Set plugin version to chylex-52

Fixes wrong recorded inputs when code completion introduces an import.

Fixes wrong recorded inputs when completing a static member with a partial type name. Example: `WiE.A` -> `WindowEvent.ACTION_EVENT_MASK`

.claude/changelog-instructions.md

@@ -0,0 +1,220 @@
+# Changelog Maintenance Instructions
+
+## Historical Context
+
+- The changelog was actively maintained until version 2.9.0
+- There's a gap from 2.10.0 through 2.27.0 where changelog wasn't maintained
+- We're resuming changelog maintenance from version 2.28.0 onwards
+- Between 2.9.0 and 2.28.0, include this note: **"Changelog was not maintained for versions 2.10.0 through 2.27.0"**
+
+## Changelog Structure
+
+### [To Be Released] Section
+- All unreleased changes from master branch go here
+- When a release is made, this section becomes the new version section
+- Create a new empty `[To Be Released]` section after each release
+
+### Version Entry Format
+```
+## 2.28.0, 2024-MM-DD
+
+### Features:
+* Feature description without ticket number
+* `CommandName` action can be used... | [VIM-XXXX](https://youtrack.jetbrains.com/issue/VIM-XXXX)
+
+### Fixes:
+* [VIM-XXXX](https://youtrack.jetbrains.com/issue/VIM-XXXX) Bug fix description
+
+### Changes:
+* Other changes
+```
+
+## How to Gather Information
+
+### 1. Check Current State
+- Read CHANGES.md to find the last documented version
+- **Important**: Only read the top portion of CHANGES.md (it's a large file)
+- Focus on the `[To Be Released]` section and recent versions
+- Note the date of the last entry
+
+### 2. Find Releases
+- Use `git tag --list --sort=-version:refname` to see all version tags
+- Tags like `2.27.0`, `2.27.1` indicate releases
+- Note: Patch releases (x.x.1, x.x.2) might be on separate branches
+- Release dates available at: https://plugins.jetbrains.com/plugin/164-ideavim/versions
+
+### 3. Review Changes
+```bash
+# Get commits since last documented version
+git log --oneline --since="YYYY-MM-DD" --first-parent master
+
+# Get merged PRs
+gh pr list --state merged --limit 100 --json number,title,author,mergedAt
+
+# Check specific release commits
+git log --oneline <previous-tag>..<new-tag>
+```
+
+**Important**: Don't just read commit messages - examine the actual changes:
+- Use `git show <commit-hash>` to see the full commit content
+- Look at modified test files to find specific examples of fixed commands
+- Check the actual code changes to understand what was really fixed or added
+- Tests often contain the best examples for changelog entries (e.g., exact commands that now work)
+
+### 4. What to Include
+- **Features**: New functionality with [VIM-XXXX] ticket numbers if available
+- **Bug Fixes**: Fixed issues with [VIM-XXXX] ticket references
+- **Breaking Changes**: Any backwards-incompatible changes
+- **Deprecations**: Features marked for future removal
+- **Merged PRs**: Reference significant PRs like "Implement vim-surround (#123)"
+  - Note: PRs have their own inclusion rules - see "Merged PRs Special Rules" section below
+
+### 5. What to Exclude
+- Dependabot PRs (author: dependabot[bot])
+- Claude-generated PRs (check PR author/title)
+- Internal refactoring with no user impact
+- Documentation-only changes (unless significant)
+- Test-only changes
+- **API module changes** (while in experimental status) - Do not log changes to the `api` module as it's currently experimental
+  - Note: This exclusion should be removed once the API status is no longer experimental
+- **Internal code changes** - Do not log coding changes that users cannot see or experience
+  - Refactoring, code cleanup, internal architecture changes
+  - Performance optimizations (unless they fix a noticeable user issue)
+  - Remember: The changelog is for users, not developers
+
+## Writing Style
+
+- **Be concise**: One line per change when possible
+- **User-focused**: Describe what changed from user's perspective
+  - Write for end users, not developers
+  - Focus on visible behavior changes, new commands, fixed issues users experience
+  - Avoid technical implementation details
+- **Include examples** when helpful:
+  - For fixes: Show the command/operation that now works correctly
+  - For features: Demonstrate the new commands or functionality
+  - Good example: "Fixed `ci"` command in empty strings" or "Added support for `gn` text object"
+  - Bad examples (too vague, unclear what was broken):
+    - "Fixed count validation in text objects"
+    - "Fixed inlay offset calculations"
+  - Better: Specify the actual case - "Fixed `3daw` deleting wrong number of words" or "Fixed cursor position with inlay hints in `f` motion"
+  - **If you can't determine the specific case from tests/code, omit the entry rather than leave it unclear**
+- **Add helpful links** for context:
+  - When mentioning IntelliJ features, search for official JetBrains documentation or blog posts
+  - When referencing Vim commands, link to Vim documentation if helpful
+  - Example: "Added support for [Next Edit Suggestion](https://blog.jetbrains.com/ai/2025/08/introducing-next-edit-suggestions-in-jetbrains-ai-assistant/)"
+  - Use web search to find the most relevant official sources
+- **Include references**: Add [VIM-XXXX] for YouTrack tickets, (#XXX) for PRs
+- **Group logically**: Features, Fixes, Changes, Merged PRs
+- **No duplication**: Each change appears in exactly ONE subsection - don't repeat items across categories
+- **Use consistent tense**: Past tense for completed work
+
+## Examples of Good Entries
+
+```
+### Features:
+* Added support for `gn` text object - select next match with `gn`, change with `cgn`
+* Implemented `:tabmove` command - use `:tabmove +1` or `:tabmove -1` to reorder tabs
+* Support for `z=` to show spelling suggestions
+* Added integration with [Next Edit Suggestion](https://blog.jetbrains.com/ai/2025/08/introducing-next-edit-suggestions-in-jetbrains-ai-assistant/) feature
+* Support for [multiple cursors](https://www.jetbrains.com/help/idea/multicursor.html) in visual mode
+
+### Fixes:
+* [VIM-3456](https://youtrack.jetbrains.com/issue/VIM-3456) Fixed cursor position after undo in visual mode
+* [VIM-3458](https://youtrack.jetbrains.com/issue/VIM-3458) Fixed `ci"` command now works correctly in empty strings
+* [VIM-3260](https://youtrack.jetbrains.com/issue/VIM-3260) Fixed `G` command at file end with count
+* [VIM-3180](https://youtrack.jetbrains.com/issue/VIM-3180) Fixed `vib` and `viB` selection in nested blocks
+
+### Merged PRs:
+* [805](https://github.com/JetBrains/ideavim/pull/805) by [chylex](https://github.com/chylex): VIM-3238 Fix recording a macro that replays another macro
+```
+
+## IMPORTANT Format Notes
+
+### For Fixes:
+Always put the ticket link FIRST, then the description:
+```
+* [VIM-XXXX](https://youtrack.jetbrains.com/issue/VIM-XXXX) Description of what was fixed
+```
+
+### For Features:
+- Without ticket: Just the description
+- With ticket: Can use either format:
+  - Description with pipe: `* Feature description | [VIM-XXXX](https://youtrack.jetbrains.com/issue/VIM-XXXX)`
+  - Link first (like fixes): `* [VIM-XXXX](https://youtrack.jetbrains.com/issue/VIM-XXXX) Feature description`
+
+### Avoid Duplication:
+- **Each change should appear in only ONE subsection**
+- If a feature is listed in Features, don't repeat it in Fixes
+- If a bug fix is in Fixes, don't list it again elsewhere
+- Choose the most appropriate category for each change
+
+### Merged PRs Special Rules:
+- **Different criteria than other sections**: The exclusion rules for Features/Fixes don't apply here
+- **Include PRs from external contributors** even if they're internal changes or refactoring
+- **List significant community contributions** regardless of whether they're user-visible
+- **Format**: PR number, author, and brief description
+- **Use PR title as-is**: Take the description directly from the PR title, don't regenerate or rewrite it
+- **Purpose**: Acknowledge community contributions and provide PR tracking
+- The "user-visible only" rule does NOT apply to this section
+
+## Process
+
+1. Read the current CHANGES.md (only the top portion - focus on `[To Be Released]` and recent versions)
+2. Check previous changelog PRs from GitHub:
+   - Review the last few changelog update PRs (use `gh pr list --search "Update changelog" --state all --limit 5`)
+   - **Read the PR comments**: Use `gh pr view <PR_NUMBER> --comments` to check for specific instructions
+   - Look for any comments or instructions about what NOT to log this time
+   - Previous PRs may contain specific exclusions or special handling instructions
+   - Pay attention to review feedback that might indicate what to avoid in future updates
+3. Check git tags for any undocumented releases
+4. Review commits and PRs since last entry
+5. Group changes by release or under [To Be Released]
+6. Update CHANGES.md maintaining existing format
+7. Update the `changeNotes` section in `build.gradle.kts` (see detailed instructions below)
+8. Create a PR only if there are changes to document:
+   - Title format: "Update changelog: <super short summary>"
+   - Example: "Update changelog: Add gn text object, fix visual mode issues"
+   - Body: Brief summary of what was added
+
+## Updating changeNotes in build.gradle.kts
+
+The `changeNotes` section in `build.gradle.kts` displays on the JetBrains Marketplace plugin page. Follow these rules:
+
+### Content Requirements
+- **Match CHANGES.md exactly**: Use the same content from the `[To Be Released]` section
+- **Don't create a shorter version**: Include all entries as they appear in CHANGES.md
+- **Keep the same level of detail**: Don't summarize or condense
+
+### HTML Formatting
+Convert Markdown to HTML format:
+- Headers: `### Features:` → `<b>Features:</b>`
+- Line breaks: Use `<br>` between items
+- Links: Convert markdown links to HTML `<a href="">` tags
+- Bullet points: Use `•` or keep `*` with proper spacing
+- Code blocks: Use `<code>` tags for commands like `<code>gn</code>`
+
+### Special Notes
+- **IMPORTANT**: Keep any existing information about the reward program in changeNotes
+- This content appears in the plugin description on JetBrains Marketplace
+
+### Example Conversion
+Markdown in CHANGES.md:
+```
+### Features:
+* Added support for `gn` text object
+* [VIM-3456](https://youtrack.jetbrains.com/issue/VIM-3456) Fixed cursor position
+```
+
+HTML in changeNotes:
+```html
+<b>Features:</b><br>
+• Added support for <code>gn</code> text object<br>
+• <a href="https://youtrack.jetbrains.com/issue/VIM-3456">VIM-3456</a> Fixed cursor position<br>
+```
+
+## Important Notes
+
+- **Don't create a PR if changelog is already up to date**
+- **Preserve existing format and structure**
+- **Maintain chronological order (newest first)**
+- **Keep the historical gap note between 2.9.0 and 2.28.0**

.devcontainer/devcontainer.json

@@ -0,0 +1,12 @@
+{
+  "name": "Java",
+  "image": "mcr.microsoft.com/devcontainers/java:1-21",
+  "features": {
+    "ghcr.io/devcontainers/features/java:1": {
+      "version": "none",
+      "installMaven": "true",
+      "mavenVersion": "3.8.6",
+      "installGradle": "true"
+    }
+  }
+}

.github/workflows/claude-code-review.yml

@@ -0,0 +1,54 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    # Optional: Only run on specific file changes
+    # paths:
+    #   - "src/**/*.ts"
+    #   - "src/**/*.tsx"
+    #   - "src/**/*.js"
+    #   - "src/**/*.jsx"
+
+jobs:
+  claude-review:
+    # Optional: Filter by PR author
+    # if: |
+    #   github.event.pull_request.user.login == 'external-contributor' ||
+    #   github.event.pull_request.user.login == 'new-developer' ||
+    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
+    
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          prompt: |
+            Please review this pull request and provide feedback on:
+            - Code quality and best practices
+            - Potential bugs or issues
+            - Performance considerations
+            - Security concerns
+            - Test coverage
+            
+            Use the repository's CLAUDE.md for guidance on style and conventions. Be constructive and helpful in your feedback.
+
+            Use `gh pr comment` with your Bash tool to leave your review as a comment on the PR.
+          
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://docs.anthropic.com/en/docs/claude-code/sdk#command-line for available options
+          claude_args: '--allowed-tools "Bash(gh issue view:*),Bash(gh search:*),Bash(gh issue list:*),Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*),Bash(gh pr list:*)"'
+

.github/workflows/claude.yml

@@ -0,0 +1,50 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it.
+          # prompt: 'Update the pull request description to include a summary of changes.'
+
+          # Optional: Add claude_args to customize behavior and configuration
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://docs.anthropic.com/en/docs/claude-code/sdk#command-line for available options
+          # claude_args: '--model claude-opus-4-1-20250805 --allowed-tools Bash(gh pr:*)'
+

.github/workflows/junie.yml

@@ -0,0 +1,21 @@
+name: Junie
+run-name: Junie run ${{ inputs.run_id }}
+
+permissions:
+  contents: write
+
+on:
+  workflow_dispatch:
+    inputs:
+      run_id:
+        description: "id of workflow process"
+        required: true
+      workflow_params:
+        description: "stringified params"
+        required: true
+
+jobs:
+  call-workflow-passing-data:
+    uses: jetbrains-junie/junie-workflows/.github/workflows/ej-issue.yml@main
+    with:
+      workflow_params: ${{ inputs.workflow_params }}

.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

.github/workflows/updateChangelogClaude.yml

@@ -0,0 +1,45 @@
+name: Update Changelog with Claude
+
+on:
+  schedule:
+    # Run every day at 5 AM UTC
+    - cron: '0 5 * * *'
+  workflow_dispatch:  # Allow manual trigger
+
+jobs:
+  update-changelog:
+    runs-on: ubuntu-latest
+    if: github.repository == 'JetBrains/ideavim'
+
+    permissions:
+      contents: write
+      pull-requests: write
+      id-token: write
+      issues: read
+      actions: read
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Need full history to analyze commits and tags
+      
+      - name: Run Claude Code to Update Changelog
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          
+          prompt: |
+            ## Task: Update the CHANGES.md Changelog File
+            
+            You need to review the latest commits and maintain the changelog file (CHANGES.md) with meaningful changes.
+            
+            Please follow the detailed changelog maintenance instructions in `.claude/changelog-instructions.md`.
+            
+            If you find changes that need documenting, update CHANGES.md and create a pull request with:
+            - Title: "Update changelog: <super short summary>"
+              Example: "Update changelog: Add gn text object, fix visual mode issues"
+            - Body: Brief summary of what was added
+          
+          # Allow Claude to use git, GitHub CLI, and web access for checking releases and tickets
+          claude_args: '--allowed-tools "Read,Edit,Bash(git:*),Bash(gh:*),WebSearch,WebFetch(domain:plugins.jetbrains.com),WebFetch(domain:youtrack.jetbrains.com),WebFetch(domain:github.com)"'

.github/workflows/updateIntellijVersions.yml

@@ -0,0 +1,47 @@
+name: Update IntelliJ Version Configurations
+
+on:
+  schedule:
+    # Run three times a year: August 15, April 30, December 1
+    # Times are in UTC
+    - cron: '0 10 15 8 *'   # August 15 at 10:00 UTC
+    - cron: '0 10 30 4 *'   # April 30 at 10:00 UTC  
+    - cron: '0 10 1 12 *'   # December 1 at 10:00 UTC
+  workflow_dispatch:  # Allow manual trigger for testing
+
+jobs:
+  update-intellij-versions:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      id-token: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+      
+      - name: Run Claude Code
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          
+          prompt: |
+            Look at the file `.teamcity/_Self/Project.kt` and check what IntelliJ versions are currently being tested (look for TestingBuildType configurations).
+            
+            Based on the current date and existing versions, determine if a new IntelliJ version should be added. 
+            IntelliJ releases new versions approximately 3 times per year:
+            - Spring release (x.1) - around March/April
+            - Summer release (x.2) - around July/August  
+            - Fall release (x.3) - around November/December
+            
+            If a new version should be added:
+            1. Add the new TestingBuildType configuration in chronological order
+            2. Create a pull request with your changes
+            
+            The configuration file is located at: `.teamcity/_Self/Project.kt`
+            Look for the section with comment `// Active tests`
+            
+            Only add a new version if it doesn't already exist and if it makes sense based on the release schedule.

.gitignore

@@ -3,6 +3,7 @@
 /.intellijPlatform/
 
 /.idea/
+!/.idea/dictionaries/project.xml
 !/.idea/scopes
 !/.idea/copyright
 !/.idea/icon.png
@@ -32,4 +33,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

.idea/dictionaries/project.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="project">
+    <words>
+      <w>overstrike</w>
+    </words>
+  </dictionary>
+</component>

.idea/gradle.xml

@@ -9,6 +9,7 @@
           <set>
             <option value="$PROJECT_DIR$" />
             <option value="$PROJECT_DIR$/annotation-processors" />
+            <option value="$PROJECT_DIR$/api" />
             <option value="$PROJECT_DIR$/scripts" />
             <option value="$PROJECT_DIR$/tests" />
             <option value="$PROJECT_DIR$/tests/java-tests" />

.idea/runConfigurations/IdeaVim_tests.xml

@@ -5,7 +5,7 @@
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
       <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
+      <option name="scriptParameters" value="-x :tests:property-tests:test -x :tests:long-running-tests:test" />
       <option name="taskDescriptions">
         <list />
       </option>
@@ -19,6 +19,7 @@
     <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
     <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
     <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
     <method v="2" />
   </configuration>
 </component>

.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 PROPERTY_TESTS = "2024.3.3"
-  const val LONG_RUNNING_TESTS = "2024.3.3"
-  const val RELEASE = "2024.3.3"
+  const val NVIM_TESTS = "2025.1"
+  const val PROPERTY_TESTS = "2025.1"
+  const val LONG_RUNNING_TESTS = "2025.1"
+  const val RELEASE = "2025.1"
 
-  const val RELEASE_DEV = "2024.3.3"
-  const val RELEASE_EAP = "2024.3.3"
+  const val RELEASE_DEV = "2025.1"
+  const val RELEASE_EAP = "2025.1"
 }

.teamcity/_Self/Project.kt

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

.teamcity/_Self/buildTypes/Compatibility.kt

@@ -43,6 +43,12 @@ 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
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}cn.mumukehao.plugin' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.magidc.ideavim.dial' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}dev.ghostflyby.ideavim.toggleIME' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.magidc.ideavim.anyObject' [latest-IU] -team-city
             """.trimIndent()
     }
   }

.teamcity/_Self/buildTypes/LongRunning.kt

@@ -25,7 +25,7 @@ object LongRunning : IdeaVimBuildType({
 
   steps {
     gradle {
-      tasks = "clean :tests:long-running-tests:testLongRunning"
+      tasks = "clean :tests:long-running-tests:test"
       buildFile = ""
       enableStacktrace = true
       jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"

.teamcity/_Self/buildTypes/Nvim.kt

@@ -39,7 +39,7 @@ object Nvim : IdeaVimBuildType({
               """.trimIndent()
     }
     gradle {
-      tasks = "clean test -Dnvim"
+      tasks = "clean test -x :tests:property-tests:test -x :tests:long-running-tests:test -Dnvim"
       buildFile = ""
       enableStacktrace = true
       jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"

.teamcity/_Self/buildTypes/PropertyBased.kt

@@ -24,7 +24,8 @@ object PropertyBased : IdeaVimBuildType({
 
   steps {
     gradle {
-      tasks = "clean :tests:property-tests:testPropertyBased"
+      clearConditions()
+      tasks = "clean :tests:property-tests:test"
       buildFile = ""
       enableStacktrace = true
       jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"

.teamcity/_Self/buildTypes/ReleasePlugin.kt

@@ -115,7 +115,7 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
     }
     script {
       name = "Run tests"
-      scriptContent = "./gradlew test"
+      scriptContent = "./gradlew test -x :tests:property-tests:test -x :tests:long-running-tests:test"
     }
     gradle {
       name = "Publish release"

.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,
@@ -40,7 +40,7 @@ open class TestingBuildType(
   steps {
     gradle {
       clearConditions()
-      tasks = "clean test"
+      tasks = "clean test -x :tests:property-tests:test -x :tests:long-running-tests:test"
       buildFile = ""
       enableStacktrace = true
       jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"

.teamcity/_Self/subprojects/GitHub.kt

@@ -15,7 +15,7 @@ object GitHub : Project({
   name = "Pull Requests checks"
   description = "Automatic checking of GitHub Pull Requests"
 
-  buildType(GithubBuildType("clean test", "Tests"))
+  buildType(GithubBuildType("clean test -x :tests:property-tests:test -x :tests:long-running-tests:test", "Tests"))
 })
 
 class GithubBuildType(command: String, desc: String) : IdeaVimBuildType({

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,50 @@ 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
+* [![icon][mail]](mailto:xinhe.wang@jetbrains.com)
+  [![icon][github]](https://github.com/wxh06)
+   
+  Xinhe Wang
+* [![icon][mail]](mailto:zuber.kuba@gmail.com)
+  [![icon][github]](https://github.com/zuberol)
+   
+  Jakub Zuber
+* [![icon][mail]](mailto:nmh9097@gmail.com)
+  [![icon][github]](https://github.com/NaMinhyeok)
+   
+  Na Minhyeok
+* [![icon][mail]](mailto:201638009+jetbrains-junie[bot]@users.noreply.github.com)
+  [![icon][github]](https://github.com/apps/jetbrains-junie)
+   
+  jetbrains-junie[bot]
+* [![icon][mail]](mailto:4416693+magidc@users.noreply.github.com)
+  [![icon][github]](https://github.com/magidc)
+   
+  magidc
+* [![icon][mail]](mailto:ricardo.rodcas@gmail.com)
+  [![icon][github]](https://github.com/magidc)
+   
+  magidc
 
 Previous contributors:
 

CLAUDE.md

@@ -0,0 +1,22 @@
+# CLAUDE.md
+
+Guidance for Claude Code when working with IdeaVim.
+
+## Quick Reference
+
+Essential commands:
+- `./gradlew runIde` - Start dev IntelliJ with IdeaVim
+- `./gradlew test -x :tests:property-tests:test -x :tests:long-running-tests:test` - Run standard tests
+
+See CONTRIBUTING.md for architecture details and complete command list.
+
+## IdeaVim-Specific Notes
+
+- Property tests can be flaky - verify if failures relate to your changes
+- Use `<Action>` in mappings, not `:action` 
+- Config file: `~/.ideavimrc` (XDG supported)
+- Goal: Match Vim functionality and architecture
+
+## Additional Documentation
+
+- Changelog maintenance: See `.claude/changelog-instructions.md`

CONTRIBUTING.md

@@ -65,7 +65,7 @@ We've prepared some useful configurations for you:
 And here are useful gradle commands:
 
 * `./gradlew runIde` — start the dev version of IntelliJ IDEA with IdeaVim installed.
-* `./gradlew test` — run tests.
+* `./gradlew test -x :tests:property-tests:test -x :tests:long-running-tests:test` — run tests.
 * `./gradlew buildPlugin` — build the plugin. The result will be located in `build/distributions`. This file can be
 installed by using `Settings | Plugin | >Gear Icon< | Install Plugin from Disk...`. You can stay with your personal build
 for a few days or send it to a friend for testing.
@@ -78,8 +78,8 @@ for a few days or send it to a friend for testing.
  - Read the javadoc for the `@VimBehaviorDiffers` annotation in the source code and fix the corresponding functionality.
  - Implement one of the requested [#vim plugin](https://youtrack.jetbrains.com/issues/VIM?q=%23Unresolved%20tag:%20%7Bvim%20plugin%7D%20sort%20by:%20votes%20)s.
 
-> :small_orange_diamond: Selected an issue to work on? Leave a comment in a YouTrack ticket or create a draft PR
-> to indicate that you've started working on it so that you might get additional guidance and feedback from the maintainers.
+> :small_orange_diamond: You may leave a comment in the YouTrack ticket or open a draft PR if you’d like early feedback
+> or want to let maintainers know you’ve started working on an issue. Otherwise, simply open a PR.
 
 ## Where to start in the codebase
 

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,
-Android Studio and other IntelliJ platform based IDEs.
+IntelliJ IDEA, PyCharm, GoLand, CLion, PhpStorm, WebStorm, RubyMine, DataGrip, DataSpell, Rider, Cursive,
+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
-
-[IdeaVim plugins](https://github.com/JetBrains/ideavim/wiki/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
+* Vim script
+* IdeaVim plugins
 
 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 Roadmap](https://github.com/JetBrains/ideavim/blob/master/vimscript-info/VIMSCRIPT_ROADMAP.md).
+[Vim Script Discussion](https://github.com/JetBrains/ideavim/discussions/357).
 
 
 ### IDE specific options

annotation-processors/build.gradle.kts

@@ -8,7 +8,7 @@
 
 plugins {
   kotlin("jvm")
-  kotlin("plugin.serialization") version "2.0.21"
+  kotlin("plugin.serialization") version "2.2.0"
 }
 
 val kotlinxSerializationVersion: String by project
@@ -21,10 +21,11 @@ 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.2")
   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")
     exclude("org.jetbrains.kotlin", "kotlin-stdlib-common")
   }
+  api(project(":api"))
 }

annotation-processors/src/main/kotlin/com/intellij/vim/processors/CommandOrMotionProcessor.kt

@@ -31,12 +31,15 @@ class CommandOrMotionProcessor(private val environment: SymbolProcessorEnvironme
   private val json = Json { prettyPrint = true }
 
   override fun process(resolver: Resolver): List<KSAnnotated> {
+    val commandsFile = environment.options["commands_file"]
+    if (commandsFile == null) return emptyList()
+
     resolver.getAllFiles().forEach { it.accept(visitor, Unit) }
 
     val generatedDirPath = Path(environment.options["generated_directory"]!!)
     Files.createDirectories(generatedDirPath)
 
-    val filePath = generatedDirPath.resolve(environment.options["commands_file"]!!)
+    val filePath = generatedDirPath.resolve(commandsFile)
     val sortedCommands = commands.sortedWith(compareBy({ it.keys }, { it.`class` }))
     val fileContent = json.encodeToString(sortedCommands)
     filePath.writeText(fileContent)

annotation-processors/src/main/kotlin/com/intellij/vim/processors/ExCommandProcessor.kt

@@ -31,12 +31,15 @@ class ExCommandProcessor(private val environment: SymbolProcessorEnvironment): S
   private val json = Json { prettyPrint = true }
 
   override fun process(resolver: Resolver): List<KSAnnotated> {
+    val exCommandsFile = environment.options["ex_commands_file"]
+    if (exCommandsFile == null) return emptyList()
+
     resolver.getAllFiles().forEach { it.accept(visitor, Unit) }
 
     val generatedDirPath = Path(environment.options["generated_directory"]!!)
     Files.createDirectories(generatedDirPath)
 
-    val filePath = generatedDirPath.resolve(environment.options["ex_commands_file"]!!)
+    val filePath = generatedDirPath.resolve(exCommandsFile)
     val sortedCommandToClass = commandToClass.toList().sortedWith(compareBy({ it.first }, { it.second })).toMap()
     val fileContent = json.encodeToString(sortedCommandToClass)
     filePath.writeText(fileContent)

annotation-processors/src/main/kotlin/com/intellij/vim/processors/ExtensionsProcessor.kt

@@ -0,0 +1,78 @@
+/*
+ * 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.intellij.vim.processors
+
+import com.google.devtools.ksp.KspExperimental
+import com.google.devtools.ksp.getAnnotationsByType
+import com.google.devtools.ksp.processing.Resolver
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.symbol.KSAnnotated
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+import com.google.devtools.ksp.symbol.KSFile
+import com.google.devtools.ksp.symbol.KSFunctionDeclaration
+import com.google.devtools.ksp.symbol.KSVisitorVoid
+import com.intellij.vim.api.VimPlugin
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import java.nio.file.Files
+import kotlin.io.path.Path
+import kotlin.io.path.writeText
+
+// Used for processing VimPlugin annotations
+class ExtensionsProcessor(private val environment: SymbolProcessorEnvironment) : SymbolProcessor {
+  private val visitor = ExtensionsVisitor()
+  private val declaredExtensions = mutableListOf<KspExtensionBean>()
+
+  private val json = Json { prettyPrint = true }
+
+  override fun process(resolver: Resolver): List<KSAnnotated> {
+    val extensionsFile = environment.options["extensions_file"]
+    if (extensionsFile == null) return emptyList()
+
+    resolver.getAllFiles().forEach { it.accept(visitor, Unit) }
+
+    val generatedDirPath = Path(environment.options["generated_directory"]!!)
+    Files.createDirectories(generatedDirPath)
+
+    val filePath = generatedDirPath.resolve(environment.options["extensions_file"]!!)
+    val sortedExtensions = declaredExtensions.toList().sortedWith(compareBy { it.extensionName })
+
+    val fileContent = json.encodeToString(sortedExtensions)
+    filePath.writeText(fileContent)
+
+    return emptyList()
+  }
+
+
+  private inner class ExtensionsVisitor : KSVisitorVoid() {
+    @OptIn(KspExperimental::class)
+    override fun visitFunctionDeclaration(function: KSFunctionDeclaration, data: Unit) {
+      val pluginAnnotation = function.getAnnotationsByType(VimPlugin::class).firstOrNull() ?: return
+      val pluginName = pluginAnnotation.name
+      val functionPath = function.simpleName.asString()
+
+      // Extensions are not declared as part of class, however, when Kotlin code is decompiled to Java,
+      // function `fun init()` in a file File.kt, will be a static method in a class FileKt since Java
+      // does not support top-level functions. Then, it can be loaded with class loader.
+
+      val surroundingFileName = function.containingFile?.fileName?.removeSuffix(".kt") ?: return
+      val packageName = function.packageName.asString()
+
+      val className = "$packageName.${surroundingFileName}Kt"
+
+      val kspExtensionBean = KspExtensionBean(pluginName, functionPath, className)
+      declaredExtensions.add(kspExtensionBean)
+    }
+
+    override fun visitFile(file: KSFile, data: Unit) {
+      file.declarations.forEach { it.accept(this, Unit) }
+    }
+  }
+}

annotation-processors/src/main/kotlin/com/intellij/vim/processors/KspExtensionBean.kt

@@ -0,0 +1,14 @@
+/*
+ * 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.intellij.vim.processors
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class KspExtensionBean(val extensionName: String, val functionName: String, val className: String)

annotation-processors/src/main/kotlin/com/intellij/vim/processors/VimscriptFunctionProcessor.kt

@@ -31,12 +31,15 @@ class VimscriptFunctionProcessor(private val environment: SymbolProcessorEnviron
   private val json = Json { prettyPrint = true }
 
   override fun process(resolver: Resolver): List<KSAnnotated> {
+    val vimscriptFunctionsFile = environment.options["vimscript_functions_file"]
+    if (vimscriptFunctionsFile == null) return emptyList()
+
     resolver.getAllFiles().forEach { it.accept(visitor, Unit) }
 
     val generatedDirPath = Path(environment.options["generated_directory"]!!)
     Files.createDirectories(generatedDirPath)
 
-    val filePath = generatedDirPath.resolve(environment.options["vimscript_functions_file"]!!)
+    val filePath = generatedDirPath.resolve(vimscriptFunctionsFile)
     val sortedNameToClass = nameToClass.toList().sortedWith(compareBy({ it.first }, { it.second })).toMap()
     val fileContent = json.encodeToString(sortedNameToClass)
     filePath.writeText(fileContent)

annotation-processors/src/main/kotlin/com/intellij/vim/providers/ExtensionsProcessorProvider.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.intellij.vim.providers
+
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
+import com.intellij.vim.processors.ExtensionsProcessor
+
+class ExtensionsProcessorProvider: SymbolProcessorProvider {
+  override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor {
+    return ExtensionsProcessor(environment)
+  }
+}

annotation-processors/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -1,3 +1,4 @@
 com.intellij.vim.providers.CommandOrMotionProcessorProvider
 com.intellij.vim.providers.ExCommandProcessorProvider
 com.intellij.vim.providers.VimscriptFunctionProcessorProvider
+com.intellij.vim.providers.ExtensionsProcessorProvider

api/build.gradle.kts

@@ -0,0 +1,29 @@
+/*
+ * 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.
+ */
+
+plugins {
+  kotlin("jvm")
+}
+
+val kotlinVersion: String by project
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testImplementation(platform("org.junit:junit-bom:6.0.0"))
+  testImplementation("org.junit.jupiter:junit-jupiter")
+  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion")
+  compileOnly("org.jetbrains:annotations:26.0.2-1")
+  compileOnly("org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.10.2")
+}
+
+tasks.test {
+  useJUnitPlatform()
+}

api/src/main/kotlin/com/intellij/vim/api/VimApi.kt

@@ -0,0 +1,545 @@
+/*
+ * 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.intellij.vim.api
+
+import com.intellij.vim.api.models.Mode
+import com.intellij.vim.api.models.Path
+import com.intellij.vim.api.scopes.DigraphScope
+import com.intellij.vim.api.scopes.MappingScope
+import com.intellij.vim.api.scopes.ModalInput
+import com.intellij.vim.api.scopes.OptionScope
+import com.intellij.vim.api.scopes.OutputPanelScope
+import com.intellij.vim.api.scopes.VimApiDsl
+import com.intellij.vim.api.scopes.commandline.CommandLineScope
+import com.intellij.vim.api.scopes.editor.EditorScope
+import org.jetbrains.annotations.ApiStatus
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Entry point of the Vim API
+ *
+ * The API is currently in experimental status and not suggested to be used.
+ */
+@ApiStatus.Experimental
+@VimApiDsl
+interface VimApi {
+  /**
+   * Represents the current mode in Vim.
+   *
+   * Example usage:
+   *
+   * **Getting the Current Mode**
+   * ```kotlin
+   * val currentMode = mode
+   * println("Current Vim Mode: $currentMode")
+   * ```
+   *
+   * The set of mode is currently an experimental operation as the contracts of it are getting polished.
+   *   We suggest currently not using it.
+   */
+  @set:ApiStatus.Experimental
+  var mode: Mode
+
+  /**
+   * Retrieves a variable of the specified type and name.
+   * Use the extension function `getVariable<String>("name")`
+   */
+  fun <T : Any> getVariable(name: String, type: KType): T?
+
+  /**
+   * Sets a variable with the specified name and value.
+   * Use the extension function `setVariable<String>("name", 1)`
+   *
+   * In Vim, this is equivalent to `let varname = value`.
+   */
+  fun setVariable(name: String, value: Any, type: KType)
+
+  /**
+   * Exports a function that can be used as an operator function in Vim.
+   *
+   * In Vim, operator functions are used with the `g@` operator to create custom operators.
+   *
+   * Example usage:
+   * ```kotlin
+   * exportOperatorFunction("MyOperator") {
+   *     editor {
+   *         // Perform operations on the selected text
+   *         true // Return success
+   *     }
+   * }
+   * ```
+   *
+   * @param name The name to register the function under
+   * @param function The function to execute when the operator is invoked
+   */
+  fun exportOperatorFunction(name: String, function: suspend VimApi.() -> Boolean)
+
+  /**
+   * Sets the current operator function to use with the `g@` operator.
+   *
+   * In Vim, this is equivalent to setting the 'operatorfunc' option.
+   *
+   * @param name The name of the previously exported operator function
+   */
+  fun setOperatorFunction(name: String)
+
+  /**
+   * Executes normal mode commands as if they were typed.
+   *
+   * In Vim, this is equivalent to the `:normal` command.
+   *
+   * Example usage:
+   * ```kotlin
+   * normal("gg")  // Go to the first line
+   * normal("dw")  // Delete word
+   * ```
+   *
+   * @param command The normal mode command string to execute
+   */
+  fun normal(command: String)
+
+  /**
+   * Executes a block of code in the context of the currently focused editor.
+   *
+   * Example usage:
+   * ```kotlin
+   * editor {
+   *     read {
+   *       // executed under read lock
+   *     }
+   * }
+   * ```
+   *
+   * @param block The code block to execute within editor scope
+   * @return The result of the block execution
+   */
+  fun <T> editor(block: EditorScope.() -> T): T
+
+  /**
+   * Executes a block of code for each editor.
+   *
+   * This function allows performing operations on all available editors.
+   *
+   * Example usage:
+   * ```kotlin
+   * forEachEditor {
+   *     // Perform some operation on each editor
+   * }
+   * ```
+   *
+   * @param block The code block to execute for each editor
+   * @return A list containing the results of executing the block on each editor
+   */
+  fun <T> forEachEditor(block: EditorScope.() -> T): List<T>
+
+  /**
+   * Provides access to key mapping functionality.
+   *
+   * Example usage:
+   * ```kotlin
+   * mappings {
+   *    nmap("jk", "<Esc>")
+   * }
+   * ```
+   *
+   * @param block The code block to execute within the mapping scope
+   */
+  fun mappings(block: MappingScope.() -> Unit)
+
+//  /**
+//   * Provides access to event listener functionality.
+//   *
+//   * Example usage:
+//   * ```kotlin
+//   * listeners {
+//   *     // Register a listener for mode changes
+//   *     onModeChange { oldMode ->
+//   *         println("Mode changed from $oldMode")
+//   *     }
+//   * }
+//   * ```
+//   *
+//   * @param block The code block to execute within the listeners scope
+//   */
+//  fun listeners(block: ListenersScope.() -> Unit)
+
+  /**
+   * Provides access to Vim's output panel functionality.
+   *
+   * Example usage:
+   * ```kotlin
+   * outputPanel {
+   *     // Print a message to the output panel
+   *     setText("Hello from IdeaVim plugin!")
+   * }
+   * ```
+   *
+   * @param block The code block to execute within the output panel scope
+   */
+  fun outputPanel(block: OutputPanelScope.() -> Unit)
+
+  /**
+   * Provides access to modal input functionality.
+   *
+   * Example usage:
+   * ```kotlin
+   * modalInput()
+   *  .inputChar(label) { char ->
+   *    // get char that user entered
+   *  }
+   * ```
+   *
+   * @return A ModalInput instance that can be used to request user input
+   */
+  fun modalInput(): ModalInput
+
+  /**
+   * Provides access to Vim's command line functionality.
+   *
+   * Example usage:
+   * ```kotlin
+   * commandLine {
+   *    // get current command line text
+   *    read {
+   *      // executed under read lock
+   *      text
+   *    }
+   * }
+   * ```
+   *
+   * @param block The code block to execute with command line scope
+   */
+  fun commandLine(block: CommandLineScope.() -> Unit)
+
+  /**
+   * Provides access to Vim's options functionality.
+   *
+   * Example usage:
+   * ```kotlin
+   * // Get option value
+   * val history = option { get<Int>("history") }
+   * 
+   * // Set option value and return result
+   * val wasSet = option { 
+   *     set("number", true)
+   *     true
+   * }
+   * 
+   * // Multiple operations
+   * option {
+   *     set("ignorecase", true)
+   *     append("virtualedit", "block")
+   * }
+   * ```
+   *
+   * @param block The code block to execute within the option scope
+   * @return The result of the block execution
+   */
+  fun <T> option(block: OptionScope.() -> T): T
+
+  /**
+   * Provides access to Vim's digraph functionality.
+   *
+   * Example usage:
+   * ```kotlin
+   * digraph {
+   *     // Add a new digraph
+   *     add("a:", 'ä')
+   * }
+   * ```
+   *
+   * @param block The code block to execute within the digraph scope
+   */
+  fun digraph(block: DigraphScope.() -> Unit)
+
+  /**
+   * Gets the number of tabs in the current window.
+   */
+  val tabCount: Int
+
+  /**
+   * The index of the current tab or null if there is no tab selected or no tabs are open
+   */
+  val currentTabIndex: Int?
+
+  /**
+   * Removes a tab at the specified index and selects another tab.
+   *
+   * @param indexToDelete The index of the tab to delete
+   * @param indexToSelect The index of the tab to select after deletion
+   */
+  fun removeTabAt(indexToDelete: Int, indexToSelect: Int)
+
+  /**
+   * Moves the current tab to the specified index.
+   *
+   * @param index The index to move the current tab to
+   * @throws IllegalStateException if there is no tab selected or no tabs are open
+   */
+  fun moveCurrentTabToIndex(index: Int)
+
+  /**
+   * Closes all tabs except the current one.
+   *
+   * @throws IllegalStateException if there is no tab selected
+   */
+  fun closeAllExceptCurrentTab()
+
+  /**
+   * Checks if a pattern matches a text.
+   *
+   * @param pattern The regular expression pattern to match
+   * @param text The text to check against the pattern
+   * @param ignoreCase Whether to ignore case when matching
+   * @return True if the pattern matches the text, false otherwise
+   */
+  fun matches(pattern: String, text: String, ignoreCase: Boolean = false): Boolean
+
+  /**
+   * Finds all matches of a pattern in a text.
+   *
+   * @param text The text to search in
+   * @param pattern The regular expression pattern to search for
+   * @return A list of pairs representing the start and end offsets of each match
+   */
+  fun getAllMatches(text: String, pattern: String): List<Pair<Int, Int>>
+
+  /**
+   * Selects the next window in the editor.
+   */
+  fun selectNextWindow()
+
+  /**
+   * Selects the previous window in the editor.
+   */
+  fun selectPreviousWindow()
+
+  /**
+   * Selects a window by its index.
+   *
+   * @param index The index of the window to select (1-based).
+   */
+  fun selectWindow(index: Int)
+
+  /**
+   * Splits the current window vertically and optionally opens a file in the new window.
+   *
+   * @param filePath Path of the file to open in the new window. If null, the new window will show the same file.
+   */
+  fun splitWindowVertically(filePath: Path? = null)
+
+  /**
+   * Splits the current window horizontally and optionally opens a file in the new window.
+   *
+   * @param filePath Path of the file to open in the new window. If null, the new window will show the same file.
+   */
+  fun splitWindowHorizontally(filePath: Path? = null)
+
+  /**
+   * Closes all windows except the current one.
+   */
+  fun closeAllExceptCurrentWindow()
+
+  /**
+   * Closes the current window.
+   */
+  fun closeCurrentWindow()
+
+  /**
+   * Closes all windows in the editor.
+   */
+  fun closeAllWindows()
+
+  /**
+   * Parses and executes the given Vimscript string.
+   *
+   * @param script The Vimscript string to execute
+   * @return The result of the execution, which can be Success or Error
+   */
+  fun execute(script: String): Boolean
+
+  /**
+   * Registers a new Vim command.
+   *
+   * Example usage:
+   * ```
+   * command("MyCommand") { cmd ->
+   *     println("Command executed: $cmd")
+   * }
+   * ```
+   *
+   * @param command The name of the command to register, as entered by the user.
+   * @param block The logic to execute when the command is invoked. Receives the command name
+   *              entered by the user as a parameter.
+   */
+  fun command(command: String, block: VimApi.(String) -> Unit)
+
+  /**
+   * Gets keyed data from a Vim window.
+   *
+   * @param key The key to retrieve data for
+   * @return The data associated with the key, or null if no data is found
+   */
+  fun <T> getDataFromWindow(key: String): T?
+
+  /**
+   * Stores keyed user data in a Vim window.
+   *
+   * @param key The key to store data for
+   * @param data The data to store
+   */
+  fun <T> putDataToWindow(key: String, data: T)
+
+  /**
+   * Gets data from buffer.
+   *
+   * @param key The key to retrieve data for
+   * @return The data associated with the key, or null if no data is found
+   */
+  fun <T> getDataFromBuffer(key: String): T?
+
+  /**
+   * Puts data to buffer.
+   *
+   * @param key The key to store data for
+   * @param data The data to store
+   */
+  fun <T> putDataToBuffer(key: String, data: T)
+
+  /**
+   * Gets data from tab (group of windows).
+   *
+   * @param key The key to retrieve data for
+   * @return The data associated with the key, or null if no data is found
+   */
+  fun <T> getDataFromTab(key: String): T?
+
+  /**
+   * Puts data to tab (group of windows).
+   *
+   * @param key The key to store data for
+   * @param data The data to store
+   */
+  fun <T> putDataToTab(key: String, data: T)
+
+  /**
+   * Gets data from window or puts it if it doesn't exist.
+   *
+   * @param key The key to retrieve or store data for
+   * @param provider A function that provides the data if it doesn't exist
+   * @return The existing data or the newly created data
+   */
+  fun <T> getOrPutWindowData(key: String, provider: () -> T): T =
+    getDataFromWindow(key) ?: provider().also { putDataToWindow(key, it) }
+
+  /**
+   * Gets data from buffer or puts it if it doesn't exist.
+   *
+   * @param key The key to retrieve or store data for
+   * @param provider A function that provides the data if it doesn't exist
+   * @return The existing data or the newly created data
+   */
+  fun <T> getOrPutBufferData(key: String, provider: () -> T): T =
+    getDataFromBuffer(key) ?: provider().also { putDataToBuffer(key, it) }
+
+  /**
+   * Gets data from tab or puts it if it doesn't exist.
+   *
+   * @param key The key to retrieve or store data for
+   * @param provider A function that provides the data if it doesn't exist
+   * @return The existing data or the newly created data
+   */
+  fun <T> getOrPutTabData(key: String, provider: () -> T): T =
+    getDataFromTab(key) ?: provider().also { putDataToTab(key, it) }
+
+  /**
+   * Saves the current file.
+   */
+  fun saveFile()
+
+  /**
+   * Closes the current file.
+   */
+  fun closeFile()
+
+  /**
+   * Finds the start offset of the next word in camel case or snake case text.
+   *
+   * @param chars The character sequence to search in (e.g., document text)
+   * @param startIndex The index to start searching from (inclusive). Must be within the bounds of chars: [0, chars.length)
+   * @param count Find the [count]-th occurrence. Must be greater than 0.
+   * @return The offset of the next word start, or null if not found
+   */
+  fun getNextCamelStartOffset(chars: CharSequence, startIndex: Int, count: Int = 1): Int?
+
+  /**
+   * Finds the start offset of the previous word in camel case or snake case text.
+   *
+   * @param chars The character sequence to search in (e.g., document text)
+   * @param endIndex The index to start searching backward from (exclusive). Must be within the bounds of chars: [0, chars.length]
+   * @param count Find the [count]-th occurrence. Must be greater than 0.
+   * @return The offset of the previous word start, or null if not found
+   */
+  fun getPreviousCamelStartOffset(chars: CharSequence, endIndex: Int, count: Int = 1): Int?
+
+  /**
+   * Finds the end offset of the next word in camel case or snake case text.
+   *
+   * @param chars The character sequence to search in (e.g., document text)
+   * @param startIndex The index to start searching from (inclusive). Must be within the bounds of chars: [0, chars.length)
+   * @param count Find the [count]-th occurrence. Must be greater than 0.
+   * @return The offset of the next word end, or null if not found
+   */
+  fun getNextCamelEndOffset(chars: CharSequence, startIndex: Int, count: Int = 1): Int?
+
+  /**
+   * Finds the end offset of the previous word in camel case or snake case text.
+   *
+   * @param chars The character sequence to search in (e.g., document text)
+   * @param endIndex The index to start searching backward from (exclusive). Must be within the bounds of chars: [0, chars.length]
+   * @param count Find the [count]-th occurrence. Must be greater than 0.
+   * @return The offset of the previous word end, or null if not found
+   */
+  fun getPreviousCamelEndOffset(chars: CharSequence, endIndex: Int, count: Int = 1): Int?
+}
+
+/**
+ * Sets a variable with the specified name and value.
+ *
+ * In Vim, this is equivalent to `let varname = value`.
+ *
+ * Example usage:
+ * ```
+ * setVariable<Int>("g:my_var", 42)
+ * ```
+ *
+ * @param name The name of the variable, optionally prefixed with a scope (g:, b:, etc.)
+ * @param value The value to set
+ */
+inline fun <reified T : Any> VimApi.setVariable(name: String, value: T) {
+  val kType: KType = typeOf<T>()
+  setVariable(name, value, kType)
+}
+
+/**
+ * Retrieves a variable of the specified type and name.
+ *
+ * Example usage:
+ * ```
+ * val value: String? = getVariable<String>("myVariable")
+ * ```
+ *
+ * @param name The name of the variable to retrieve.
+ * @return The variable of type `T` if found, otherwise `null`.
+ */
+inline fun <reified T : Any> VimApi.getVariable(name: String): T? {
+  val kType: KType = typeOf<T>()
+  return getVariable(name, kType)
+}

api/src/main/kotlin/com/intellij/vim/api/VimPlugin.kt

@@ -0,0 +1,18 @@
+/*
+ * 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.intellij.vim.api
+
+/**
+ * Annotation used to describe a Vim plugin.
+ *
+ * @property name Specifies the name of the plugin.
+ */
+@Target(AnnotationTarget.FUNCTION)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class VimPlugin(val name: String)

api/src/main/kotlin/com/intellij/vim/api/models/ApiModels.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.intellij.vim.api.models
+
+/**
+ * Represents the type of text selection in Vim.
+ */
+enum class TextType {
+  /**
+   * Character-wise selection, where text is selected character by character.
+   */
+  CHARACTER_WISE,
+
+  /**
+   * Line-wise selection, where text is selected line by line.
+   */
+  LINE_WISE,
+
+  /**
+   * Block-wise selection, where text is selected in a rectangular block.
+   */
+  BLOCK_WISE,
+}
+
+/**
+ * Represents a line of text in the editor.
+ *
+ * @property number The line number (0-based or 1-based depending on context).
+ * @property text The content of the line.
+ * @property start The offset of the first character in the line.
+ * @property end The offset after the last character in the line.
+ */
+data class Line(val number: Int, val text: String, val start: Int, val end: Int)
+
+/**
+ * Represents a caret with its associated information.
+ * A pair of [CaretId] and [CaretInfo].
+ */
+typealias CaretData = Pair<CaretId, CaretInfo>
+
+/**
+ * A unique identifier for a caret in the editor.
+ *
+ * @property id The string representation of the caret identifier.
+ */
+@JvmInline
+value class CaretId(val id: String)
+
+/**
+ * Contains information about a caret's position and selection.
+ *
+ * @property offset The current offset (position) of the caret in the document.
+ * @property selection The selection range as a pair of start and end offsets, or null if no selection.
+ */
+data class CaretInfo(
+  val offset: Int,
+  val selection: Pair<Int, Int>?,
+)
+
+/**
+ * Represents an identifier for a highlight in the editor.
+ * Used for tracking and managing highlights applied to text.
+ */
+interface HighlightId

api/src/main/kotlin/com/intellij/vim/api/models/Color.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.intellij.vim.api.models
+
+/**
+ * Represents a color in RGBA format.
+ *
+ * @property hexCode The string representation of the color in hex format (#RRGGBB or #RRGGBBAA).
+ */
+data class Color(
+  val hexCode: String,
+) {
+  /**
+   * Creates a color from individual RGB(A) components.
+   *
+   * @param r Red component (0-255).
+   * @param g Green component (0-255).
+   * @param b Blue component (0-255).
+   * @param a Alpha component (0-255), defaults to 255 (fully opaque).
+   */
+  constructor(r: Int, g: Int, b: Int, a: Int = 255) : this(String.format("#%02x%02x%02x%02x", r, g, b, a))
+
+  /**
+   * The red component of the color (0-255).
+   */
+  val r: Int = hexCode.substring(1..2).toInt(16)
+
+  /**
+   * The green component of the color (0-255).
+   */
+  val g: Int = hexCode.substring(3..4).toInt(16)
+
+  /**
+   * The blue component of the color (0-255).
+   */
+  val b: Int = hexCode.substring(5..6).toInt(16)
+
+  /**
+   * The alpha component of the color (0-255).
+   * Defaults to 255 (fully opaque) if not specified in the hex code.
+   */
+  val a: Int = if (hexCode.length == 9) hexCode.substring(7..8).toInt(16) else 255
+
+  init {
+    require(hexCode.matches(Regex("^#[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$"))) {
+      "Hex code should be in format #RRGGBB[AA]"
+    }
+  }
+}

api/src/main/kotlin/com/intellij/vim/api/models/Jump.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.intellij.vim.api.models
+
+import org.jetbrains.annotations.Range
+
+/**
+ * Represents a Vim jump location.
+ */
+data class Jump(
+  /**
+   * The 0-based line number of the jump.
+   */
+  val line: @Range(from = 0, to = Int.MAX_VALUE.toLong()) Int,
+
+  /**
+   * The 0-based column number of the jump.
+   */
+  val col: @Range(from = 0, to = Int.MAX_VALUE.toLong()) Int,
+
+  /**
+   * The file path where the jump is located.
+   */
+  val filepath: Path,
+)

api/src/main/kotlin/com/intellij/vim/api/models/Mark.kt

@@ -0,0 +1,36 @@
+/*
+ * 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.intellij.vim.api.models
+
+import org.jetbrains.annotations.Range
+
+/**
+ * Represents a Vim mark.
+ */
+data class Mark(
+  /**
+   * The character key of the mark (a-z for local marks, A-Z for global marks).
+   */
+  val key: Char,
+
+  /**
+   * The 0-based line number of the mark.
+   */
+  val line: @Range(from = 0, to = Int.MAX_VALUE.toLong()) Int,
+
+  /**
+   * The 0-based column number of the mark.
+   */
+  val col: @Range(from = 0, to = Int.MAX_VALUE.toLong()) Int,
+
+  /**
+   * The file path where the mark is located.
+   */
+  val filePath: Path,
+)

api/src/main/kotlin/com/intellij/vim/api/models/Mode.kt

@@ -0,0 +1,140 @@
+/*
+ * 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.intellij.vim.api.models
+
+
+/**
+ * Represents a Vim editor mode.
+ */
+enum class Mode {
+  /**
+   * Normal mode - the default mode where commands and motions can be executed.
+   */
+  NORMAL,
+
+  /**
+   * Operator-pending mode - entered after an operator command is given but before a motion is provided.
+   */
+  OP_PENDING,
+
+  /**
+   * Operator-pending mode with forced characterwise operation.
+   */
+  OP_PENDING_CHARACTERWISE,
+
+  /**
+   * Operator-pending mode with forced linewise operation.
+   */
+  OP_PENDING_LINEWISE,
+
+  /**
+   * Operator-pending mode with forced blockwise operation.
+   */
+  OP_PENDING_BLOCKWISE,
+
+  /**
+   * Normal mode using i_CTRL-O in Insert-mode.
+   */
+  NORMAL_FROM_INSERT,
+
+  /**
+   * Normal mode using i_CTRL-O in Replace-mode.
+   */
+  NORMAL_FROM_REPLACE,
+
+  /**
+   * Normal mode using i_CTRL-O in Virtual-Replace-mode.
+   */
+  NORMAL_FROM_VIRTUAL_REPLACE,
+
+  /**
+   * Visual mode with character-wise selection.
+   */
+  VISUAL_CHARACTER,
+
+  /**
+   * Visual mode with character-wise selection using v_CTRL-O in Select mode.
+   */
+  VISUAL_CHARACTER_FROM_SELECT,
+
+  /**
+   * Visual mode with line-wise selection.
+   */
+  VISUAL_LINE,
+
+  /**
+   * Visual mode with line-wise selection using v_CTRL-O in Select mode.
+   */
+  VISUAL_LINE_FROM_SELECT,
+
+  /**
+   * Visual mode with block-wise selection.
+   */
+  VISUAL_BLOCK,
+
+  /**
+   * Visual mode with block-wise selection using v_CTRL-O in Select mode.
+   */
+  VISUAL_BLOCK_FROM_SELECT,
+
+  /**
+   * Select mode with character-wise selection.
+   */
+  SELECT_CHARACTER,
+
+  /**
+   * Select mode with line-wise selection.
+   */
+  SELECT_LINE,
+
+  /**
+   * Select mode with block-wise selection.
+   */
+  SELECT_BLOCK,
+
+  /**
+   * Insert mode - used for inserting text.
+   */
+  INSERT,
+
+  /**
+   * Replace mode - used for replacing existing text.
+   */
+  REPLACE,
+
+  /**
+   * Command-line mode - used for entering Ex commands.
+   */
+  COMMAND_LINE;
+
+  /**
+   * Returns the TextType associated with this mode, if applicable.
+   * Only visual and select modes have a TextType.
+   */
+  val selectionType: TextType?
+    get() = when (this) {
+      VISUAL_CHARACTER, VISUAL_CHARACTER_FROM_SELECT, SELECT_CHARACTER -> TextType.CHARACTER_WISE
+      VISUAL_LINE, VISUAL_LINE_FROM_SELECT, SELECT_LINE -> TextType.LINE_WISE
+      VISUAL_BLOCK, VISUAL_BLOCK_FROM_SELECT, SELECT_BLOCK -> TextType.BLOCK_WISE
+      else -> null
+    }
+
+  /**
+   * Returns true if this mode is a visual mode.
+   */
+  val isVisual: Boolean
+    get() = this == VISUAL_CHARACTER || this == VISUAL_LINE || this == VISUAL_BLOCK ||
+      this == VISUAL_CHARACTER_FROM_SELECT || this == VISUAL_LINE_FROM_SELECT || this == VISUAL_BLOCK_FROM_SELECT
+
+  /**
+   * Returns true if this mode is a select mode.
+   */
+  val isSelect: Boolean
+    get() = this == SELECT_CHARACTER || this == SELECT_LINE || this == SELECT_BLOCK
+}

api/src/main/kotlin/com/intellij/vim/api/models/Path.kt

@@ -0,0 +1,26 @@
+/*
+ * 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.intellij.vim.api.models
+
+/**
+ * Represents a path.
+ */
+interface Path {
+  /**
+   * The protocol part of the path.
+   */
+  val protocol: String
+
+  /**
+   * The segments of the path as an array of strings.
+   */
+  val path: Array<String>
+
+  companion object
+}

api/src/main/kotlin/com/intellij/vim/api/models/Range.kt

@@ -0,0 +1,42 @@
+/*
+ * 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.intellij.vim.api.models
+
+/**
+ * Represents a range of text in the editor.
+ * Can be either a simple linear range or a block (rectangular) range.
+ */
+sealed interface Range {
+  /**
+   * Represents a simple linear range of text from start to end offset.
+   *
+   * @property start The starting offset of the range.
+   * @property end The ending offset of the range (exclusive).
+   */
+  data class Simple(val start: Int, val end: Int) : Range
+
+  /**
+   * Represents a block (rectangular) selection consisting of multiple simple ranges.
+   * Each simple range typically represents a line segment in the block selection.
+   *
+   * @property ranges An array of simple ranges that make up the block selection.
+   */
+  data class Block(val ranges: Array<Simple>) : Range {
+    override fun equals(other: Any?): Boolean {
+      if (this === other) return true
+      if (javaClass != other?.javaClass) return false
+      other as Block
+      return ranges.contentEquals(other.ranges)
+    }
+
+    override fun hashCode(): Int {
+      return ranges.contentHashCode()
+    }
+  }
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/DigraphScope.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.intellij.vim.api.scopes
+
+/**
+ * Scope for functions that provide working with digraphs.
+ */
+@VimApiDsl
+interface DigraphScope {
+  /**
+   * Gets the character for a digraph.
+   *
+   * In Vim, this is equivalent to entering CTRL-K followed by the two characters in insert mode.
+   * Example: CTRL-K a: produces 'ä'
+   *
+   * @param ch1 The first character of the digraph
+   * @param ch2 The second character of the digraph
+   * @return The Unicode codepoint of the character represented by the digraph, or the codepoint of ch2 if no digraph is found
+   */
+  fun getCharacter(ch1: Char, ch2: Char): Int
+
+  /**
+   * Adds a custom digraph.
+   *
+   * In Vim, this is equivalent to the `:digraph` command with arguments.
+   * Example: `:digraph a: 228` adds a digraph where 'a:' produces 'ä'
+   *
+   * @param ch1 The first character of the digraph
+   * @param ch2 The second character of the digraph
+   * @param codepoint The Unicode codepoint of the character to associate with the digraph
+   */
+  fun add(ch1: Char, ch2: Char, codepoint: Int)
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/ListenersScope.kt

@@ -0,0 +1,189 @@
+/*
+ * 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.intellij.vim.api.scopes
+
+import com.intellij.vim.api.VimApi
+import com.intellij.vim.api.models.CaretId
+import com.intellij.vim.api.models.Mode
+import com.intellij.vim.api.models.Range
+
+/**
+ * Scope that provides access to various listeners.
+ */
+@VimApiDsl
+interface ListenersScope {
+  /**
+   * Registers a callback that is invoked when the editor mode changes.
+   *
+   * The callback receives the previous mode as a parameter.
+   *
+   * Example:
+   * ```kotlin
+   * listeners {
+   *   onModeChange { oldMode ->
+   *     if (mode == Mode.INSERT) {
+   *       // Do something when entering INSERT mode
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when the mode changes
+   */
+  fun onModeChange(callback: suspend VimApi.(Mode) -> Unit)
+
+  /**
+   * Registers a callback that is invoked when text is yanked.
+   *
+   * The callback receives a map of caret IDs to the yanked text ranges.
+   *
+   * Example:
+   * ```kotlin
+   * listeners {
+   *   onYank { caretRangeMap ->
+   *     // Process yanked text ranges
+   *     caretRangeMap.forEach { (caretId, range) ->
+   *       // Highlight or process the yanked range
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when text is yanked
+   */
+  fun onYank(callback: suspend VimApi.(Map<CaretId, Range.Simple>) -> Unit)
+
+  /**
+   * Registers a callback that is invoked when a new editor is created.
+   *
+   * Example:
+   * ```kotlin
+   * listeners {
+   *   onEditorCreate {
+   *     // Initialize resources for the new editor
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when an editor is created
+   */
+  fun onEditorCreate(callback: suspend VimApi.() -> Unit)
+
+  /**
+   * Registers a callback that is invoked when an editor is released.
+   *
+   * Example:
+   * ```kotlin
+   * listeners {
+   *   onEditorRelease {
+   *     // Clean up resources associated with the editor
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when an editor is released
+   */
+  fun onEditorRelease(callback: suspend VimApi.() -> Unit)
+
+  /**
+   * Registers a callback that is invoked when an editor gains focus.
+   *
+   * Example:
+   * ```kotlin
+   * listeners {
+   *   onEditorFocusGain {
+   *     // Perform actions when editor gains focus
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when an editor gains focus
+   */
+  fun onEditorFocusGain(callback: suspend VimApi.() -> Unit)
+
+  /**
+   * Registers a callback that is invoked when an editor loses focus.
+   *
+   * Example:
+   * ```kotlin
+   * listeners {
+   *   onEditorFocusLost {
+   *     // Perform actions when editor loses focus
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when an editor loses focus
+   */
+  fun onEditorFocusLost(callback: suspend VimApi.() -> Unit)
+
+  /**
+   * Registers a callback that is invoked when macro recording starts.
+   *
+   * Example:
+   * ```kotlin
+   * listeners {
+   *   onMacroRecordingStart {
+   *     // Perform actions when macro recording begins
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when macro recording starts
+   */
+  fun onMacroRecordingStart(callback: suspend VimApi.() -> Unit)
+
+  /**
+   * Registers a callback that is invoked when macro recording finishes.
+   *
+   * Example:
+   * ```kotlin
+   * listeners {
+   *   onMacroRecordingFinish {
+   *     // Perform actions when macro recording ends
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when macro recording finishes
+   */
+  fun onMacroRecordingFinish(callback: suspend VimApi.() -> Unit)
+
+  /**
+   * Registers a callback that is invoked when IdeaVim is enabled.
+   *
+   * Example usage:
+   * ```kotlin
+   * listeners {
+   *   onIdeaVimEnabled {
+   *     // Initialize plugin resources when IdeaVim is enabled
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when IdeaVim is enabled
+   */
+  fun onIdeaVimEnabled(callback: suspend VimApi.() -> Unit)
+
+  /**
+   * Registers a callback that is invoked when IdeaVim is disabled.
+   *
+   * Example usage:
+   * ```kotlin
+   * listeners {
+   *   onIdeaVimDisabled {
+   *     // Clean up plugin resources when IdeaVim is disabled
+   *   }
+   * }
+   * ```
+   *
+   * @param callback The function to execute when IdeaVim is disabled
+   */
+  fun onIdeaVimDisabled(callback: suspend VimApi.() -> Unit)
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/MappingScope.kt

@@ -0,0 +1,516 @@
+/*
+ * 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.intellij.vim.api.scopes
+
+import com.intellij.vim.api.VimApi
+
+/**
+ * Scope that provides access to mappings.
+ */
+@VimApiDsl
+interface MappingScope {
+  /**
+   * Maps a [from] key sequence to [to] in normal mode.
+   */
+  fun nmap(from: String, to: String)
+
+  /**
+   * Removes a [keys] mapping in normal mode.
+   * 
+   * The [keys] must fully match the 'from' keys of the original mapping.
+   * 
+   * Example:
+   * ```kotlin
+   * nmap("abc", "def")      // Create mapping
+   * nunmap("a")             // × Does not unmap anything
+   * nunmap("abc")           // ✓ Properly unmaps the mapping
+   * ```
+   */
+  fun nunmap(keys: String)
+
+  /**
+   * Maps a [from] key sequence to [to] in visual mode.
+   */
+  fun vmap(from: String, to: String)
+
+  /**
+   * Removes a [keys] mapping in visual mode.
+   * 
+   * The [keys] must fully match the 'from' keys of the original mapping.
+   * 
+   * Example:
+   * ```kotlin
+   * vmap("abc", "def")      // Create mapping
+   * vunmap("a")             // × Does not unmap anything
+   * vunmap("abc")           // ✓ Properly unmaps the mapping
+   * ```
+   */
+  fun vunmap(keys: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in normal mode.
+   */
+  fun nmap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps a [from] key sequence to an [action] in visual mode.
+   */
+  fun vmap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in normal mode.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun nmap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in visual mode.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun vmap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in all modes.
+   */
+  fun map(from: String, to: String)
+
+  /**
+   * Removes a [keys] mapping in all modes.
+   * 
+   * The [keys] must fully match the 'from' keys of the original mapping.
+   * 
+   * Example:
+   * ```kotlin
+   * map("abc", "def")       // Create mapping
+   * unmap("a")              // × Does not unmap anything
+   * unmap("abc")            // ✓ Properly unmaps the mapping
+   * ```
+   */
+  fun unmap(keys: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in all modes.
+   */
+  fun map(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in all modes.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun map(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in visual exclusive mode.
+   */
+  fun xmap(from: String, to: String)
+
+  /**
+   * Removes a [keys] mapping in visual exclusive mode.
+   * 
+   * The [keys] must fully match the 'from' keys of the original mapping.
+   * 
+   * Example:
+   * ```kotlin
+   * xmap("abc", "def")      // Create mapping
+   * xunmap("a")             // × Does not unmap anything
+   * xunmap("abc")           // ✓ Properly unmaps the mapping
+   * ```
+   */
+  fun xunmap(keys: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in visual exclusive mode.
+   */
+  fun xmap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in visual exclusive mode.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun xmap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in select mode.
+   */
+  fun smap(from: String, to: String)
+
+  /**
+   * Removes a [keys] mapping in select mode.
+   * 
+   * The [keys] must fully match the 'from' keys of the original mapping.
+   * 
+   * Example:
+   * ```kotlin
+   * smap("abc", "def")      // Create mapping
+   * sunmap("a")             // × Does not unmap anything
+   * sunmap("abc")           // ✓ Properly unmaps the mapping
+   * ```
+   */
+  fun sunmap(keys: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in select mode.
+   */
+  fun smap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in select mode.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun smap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in operator pending mode.
+   */
+  fun omap(from: String, to: String)
+
+  /**
+   * Removes a [keys] mapping in operator pending mode.
+   * 
+   * The [keys] must fully match the 'from' keys of the original mapping.
+   * 
+   * Example:
+   * ```kotlin
+   * omap("abc", "def")      // Create mapping
+   * ounmap("a")             // × Does not unmap anything
+   * ounmap("abc")           // ✓ Properly unmaps the mapping
+   * ```
+   */
+  fun ounmap(keys: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in operator pending mode.
+   */
+  fun omap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in operator pending mode.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun omap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in insert mode.
+   */
+  fun imap(from: String, to: String)
+
+  /**
+   * Removes a [keys] mapping in insert mode.
+   * 
+   * The [keys] must fully match the 'from' keys of the original mapping.
+   * 
+   * Example:
+   * ```kotlin
+   * imap("abc", "def")      // Create mapping
+   * iunmap("a")             // × Does not unmap anything
+   * iunmap("abc")           // ✓ Properly unmaps the mapping
+   * ```
+   */
+  fun iunmap(keys: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in insert mode.
+   */
+  fun imap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in insert mode.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun imap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in command line mode.
+   */
+  fun cmap(from: String, to: String)
+
+  /**
+   * Removes a [keys] mapping in command line mode.
+   * 
+   * The [keys] must fully match the 'from' keys of the original mapping.
+   * 
+   * Example:
+   * ```kotlin
+   * cmap("abc", "def")      // Create mapping
+   * cunmap("a")             // × Does not unmap anything
+   * cunmap("abc")           // ✓ Properly unmaps the mapping
+   * ```
+   */
+  fun cunmap(keys: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in command line mode.
+   */
+  fun cmap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in command line mode.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun cmap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in normal mode non-recursively.
+   */
+  fun nnoremap(from: String, to: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in normal mode non-recursively.
+   */
+  fun nnoremap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in normal mode non-recursively.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun nnoremap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in visual mode non-recursively.
+   */
+  fun vnoremap(from: String, to: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in visual mode non-recursively.
+   */
+  fun vnoremap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in visual mode non-recursively.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun vnoremap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in all modes non-recursively.
+   */
+  fun noremap(from: String, to: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in all modes non-recursively.
+   */
+  fun noremap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in all modes non-recursively.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun noremap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in visual exclusive mode non-recursively.
+   */
+  fun xnoremap(from: String, to: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in visual exclusive mode non-recursively.
+   */
+  fun xnoremap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in visual exclusive mode non-recursively.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun xnoremap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in select mode non-recursively.
+   */
+  fun snoremap(from: String, to: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in select mode non-recursively.
+   */
+  fun snoremap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in select mode non-recursively.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun snoremap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in operator pending mode non-recursively.
+   */
+  fun onoremap(from: String, to: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in operator pending mode non-recursively.
+   */
+  fun onoremap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in operator pending mode non-recursively.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun onoremap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in insert mode non-recursively.
+   */
+  fun inoremap(from: String, to: String)
+
+  /**
+   * Maps a [from] key sequence to an [action] in insert mode non-recursively.
+   */
+  fun inoremap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in insert mode non-recursively.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun inoremap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+
+  /**
+   * Maps a [from] key sequence to [to] in command line mode non-recursively.
+   */
+  fun cnoremap(from: String, to: String)
+
+  /**
+   * Maps a key sequence in command line mode to an action non-recursively.
+   *
+   * @param from The key sequence to map from
+   * @param action The action to execute when the key sequence is pressed
+   */
+  fun cnoremap(from: String, action: suspend VimApi.() -> Unit)
+
+  /**
+   * Maps [keys] to an [action] with an [actionName] in command line mode non-recursively.
+   *
+   * [actionName] is needed to provide an intermediate mapping from the [keys] to [action].
+   * Two mappings will be created: from [keys] to [actionName] and from [actionName] to [action].
+   * In this way, the user will be able to rewrite the default mapping to the plugin by
+   * providing a custom mapping to [actionName].
+   */
+  fun cnoremap(
+    keys: String,
+    actionName: String,
+    action: suspend VimApi.() -> Unit,
+  )
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/ModalInput.kt

@@ -0,0 +1,171 @@
+/*
+ * 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.intellij.vim.api.scopes
+
+import com.intellij.vim.api.VimApi
+
+/**
+ * Scope for working with modal input in IdeaVim.
+ *
+ * This scope provides methods for creating and managing modal input dialogs,
+ * which can be used to get user input in a Vim-like way.
+ *
+ * The ModalInput interface supports:
+ * - Single character input with [inputChar]
+ * - String input with [inputString]
+ * - Repeating input operations with [repeat] and [repeatWhile]
+ * - Updating the input prompt with [updateLabel]
+ * - Closing the current input dialog with [closeCurrentInput]
+ */
+@VimApiDsl
+interface ModalInput {
+  /**
+   * Updates the label of the modal input dialog during input processing.
+   *
+   * This method allows you to dynamically modify the label shown to the user based on the current state.
+   *
+   * Example usage:
+   * ```kotlin
+   * modalInput()
+   *   .updateLabel { currentLabel ->
+   *     "$currentLabel - Updated"
+   *   }
+   *   .inputChar("Enter character:") { char ->
+   *     // Process the character
+   *   }
+   * ```
+   *
+   * @param block A function that takes the current label and returns a new label
+   * @return This ModalInput instance for method chaining
+   */
+  fun updateLabel(block: (String) -> String): ModalInput
+
+  /**
+   * Repeats the input operation as long as the specified condition is true.
+   *
+   * This method allows you to collect multiple inputs from the user until a certain condition is met.
+   * The condition is evaluated before each input operation.
+   *
+   * Example usage:
+   * ```kotlin
+   * var inputCount = 0
+   *
+   * modalInput()
+   *   .repeatWhile {
+   *     inputCount < 3  // Continue until we've received 3 inputs
+   *   }
+   *   .inputChar("Enter character:") { char ->
+   *     inputCount++
+   *     // Process the character
+   *   }
+   * ```
+   *
+   * @param condition A function that returns true if the input operation should be repeated
+   * @return This ModalInput instance for method chaining
+   */
+  fun repeatWhile(condition: () -> Boolean): ModalInput
+
+  /**
+   * Repeats the input operation a specified number of times.
+   *
+   * This method allows you to collect a fixed number of inputs from the user.
+   *
+   * Example usage:
+   * ```kotlin
+   * modalInput()
+   *   .repeat(3)  // Get 3 characters from the user
+   *   .inputChar("Enter character:") { char ->
+   *     // Process each character as it's entered
+   *     // This handler will be called 3 times
+   *   }
+   * ```
+   *
+   * @param count The number of times to repeat the input operation
+   * @return This ModalInput instance for method chaining
+   */
+  fun repeat(count: Int): ModalInput
+
+  /**
+   * Creates a modal input dialog for collecting a string from the user.
+   *
+   * This method displays a dialog with the specified label and waits for the user to enter text.
+   * The handler is executed after the user presses ENTER, receiving the entered string as a parameter.
+   *
+   * Example usage:
+   * ```kotlin
+   * modalInput()
+   *   .inputString("Enter string:") { enteredString ->
+   *     // Process the entered string
+   *     println("User entered: $enteredString")
+   *   }
+   * ```
+   *
+   * This can be combined with other methods:
+   *
+   * ```kotlin
+   * vimApi.modalInput()
+   *   .repeat(2)  // Get two strings from the user
+   *   .inputString("Enter value:") { value ->
+   *     // Process each string as it's entered
+   *   }
+   * ```
+   *
+   * @param label The label to display in the dialog
+   * @param handler A function that will be called when the user enters input and presses ENTER
+   */
+  fun inputString(label: String, handler: VimApi.(String) -> Unit)
+
+  /**
+   * Creates a modal input dialog for collecting a single character from the user.
+   *
+   * This method displays a dialog with the specified label and waits for the user to press a key.
+   * The handler is executed immediately after the user presses any key, receiving the entered character as a parameter.
+   * Unlike [inputString], this method doesn't require the user to press ENTER.
+   *
+   * Example usage:
+   * ```kotlin
+   * vimApi.modalInput()
+   *   .inputChar("Press a key:") { char ->
+   *     // Process the entered character
+   *     when(char) {
+   *       'y', 'Y' -> println("You confirmed")
+   *       'n', 'N' -> println("You declined")
+   *       else -> println("Invalid option")
+   *     }
+   *   }
+   * ```
+   *
+   * This can be combined with other methods:
+   *
+   * ```kotlin
+   * vimApi.modalInput()
+   *   .repeatWhile { /* condition */ }
+   *   .inputChar("Enter character:") { char ->
+   *     // Process each character as it's entered
+   *   }
+   * ```
+   *
+   * @param label The label to display in the dialog
+   * @param handler A function that will be called when the user enters a character
+   */
+  fun inputChar(label: String, handler: VimApi.(Char) -> Unit)
+
+  /**
+   * Closes the current modal input dialog, if one is active.
+   *
+   * Example usage:
+   * ```kotlin
+   * modalInput().closeCurrentInput(refocusEditor = false)
+   * ```
+   *
+   * @param refocusEditor Whether to refocus the editor after closing the dialog (default: true)
+   * @return True if a dialog was closed, false if there was no active dialog
+   */
+  fun closeCurrentInput(refocusEditor: Boolean = true): Boolean
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/OptionScope.kt

@@ -0,0 +1,244 @@
+/*
+ * 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.intellij.vim.api.scopes
+
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Scope that provides functions for working with options.
+ */
+@VimApiDsl
+interface OptionScope {
+  /**
+   * Gets the value of an option with the specified type.
+   * 
+   * **Note:** Prefer using the extension function `get<T>(name)` instead of calling this directly,
+   * as it provides better type safety and cleaner syntax through reified type parameters.
+   *
+   * Example of preferred usage:
+   * ```kotlin
+   * myVimApi.option {
+   *   val ignoreCase = get<Boolean>("ignorecase")
+   *   val history = get<Int>("history")
+   *   val clipboard = get<String>("clipboard")
+   * }
+   * ```
+   *
+   * @param name The name of the option
+   * @param type The KType of the option value
+   * @return The value of the option
+   * @throws IllegalArgumentException if the type is wrong or the option doesn't exist
+   */
+  fun <T> getOptionValue(name: String, type: KType): T
+
+  /**
+   * Sets an option value with the specified scope.
+   * 
+   * **Note:** Prefer using the extension functions `set<T>(name, value)`, `setGlobal<T>(name, value)`, 
+   * or `setLocal<T>(name, value)` instead of calling this directly, as they provide better type safety 
+   * and cleaner syntax through reified type parameters.
+   *
+   * Example of preferred usage:
+   * ```kotlin
+   * myVimApi.option {
+   *   set("ignorecase", true)        // Effective scope
+   *   setGlobal("number", 42)         // Global scope
+   *   setLocal("tabstop", 4)          // Local scope
+   * }
+   * ```
+   *
+   * @param name The name of the option
+   * @param value The value to set
+   * @param type The KType of the option value
+   * @param scope The scope to set the option in ("global", "local", or "effective")
+   * @throws IllegalArgumentException if the option doesn't exist or the type is wrong
+   */
+  fun <T> setOption(name: String, value: T, type: KType, scope: String)
+
+  /**
+   * Resets an option to its default value.
+   *
+   * In Vim, this is equivalent to `:set option&`.
+   * Example: `:set ignorecase&` resets the 'ignorecase' option to its default value.
+   *
+   * @param name The name of the option
+   *
+   * @throws IllegalArgumentException if the option doesn't exist
+   */
+  fun reset(name: String)
+
+  /**
+   * Extension function to split a comma-separated option value into a list.
+   * This is useful for processing list options like virtualedit, whichwrap, etc.
+   *
+   * Example:
+   * ```kotlin
+   * myVimApi.option {
+   *   val values = get<String>("virtualedit")?.split() ?: emptyList()
+   *   // "block,all" → ["block", "all"]
+   *   // "" → [""]
+   *   // "all" → ["all"]
+   * }
+   * ```
+   */
+  fun String.split(): List<String> = split(",")
+}
+
+/**
+ * Gets the value of an option with the specified type.
+ *
+ * In Vim, options can be accessed with the `&` prefix.
+ * Example: `&ignorecase` returns the value of the 'ignorecase' option.
+ *
+ * @param name The name of the option
+ * @return The value of the option
+ * @throws IllegalArgumentException if the type is wrong or the option doesn't exist
+ */
+inline fun <reified T> OptionScope.get(name: String): T {
+  val kType: KType = typeOf<T>()
+  return getOptionValue(name, kType)
+}
+
+/**
+ * Sets the global value of an option with the specified type.
+ *
+ * In Vim, this is equivalent to `:setglobal option=value`.
+ * Example: `:setglobal ignorecase` or `let &g:ignorecase = 1`
+ *
+ * @param name The name of the option
+ * @param value The value to set
+ *
+ * @throws IllegalArgumentException if the option doesn't exist or the type is wrong
+ */
+inline fun <reified T> OptionScope.setGlobal(name: String, value: T) {
+  val kType: KType = typeOf<T>()
+  setOption(name, value, kType, "global")
+}
+
+/**
+ * Sets the local value of an option with the specified type.
+ *
+ * In Vim, this is equivalent to `:setlocal option=value`.
+ * Example: `:setlocal ignorecase` or `let &l:ignorecase = 1`
+ *
+ * @param name The name of the option
+ * @param value The value to set
+ *
+ * @throws IllegalArgumentException if the option doesn't exist or the type is wrong
+ */
+inline fun <reified T> OptionScope.setLocal(name: String, value: T) {
+  val kType: KType = typeOf<T>()
+  setOption(name, value, kType, "local")
+}
+
+/**
+ * Sets the effective value of an option with the specified type.
+ *
+ * In Vim, this is equivalent to `:set option=value`.
+ * Example: `:set ignorecase` or `let &ignorecase = 1`
+ *
+ * @param name The name of the option
+ * @param value The value to set
+ *
+ * @throws IllegalArgumentException if the option doesn't exist or the type is wrong
+ */
+inline fun <reified T> OptionScope.set(name: String, value: T) {
+  val kType: KType = typeOf<T>()
+  setOption(name, value, kType, "effective")
+}
+
+/**
+ * Toggles a boolean option value.
+ *
+ * Example:
+ * ```kotlin
+ * myVimApi.option {
+ *   toggle("ignorecase")  // true → false, false → true
+ * }
+ * ```
+ *
+ * @param name The name of the boolean option to toggle
+ */
+fun OptionScope.toggle(name: String) {
+  val current = get<Boolean>(name)
+  set(name, !current)
+}
+
+/**
+ * Appends values to a comma-separated list option.
+ * This is equivalent to Vim's += operator for string options.
+ * Duplicate values are not added.
+ *
+ * Example:
+ * ```kotlin
+ * myVimApi.option {
+ *   append("virtualedit", "block")  // "" → "block"
+ *   append("virtualedit", "onemore")  // "block" → "block,onemore"
+ *   append("virtualedit", "block")  // "block,onemore" → "block,onemore" (no change)
+ * }
+ * ```
+ *
+ * @param name The name of the list option
+ * @param values The values to append (duplicates will be ignored)
+ */
+fun OptionScope.append(name: String, vararg values: String) {
+  val current = get<String>(name)
+  val currentList = if (current.isEmpty()) emptyList() else current.split()
+  val valuesToAdd = values.filterNot { it in currentList }
+  val newList = currentList + valuesToAdd
+  set(name, newList.joinToString(","))
+}
+
+/**
+ * Prepends values to a comma-separated list option.
+ * This is equivalent to Vim's ^= operator for string options.
+ * Duplicate values are not added.
+ *
+ * Example:
+ * ```kotlin
+ * myVimApi.option {
+ *   prepend("virtualedit", "block")  // "all" → "block,all"
+ *   prepend("virtualedit", "onemore")  // "block,all" → "onemore,block,all"
+ *   prepend("virtualedit", "all")  // "onemore,block,all" → "onemore,block,all" (no change)
+ * }
+ * ```
+ *
+ * @param name The name of the list option
+ * @param values The values to prepend (duplicates will be ignored)
+ */
+fun OptionScope.prepend(name: String, vararg values: String) {
+  val current = get<String>(name)
+  val currentList = if (current.isEmpty()) emptyList() else current.split()
+  val valuesToAdd = values.filterNot { it in currentList }
+  val newList = valuesToAdd + currentList
+  set(name, newList.joinToString(","))
+}
+
+/**
+ * Removes values from a comma-separated list option.
+ * This is equivalent to Vim's -= operator for string options.
+ *
+ * Example:
+ * ```kotlin
+ * myVimApi.option {
+ *   remove("virtualedit", "block")  // "block,all" → "all"
+ *   remove("virtualedit", "all")  // "all" → ""
+ * }
+ * ```
+ *
+ * @param name The name of the list option
+ * @param values The values to remove
+ */
+fun OptionScope.remove(name: String, vararg values: String) {
+  val current = get<String>(name)
+  val currentList = if (current.isEmpty()) emptyList() else current.split()
+  val newList = currentList.filterNot { it in values }
+  set(name, newList.joinToString(","))
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/OutputPanelScope.kt

@@ -0,0 +1,60 @@
+/*
+ * 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.intellij.vim.api.scopes
+
+/**
+ * Scope that provides functions for interacting with the Vim output panel.
+ */
+@VimApiDsl
+interface OutputPanelScope {
+  /**
+   * The text displayed in the output panel.
+   */
+  val text: String
+
+  /**
+   * The label text displayed at the bottom of the output panel.
+   *
+   * This is used for status information like "-- MORE --" to indicate
+   * that there is more content to scroll through.
+   */
+  val label: String
+
+  /**
+   * Sets the text content of the output panel.
+   *
+   * This replaces any existing text in the panel with the provided text.
+   *
+   * @param text The new text to display in the output panel.
+   */
+  fun setText(text: String)
+
+  /**
+   * Appends text to the existing content of the output panel.
+   *
+   * @param text The text to append to the current content.
+   * @param startNewLine Whether to start the appended text on a new line.
+   *                     If true and there is an existing text, a newline character
+   *                     will be inserted before the appended text.
+   *                     Defaults to false.
+   */
+  fun appendText(text: String, startNewLine: Boolean = false)
+
+  /**
+   * Sets the label text at the bottom of the output panel.
+   *
+   * @param label The new label text to display.
+   */
+  fun setLabel(label: String)
+
+  /**
+   * Clears all text from the output panel.
+   */
+  fun clearText()
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/VimApiDsl.kt

@@ -0,0 +1,13 @@
+/*
+ * 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.intellij.vim.api.scopes
+
+@Target(AnnotationTarget.CLASS, AnnotationTarget.TYPE)
+@DslMarker
+internal annotation class VimApiDsl

api/src/main/kotlin/com/intellij/vim/api/scopes/commandline/CommandLineRead.kt

@@ -0,0 +1,32 @@
+/*
+ * 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.intellij.vim.api.scopes.commandline
+
+import com.intellij.vim.api.scopes.VimApiDsl
+
+/**
+ * Scope for command line functions that should be executed under read lock.
+ */
+@VimApiDsl
+interface CommandLineRead {
+  /**
+   * The text currently displayed in the command line.
+   */
+  val text: String
+
+  /**
+   * The current position of the caret in the command line.
+   */
+  val caretPosition: Int
+
+  /**
+   * True if the command line is currently active, false otherwise.
+   */
+  val isActive: Boolean
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/commandline/CommandLineScope.kt

@@ -0,0 +1,80 @@
+/*
+ * 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.intellij.vim.api.scopes.commandline
+
+import com.intellij.vim.api.VimApi
+import com.intellij.vim.api.scopes.VimApiDsl
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+/**
+ * Scope for interacting with the Vim command line.
+ */
+@VimApiDsl
+abstract class CommandLineScope {
+  /**
+   * Reads input from the command line and processes it with the provided function.
+   *
+   * @param prompt The prompt to display at the beginning of the command line.
+   * @param finishOn The character that, when entered, will finish the input process. If null, only Enter will finish.
+   * @param callback A function that will be called with the entered text when input is complete.
+   */
+  abstract fun input(prompt: String, finishOn: Char? = null, callback: VimApi.(String) -> Unit)
+
+  /**
+   * Executes operations on the command line that require a read lock.
+   *
+   * Example usage:
+   * ```kotlin
+   * commandLine {
+   *  read {
+   *    text
+   *  }
+   * }
+   * ```
+   *
+   * @param block A function with CommandLineRead receiver that contains the read operations to perform.
+   * @return A Deferred that will complete with the result of the block execution.
+   */
+  @OptIn(ExperimentalContracts::class)
+  fun <T> read(block: CommandLineRead.() -> T): T {
+    contract {
+      callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return this.ideRead(block)
+  }
+
+  /**
+   * Executes operations that require write lock on the command line.
+   *
+   * Example usage:
+   * ```kotlin
+   * // Set command line text
+   * commandLineScope {
+   *  change {
+   *    setText("Hello")
+   *   }
+   * }
+   * ```
+   *
+   * @param block A function with CommandLineTransaction receiver that contains the write operations to perform.
+   * @return A Job that represents the ongoing execution of the block.
+   */
+  @OptIn(ExperimentalContracts::class)
+  fun change(block: CommandLineTransaction.() -> Unit) {
+    contract {
+      callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    ideChange(block)
+  }
+
+  protected abstract fun <T> ideRead(block: CommandLineRead.() -> T): T
+  protected abstract fun ideChange(block: CommandLineTransaction.() -> Unit)
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/commandline/CommandLineTransaction.kt

@@ -0,0 +1,47 @@
+/*
+ * 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.intellij.vim.api.scopes.commandline
+
+import com.intellij.vim.api.scopes.VimApiDsl
+
+/**
+ * Scope for command line functions that should be executed under write lock.
+ */
+@VimApiDsl
+interface CommandLineTransaction {
+  /**
+   * Sets the text content of the command line. It replaces any existing text in the command line with the provided text.
+   *
+   * @param text The new text to display in the command line.
+   */
+  suspend fun setText(text: String)
+
+  /**
+   * Inserts text at the specified position in the command line.
+   *
+   * @param offset The position at which to insert the text.
+   * @param text The text to insert.
+   */
+  suspend fun insertText(offset: Int, text: String)
+
+  /**
+   * Sets the caret position in the command line.
+   *
+   * @param position The new position for the caret.
+   */
+  suspend fun setCaretPosition(position: Int)
+
+  /**
+   * Closes the command line.
+   *
+   * @param refocusEditor Whether to refocus the editor after closing the command line.
+   * @return True if the command line was closed, false if it was not active.
+   */
+  suspend fun close(refocusEditor: Boolean = true): Boolean
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/editor/EditorAccessor.kt

@@ -0,0 +1,328 @@
+/*
+ * 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.intellij.vim.api.scopes.editor
+
+import com.intellij.vim.api.models.CaretData
+import com.intellij.vim.api.models.CaretId
+import com.intellij.vim.api.models.Jump
+import com.intellij.vim.api.models.Line
+import com.intellij.vim.api.models.Mark
+import com.intellij.vim.api.models.Path
+import com.intellij.vim.api.models.Range
+import com.intellij.vim.api.scopes.VimApiDsl
+
+/**
+ * Interface giving functions to access the editor state. Does not imply read or write locks.
+ */
+@VimApiDsl
+interface EditorAccessor {
+  /**
+   * The total length of the text in the editor.
+   */
+  val textLength: Long
+
+  /**
+   * The entire text content of the editor.
+   */
+  val text: CharSequence
+
+  /**
+   * The total number of lines in the editor.
+   */
+  val lineCount: Int
+
+  /**
+   * File path of the editor.
+   */
+  val filePath: Path
+
+  /**
+   * Gets the start offset of the specified line.
+   *
+   * @param line The line number (0-based)
+   * @return The offset of the first character in the line
+   */
+  fun getLineStartOffset(line: Int): Int
+
+  /**
+   * Gets the end offset of the specified line.
+   *
+   * @param line The line number (0-based)
+   * @param allowEnd Whether to allow the end of the document as a valid result
+   * @return The offset after the last character in the line
+   */
+  fun getLineEndOffset(line: Int, allowEnd: Boolean): Int
+
+  /**
+   * Gets information about the line containing the specified offset.
+   *
+   * @param offset The offset in the document
+   * @return A Line object containing information about the line
+   */
+  fun getLine(offset: Int): Line
+
+  /**
+   * A list of data for all carets in the editor.
+   *
+   * Each element in the list is a CaretData object containing information about a caret,
+   * such as its position, selection, and other properties.
+   */
+  val caretData: List<CaretData>
+
+  /**
+   * A list of IDs for all carets in the editor.
+   *
+   * These IDs can be used with the `with` function to perform operations on specific carets.
+   */
+  val caretIds: List<CaretId>
+
+  /**
+   * Gets a global mark by its character key.
+   *
+   * @param char The character key of the mark (A-Z)
+   * @return The mark, or null if the mark doesn't exist
+   */
+  fun getGlobalMark(char: Char): Mark?
+
+  /**
+   * All global marks.
+   */
+  val globalMarks: Set<Mark>
+
+  /**
+   * Gets a jump from the jump list.
+   *
+   * @param count The number of jumps to go back (negative) or forward (positive) from the current position in the jump list.
+   * @return The jump, or null if there is no jump at the specified position
+   */
+  fun getJump(count: Int = 0): Jump?
+
+  /**
+   * Gets all jumps in the jump list.
+   *
+   * @return A list of all jumps
+   */
+  val jumps: List<Jump>
+
+  /**
+   * Index of the current position in the jump list.
+   *
+   * This is used to determine which jump will be used when navigating with Ctrl-O and Ctrl-I.
+   */
+  val currentJumpIndex: Int
+
+  /**
+   * Scrolls the caret into view.
+   *
+   * This ensures that the caret is visible in the editor window.
+   */
+  fun scrollCaretIntoView()
+
+  /**
+   * Scrolls the editor by a specified number of lines.
+   *
+   * @param lines The number of lines to scroll. Positive values scroll down, negative values scroll up.
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollVertically(lines: Int): Boolean
+
+  /**
+   * Scrolls the current line to the top of the display.
+   *
+   * @param line The line number to scroll to (1-based). If 0, uses the current line.
+   * @param start Whether to position the caret at the start of the line
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollLineToTop(line: Int, start: Boolean): Boolean
+
+  /**
+   * Scrolls the current line to the middle of the display.
+   *
+   * @param line The line number to scroll to (1-based). If 0, uses the current line.
+   * @param start Whether to position the caret at the start of the line
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollLineToMiddle(line: Int, start: Boolean): Boolean
+
+  /**
+   * Scrolls the current line to the bottom of the display.
+   *
+   * @param line The line number to scroll to (1-based). If 0, uses the current line.
+   * @param start Whether to position the caret at the start of the line
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollLineToBottom(line: Int, start: Boolean): Boolean
+
+  /**
+   * Scrolls the editor horizontally by a specified number of columns.
+   *
+   * @param columns The number of columns to scroll. Positive values scroll right, negative values scroll left.
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollHorizontally(columns: Int): Boolean
+
+  /**
+   * Scrolls the editor to position the caret column at the left edge of the display.
+   *
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollCaretToLeftEdge(): Boolean
+
+  /**
+   * Scrolls the editor to position the caret column at the right edge of the display.
+   *
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollCaretToRightEdge(): Boolean
+
+  /**
+   * Find the next paragraph-bound offset in the editor.
+   *
+   * @param startLine Line to start the search from.
+   * @param count Search for the [count]-th occurrence.
+   * @param includeWhitespaceLines Should be `true` if we consider lines with whitespaces as empty.
+   * @return next paragraph off
+   */
+  fun getNextParagraphBoundOffset(startLine: Int, count: Int = 1, includeWhitespaceLines: Boolean = true): Int?
+
+  /**
+   * Finds the next sentence start in the editor from the given offset, based on the specified parameters.
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @param includeCurrent If `true`, includes the current sentence if at its boundary.
+   * @param requireAll If `true`, returns `null` if fewer than [count] sentences are found.
+   * @return The offset of the next sentence start, or `null` if not found or constraints cannot be met.
+   */
+  fun getNextSentenceStart(
+    startOffset: Int,
+    count: Int = 1,
+    includeCurrent: Boolean,
+    requireAll: Boolean = true,
+  ): Int?
+
+  /**
+   * Find the next section in the editor.
+   *
+   * @param startLine The line to start searching from.
+   * @param marker The type of section to find.
+   * @param count Search for the [count]-th occurrence.
+   * @return The offset of the next section.
+   */
+  fun getNextSectionStart(startLine: Int, marker: Char, count: Int = 1): Int
+
+  /**
+   * Find the start of the previous section in the editor.
+   *
+   * @param startLine The line to start searching from.
+   * @param marker The type of section to find.
+   * @param count Search for the [count]-th occurrence.
+   * @return The offset of the next section.
+   */
+  fun getPreviousSectionStart(startLine: Int, marker: Char, count: Int = 1): Int
+
+  /**
+   * Find the next sentence end from the given offset.
+   *
+   * @param startOffset The offset to start searching from
+   * @param count Search for the [count]-th occurrence.
+   * @param includeCurrent Whether to count the current position as a sentence end
+   * @param requireAll Whether to require all sentence ends to be found
+   * @return The offset of the next sentence end, or null if not found
+   */
+  fun getNextSentenceEnd(
+    startOffset: Int,
+    count: Int = 1,
+    includeCurrent: Boolean,
+    requireAll: Boolean = true,
+  ): Int?
+
+  /**
+   * Find the next word in the editor's document, from the given starting point
+   *
+   * @param startOffset The offset in the document to search from
+   * @param count Search for the [count]-th occurrence. If negative, search backwards.
+   * @param isBigWord Use WORD instead of word boundaries.
+   * @return The offset of the [count]-th next word, or `null` if not found.
+   */
+  fun getNextWordStartOffset(startOffset: Int, count: Int = 1, isBigWord: Boolean = false): Int?
+
+  /**
+   * Find the end offset of the next word in the editor's document, from the given starting point
+   *
+   * @param startOffset The offset in the document to search from
+   * @param count Return an offset to the [count] word from the starting position. Will search backwards if negative
+   * @param isBigWord Use WORD instead of word boundaries
+   * @return The offset of the [count] next word/WORD. Will return document bounds if not found
+   */
+  fun getNextWordEndOffset(startOffset: Int, count: Int = 1, isBigWord: Boolean = false): Int
+
+  /**
+   * Find the next character on the current line
+   *
+   * @param startOffset The offset to start searching from
+   * @param count The number of occurrences to find
+   * @param char The character to find
+   * @return The offset of the next character, or -1 if not found
+   */
+  fun getNextCharOnLineOffset(startOffset: Int, count: Int = 1, char: Char): Int
+
+  /**
+   * Find the word or WORD at or following the given offset
+   *
+   * Note that if there is no current or following word, the next WORD will be returned. If a WORD is requested, this is
+   * obviously a no-op.
+   *
+   * @param startOffset The offset to search from
+   * @return The range of the word, or null if not found
+   */
+  fun getWordAtOrFollowingOffset(startOffset: Int, isBigWord: Boolean): Range?
+
+  /**
+   * Returns range of a paragraph containing the given line.
+   *
+   * @param line line to start the search from
+   * @param count search for the count paragraphs forward
+   * @param isOuter true if it is an outer motion, false otherwise
+   * @return the paragraph text range
+   */
+  fun getParagraphRange(line: Int, count: Int = 1, isOuter: Boolean): Range?
+
+  /**
+   * Find a block quote in the current line
+   *
+   * @param startOffset The offset to start searching from
+   * @param quote The quote character to find
+   * @param isOuter Whether to include the quotes in the range
+   * @return The range of the block quote, or null if not found
+   */
+  fun getBlockQuoteInLineRange(startOffset: Int, quote: Char, isOuter: Boolean): Range?
+
+  /**
+   * Finds all occurrences of the given pattern within a specified line range.
+   *
+   * @param pattern The Vim-style regex pattern to search for.
+   * @param startLine The line number to start searching from (0-based). Must be within the range [0, lineCount-1].
+   * @param endLine The line number to end searching at (0-based), or -1 for the whole document.
+   *               If specified, must be within the range [startLine, lineCount-1].
+   * @param ignoreCase If true, performs case-insensitive search; if false, performs case-sensitive search.
+   * @return A list of Ranges representing all matches found. Empty list if no matches are found.
+   */
+  fun findAll(pattern: String, startLine: Int, endLine: Int, ignoreCase: Boolean = false): List<Range>
+
+  /**
+   * Finds text matching the given Vim-style regular expression pattern.
+   *
+   * @param pattern The Vim-style regex pattern to search for.
+   * @param startOffset The offset to start searching from. Must be within the range [0, document.length].
+   * @param count Find the [count]-th occurrence of the pattern.
+   * @param backwards If true, search backward from the start offset; if false, search forward.
+   * @return A Range representing the matched text, or null if no match is found.
+   */
+  fun findPattern(pattern: String, startOffset: Int, count: Int = 1, backwards: Boolean = false): Range?
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/editor/EditorScope.kt

@@ -0,0 +1,82 @@
+/*
+ * 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.intellij.vim.api.scopes.editor
+
+import com.intellij.vim.api.scopes.VimApiDsl
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+/**
+ * Scope that provides access to editor functions.
+ */
+@VimApiDsl
+abstract class EditorScope {
+  /**
+   * Executes a read-only operation on the editor.
+   *
+   * This function provides access to read-only operations through the [EditorAccessor] interface.
+   * It runs the provided block under a read lock to ensure thread safety when accessing editor state.
+   * The operation is executed asynchronously and returns a [kotlinx.coroutines.Deferred] that can be awaited for the result.
+   *
+   * Example usage:
+   * ```
+   * editor {
+   *   val text = read {
+   *     text // Access the editor's text content
+   *   }.await()
+   * }
+   * ```
+   *
+   * @param block A suspending lambda with [EditorAccessor] receiver that contains the read operations to perform
+   * @return A [kotlinx.coroutines.Deferred] that completes with the result of the block execution
+   */
+  @OptIn(ExperimentalContracts::class)
+  fun <T> read(block: ReadScope.() -> T): T {
+    contract {
+      callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return this.ideRead(block)
+  }
+
+  /**
+   * Executes a write operation that modifies the editor's state.
+   *
+   * This function provides access to write operations through the [Transaction] interface.
+   * It runs the provided block under a write lock to ensure thread safety when modifying editor state.
+   * The operation is executed asynchronously and returns a [kotlinx.coroutines.Job] that can be joined to wait for completion.
+   *
+   * Example usage:
+   * ```
+   * editor {
+   *   val job = change {
+   *     // Modify editor content
+   *     replaceText(startOffset, endOffset, newText)
+   *
+   *     // Add highlights
+   *     val highlightId = addHighlight(startOffset, endOffset, backgroundColor, foregroundColor)
+   *   }
+   *   job.join() // Wait for the changes to complete
+   * }
+   * ```
+   *
+   * @param block A suspending lambda with [Transaction] receiver that contains the write operations to perform
+   * @return A [kotlinx.coroutines.Job] that completes when all write operations are finished
+   */
+  @OptIn(ExperimentalContracts::class)
+  fun change(block: Transaction.() -> Unit) {
+    contract {
+      callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return ideChange(block)
+  }
+
+  protected abstract fun <T> ideRead(block: ReadScope.() -> T): T
+  protected abstract fun ideChange(block: Transaction.() -> Unit)
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/editor/ReadScope.kt

@@ -0,0 +1,81 @@
+/*
+ * 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.intellij.vim.api.scopes.editor
+
+import com.intellij.vim.api.models.CaretId
+import com.intellij.vim.api.scopes.VimApiDsl
+import com.intellij.vim.api.scopes.editor.caret.CaretRead
+
+/**
+ * Interface that provides functions that open CaretRead scope.
+ */
+@VimApiDsl
+interface ReadScope : EditorAccessor {
+  /**
+   * Executes the provided block for each caret in the editor and returns a list of results.
+   *
+   * This function allows you to perform operations on all carets in the editor in a single call.
+   * The block is executed with each caret as the receiver, and the results are collected into a list.
+   *
+   * Example usage:
+   * ```kotlin
+   * editor {
+   *   val caretOffsets = forEachCaret {
+   *     offset // Get the offset of each caret
+   *   }
+   *   // caretOffsets is a List<Int> containing the offset of each caret
+   * }
+   * ```
+   *
+   * @param block The block to execute for each caret
+   * @return A list containing the results of executing the block for each caret
+   */
+  fun <T> forEachCaret(block: CaretRead.() -> T): List<T>
+
+  /**
+   * Executes the provided block with a specific caret as the receiver.
+   *
+   * This function allows you to perform operations on a specific caret identified by its ID.
+   *
+   * Example usage:
+   * ```kotlin
+   * editor {
+   *   with(caretId) {
+   *     // Perform operations on the specific caret
+   *     val caretOffset = offset
+   *     val caretLine = line
+   *   }
+   * }
+   * ```
+   *
+   * @param caretId The ID of the caret to use
+   * @param block The block to execute with the specified caret as the receiver
+   */
+  fun <T> with(caretId: CaretId, block: CaretRead.() -> T): T
+
+  /**
+   * Executes the provided block with the primary caret as the receiver.
+   *
+   * This function allows you to perform operations on the primary caret in the editor.
+   *
+   * Example usage:
+   * ```kotlin
+   * editor {
+   *   withPrimaryCaret {
+   *     // Perform operations on the primary caret
+   *     val primaryCaretOffset = offset
+   *     val primaryCaretLine = line
+   *   }
+   * }
+   * ```
+   *
+   * @param block The block to execute with the primary caret as the receiver
+   */
+  fun <T> withPrimaryCaret(block: CaretRead.() -> T): T
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/editor/Transaction.kt

@@ -0,0 +1,198 @@
+/*
+ * 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.intellij.vim.api.scopes.editor
+
+import com.intellij.vim.api.models.CaretId
+import com.intellij.vim.api.models.Color
+import com.intellij.vim.api.models.HighlightId
+import com.intellij.vim.api.models.Jump
+import com.intellij.vim.api.scopes.VimApiDsl
+import com.intellij.vim.api.scopes.editor.caret.CaretTransaction
+
+/**
+ * Scope for editor functions that should be executed under write lock.
+ */
+@VimApiDsl
+interface Transaction : EditorAccessor {
+  /**
+   * Executes the provided block for each caret in the editor and returns a list of results.
+   *
+   * Example usage:
+   * ```kotlin
+   * editor {
+   *   change {
+   *     forEachCaret {
+   *       // Perform operations on each caret
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @param block The block to execute for each caret
+   * @return A list containing the results of executing the block for each caret
+   */
+  fun <T> forEachCaret(block: CaretTransaction.() -> T): List<T>
+
+  /**
+   * Executes the provided block with a specific caret as the receiver.
+   *
+   * This function allows you to perform write operations on a specific caret identified by its ID.
+   *
+   * Example usage:
+   * ```kotlin
+   * editor {
+   *   change {
+   *     val caretId = caretIds.first() // Get the ID of the first caret
+   *     with(caretId) {
+   *       // Perform operations on the specific caret
+   *       deleteText(offset, offset + 5)
+   *       updateCaret(newOffset)
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @param caretId The ID of the caret to use
+   * @param block The block to execute with the specified caret as the receiver
+   */
+  fun <T> with(caretId: CaretId, block: CaretTransaction.() -> T): T
+
+  /**
+   * Executes the provided block with the primary caret as the receiver.
+   *
+   * This function allows you to perform write operations on the primary caret in the editor.
+   *
+   * Example usage:
+   * ```kotlin
+   * editor {
+   *   change {
+   *     withPrimaryCaret {
+   *       // Perform operations on the primary caret
+   *       deleteText(offset, offset + 5)
+   *       updateCaret(newOffset)
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @param block The block to execute with the primary caret as the receiver
+   */
+  fun <T> withPrimaryCaret(block: CaretTransaction.() -> T): T
+
+  /**
+   * Adds a new caret at the specified offset in the editor.
+   *
+   * @param offset The offset at which to add the caret
+   * @return The ID of the newly created caret if successful, null otherwise
+   * @throws IllegalArgumentException if offset is not in valid range `[0, fileLength - 1]`
+   */
+  fun addCaret(offset: Int): CaretId?
+
+  /**
+   * Removes a caret from the editor.
+   *
+   * @param caretId The ID of the caret to remove
+   * @throws IllegalArgumentException if caret with [caretId] is not found
+   */
+  fun removeCaret(caretId: CaretId)
+
+  /**
+   * Adds a highlight to the editor.
+   *
+   * @param startOffset The start offset of the highlight
+   * @param endOffset The end offset of the highlight
+   * @param backgroundColor The background color of the highlight, or null for no background color
+   * @param foregroundColor The foreground color of the highlight, or null for no foreground color
+   * @return The ID of the newly created highlight
+   */
+  fun addHighlight(
+    startOffset: Int,
+    endOffset: Int,
+    backgroundColor: Color?,
+    foregroundColor: Color?,
+  ): HighlightId
+
+  /**
+   * Removes a highlight from the editor.
+   *
+   * @param highlightId The ID of the highlight to remove
+   */
+  fun removeHighlight(highlightId: HighlightId)
+
+  /**
+   * Sets a mark at the current position for each caret in the editor.
+   *
+   * @param char The character key of the mark (a-z, A-Z, etc.)
+   * @return True if the mark was successfully set, false otherwise
+   */
+  fun setMark(char: Char): Boolean
+
+  /**
+   * Removes a mark for all carets in the editor.
+   *
+   * @param char The character key of the mark to remove (a-z, A-Z, etc.)
+   */
+  fun removeMark(char: Char)
+
+  /**
+   * Sets a global mark at the current position.
+   *
+   * @param char The character key of the mark (A-Z)
+   * @return True if the mark was successfully set, false otherwise
+   */
+  fun setGlobalMark(char: Char): Boolean
+
+  /**
+   * Removes a global mark.
+   *
+   * @param char The character key of the mark to remove (A-Z)
+   */
+  fun removeGlobalMark(char: Char)
+
+  /**
+   * Sets a global mark at the specified offset.
+   *
+   * @param char The character key of the mark (A-Z)
+   * @param offset The offset to set the mark to
+   * @return True if the mark was successfully set, false otherwise
+   */
+  fun setGlobalMark(char: Char, offset: Int): Boolean
+
+  /**
+   * Resets all marks.
+   *
+   * This removes all marks, both global and local.
+   */
+  fun resetAllMarks()
+
+  /**
+   * Adds a specific jump to the jump list.
+   *
+   * @param jump The jump to add
+   * @param reset Whether to reset the current position in the jump list
+   */
+  fun addJump(jump: Jump, reset: Boolean = false)
+
+  /**
+   * Removes a jump from the jump list.
+   *
+   * @param jump The jump to remove
+   */
+  fun removeJump(jump: Jump)
+
+  /**
+   * Removes the last jump from the jump list.
+   */
+  fun dropLastJump()
+
+  /**
+   * Clears all jumps from the jump list.
+   */
+  fun clearJumps()
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/editor/caret/CaretRead.kt

@@ -0,0 +1,371 @@
+/*
+ * 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.intellij.vim.api.scopes.editor.caret
+
+import com.intellij.vim.api.models.CaretId
+import com.intellij.vim.api.models.Line
+import com.intellij.vim.api.models.Mark
+import com.intellij.vim.api.models.Range
+import com.intellij.vim.api.models.TextType
+import com.intellij.vim.api.scopes.VimApiDsl
+
+/**
+ * Scope for caret operations that should be executed under the read lock.
+ */
+@VimApiDsl
+interface CaretRead {
+  /**
+   * The unique identifier for this caret.
+   */
+  val caretId: CaretId
+
+  /**
+   * The current offset (position) of the caret in the document.
+   */
+  val offset: Int
+
+  /**
+   * The current selection range of the caret.
+   */
+  val selection: Range
+
+  /**
+   * Information about the current line where the caret is positioned.
+   */
+  val line: Line
+
+  /**
+   * The last register that was selected for operations.
+   *
+   * Example: After using `"ay` to yank into register 'a', this would return 'a'.
+   * In VimScript, variable `v:register` contains this value.
+   */
+  val lastSelectedReg: Char
+
+  /**
+   * The default register used when no register is explicitly specified.
+   *
+   * In Vim, this is typically the unnamed register (").
+   */
+  val defaultRegister: Char
+
+  /**
+   * Indicates whether the current register was explicitly specified by the user.
+   *
+   * Example: After `"ay`, this would be true; after just `y`, this would be false.
+   */
+  val isRegisterSpecifiedExplicitly: Boolean
+
+  /**
+   * Selects a register for subsequent operations.
+   *
+   * Example: In Vim, pressing `"a` before an operation selects register 'a'.
+   *
+   * @param register The register to select
+   * @return True if the register was successfully selected, false otherwise
+   */
+  fun selectRegister(register: Char): Boolean
+
+  /**
+   * Resets all registers to their default state.
+   */
+  fun resetRegisters()
+
+  /**
+   * Checks if a register is writable.
+   *
+   * Some registers in Vim are read-only. Examples of read-only registers:
+   *  - ':' (last executed command)
+   *  - '.' (last inserted text)
+   *  - '/' (last search pattern)
+   *
+   * @param register The register to check
+   * @return True if the register is writable, false otherwise
+   */
+  fun isWritable(register: Char): Boolean
+
+  /**
+   * Checks if a register is connected to the system clipboard.
+   *
+   * In Vim, registers '+' and '*' are connected to the system clipboard.
+   * Example: Using `"+y` yanks text to the system clipboard.
+   *
+   * @param register The register to check
+   * @return True if the register is connected to the system clipboard, false otherwise
+   */
+  fun isSystemClipboard(register: Char): Boolean
+
+  /**
+   * Checks if the primary selection register is supported.
+   *
+   * Example: On Linux, using `"*y` yanks text to the primary selection.
+   *
+   * @return True if the primary selection register is supported, false otherwise
+   */
+  fun isPrimaryRegisterSupported(): Boolean
+
+  /**
+   * The marks for the current visual selection.
+   *
+   * In Vim, these are the '< and '> marks.
+   * Example: After making a visual selection and then pressing ESC, `'<` and `'>` mark the beginning and end.
+   * In VimScript `getpos("'<")` and `getpos("'>")` are used to get these marks.
+   */
+  val selectionMarks: Range?
+
+  /**
+   * The marks for the last change.
+   *
+   * In Vim, these are the '[ and '] marks.
+   * Example: After a change operation like `cw`, these marks indicate the changed region.
+   * In VimScript, `getpos("'[")` and `getpos("']")` are used to get these marks.
+   */
+  val changeMarks: Range?
+
+  /**
+   * Gets the text content of a register.
+   *
+   * Example: In Vim, `:echo @a` shows the content of register 'a'.
+   * In VimScript `getreg('a')` is used to get the content of register 'a'.
+   *
+   * @param register The register to get text from
+   * @return The text content of the register, or null if the register is empty or doesn't exist
+   */
+  fun getReg(register: Char): String?
+
+  /**
+   * Gets the type of text stored in a register (character-wise, line-wise, or block-wise).
+   *
+   * In VimScript, `getregtype('a')` is used to get the type of register 'a'.
+   *
+   * @param register The register to get the type from
+   * @return The type of text in the register, or null if the register is empty or doesn't exist
+   */
+  fun getRegType(register: Char): TextType?
+
+  /**
+   * Sets the text content and type of a register.
+   *
+   * In VimScript, `setreg('a', 'text', 'c')` is used to set register 'a' to "text" with character-wise type.
+   *
+   * @param register The register to set
+   * @param text The text to store in the register
+   * @param textType The type of text (character-wise, line-wise, or block-wise)
+   * @return True if the register was successfully set, false otherwise
+   */
+  fun setReg(register: Char, text: String, textType: TextType = TextType.CHARACTER_WISE): Boolean
+
+  /**
+   * Gets a mark by its character key for the current caret.
+   *
+   * @param char The character key of the mark (a-z, 0-9, etc.)
+   * @return The mark, or null if the mark doesn't exist
+   */
+  fun getMark(char: Char): Mark?
+
+  /**
+   * All local marks for the current caret.
+   */
+  val localMarks: Set<Mark>
+
+  /**
+   * Sets a mark at the current caret position.
+   *
+   * @param char The character key of the mark (a-z, etc.)
+   * @return True if the mark was successfully set, false otherwise
+   */
+  fun setMark(char: Char): Boolean
+
+  /**
+   * Sets a mark at the specified offset.
+   *
+   * @param char The character key of the mark (a-z, etc.)
+   * @param offset The offset to set the mark to
+   * @return True if the mark was successfully set, false otherwise
+   */
+  fun setMark(char: Char, offset: Int): Boolean
+
+  /**
+   * Removes a local mark for the current caret.
+   *
+   * @param char The character key of the mark to remove (a-z, etc.)
+   */
+  fun removeLocalMark(char: Char)
+
+  /**
+   * Resets all marks for the current caret.
+   */
+  fun resetAllMarksForCaret()
+
+  /**
+   * Scrolls a full page up or down.
+   *
+   * @param pages The number of pages to scroll. Positive values scroll down, negative values scroll up.
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollFullPage(pages: Int): Boolean
+
+  /**
+   * Scrolls half a page up.
+   *
+   * @param lines The number of lines to scroll.
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollHalfPageUp(lines: Int): Boolean
+
+  /**
+   * Scrolls half a page up.
+   *
+   * @param lines The number of lines to scroll.
+   * @return True if the scroll was successful, false otherwise
+   */
+  fun scrollHalfPageDown(lines: Int): Boolean
+
+  /**
+   * Selects a window in the same row as the current window.
+   *
+   * @param relativePosition The relative position of the window to select.
+   *                        Positive values select windows to the right,
+   *                        negative values select windows to the left.
+   */
+  fun selectWindowHorizontally(relativePosition: Int)
+
+  /**
+   * Selects a window in the same column as the current window.
+   *
+   * @param relativePosition The relative position of the window to select.
+   *                        Positive values select the windows below,
+   *                        negative values select the windows above.
+   */
+  fun selectWindowInVertically(relativePosition: Int)
+
+  /**
+   * Finds the offset of the next paragraph boundary.
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @param includeWhitespaceLines Should be `true` if we consider lines with whitespaces as empty.
+   * @return next paragraph off
+   */
+  fun getNextParagraphBoundOffset(count: Int = 1, includeWhitespaceLines: Boolean = true): Int?
+
+  /**
+   * Finds the next sentence start in the editor from the given offset, based on the specified parameters.
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @param includeCurrent If `true`, includes the current sentence if at its boundary.
+   * @param requireAll If `true`, returns `null` if fewer than [count] sentences are found.
+   * @return The offset of the next sentence start, or `null` if not found or constraints cannot be met.
+   */
+  fun getNextSentenceStart(count: Int = 1, includeCurrent: Boolean, requireAll: Boolean = true): Int?
+
+  /**
+   * Find the next section in the editor.
+   *
+   * @param marker The type of section to find.
+   * @param count Search for the [count]-th occurrence.
+   * @return The offset of the next section.
+   */
+  fun getNextSectionStart(marker: Char, count: Int = 1): Int
+
+  /**
+   * Find the start of the previous section in the editor.
+   *
+   * @param marker The type of section to find.
+   * @param count Search for the [count]-th occurrence.
+   * @return The offset of the next section.
+   */
+  fun getPreviousSectionStart(marker: Char, count: Int = 1): Int
+
+  /**
+   * Finds the end offset of the next sentence from the current caret position.
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @param includeCurrent Whether to count the current position as a sentence end
+   * @param requireAll Whether to require all sentence ends to be found
+   * @return The offset of the next sentence end, or null if not found
+   */
+  fun getNextSentenceEnd(count: Int = 1, includeCurrent: Boolean, requireAll: Boolean = true): Int?
+
+  /**
+   * Finds the end offset of the next method from the current caret position.
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @return The offset of the end of the next method.
+   */
+  fun getMethodEndOffset(count: Int = 1): Int
+
+  /**
+   * Finds the start offset of the next method from the current caret position.
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @return The offset of the start of the next method.
+   */
+  fun getMethodStartOffset(count: Int = 1): Int
+
+  /**
+   * Finds the next occurrence of a specific character on the current line.
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @param char The character to find.
+   * @return The offset of the found character, or -1 if not found.
+   */
+  fun getNextCharOnLineOffset(count: Int = 1, char: Char): Int
+
+  /**
+   * Finds the word at or following the current caret position.
+   *
+   * Note that if no word/WORD is found at or following the caret on the current line, the WORD at or following is
+   * always returned.
+   *
+   * @param isBigWord Search for word or WORD.
+   * @return A Range representing the found word, or null if no word is found.
+   */
+  fun getCurrentOrFollowingWord(isBigWord: Boolean): Range?
+
+  /**
+   * Find the range of the word text object at the location of the caret
+   */
+  fun getWordTextObjectRange(count: Int = 1, isOuter: Boolean, isBigWord: Boolean): Range
+
+  /**
+   * Find the range of the sentence text object at the location of the caret
+   */
+  fun getSentenceRange(count: Int = 1, isOuter: Boolean): Range
+
+  /**
+   * Returns range of a paragraph containing the caret
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @param isOuter true if it is an outer motion, false otherwise
+   * @return the paragraph text range
+   */
+  fun getParagraphRange(count: Int = 1, isOuter: Boolean): Range?
+
+  /**
+   * Find the range of a block tag at the location of the caret
+   */
+  fun getBlockTagRange(count: Int = 1, isOuter: Boolean): Range?
+
+  /**
+   * Find a block quote in the current line at the location of the caret
+   *
+   * @param quote The quote character to find
+   * @param isOuter Whether to include the quotes in the range
+   * @return The range of the block quote, or null if not found
+   */
+  fun getBlockQuoteInLineRange(quote: Char, isOuter: Boolean): Range?
+
+  /**
+   * Finds the offset of the next misspelled word from the current caret position.
+   *
+   * @param count Search for the [count]-th occurrence.
+   * @return The offset of the next misspelled word.
+   */
+  fun getNextMisspelledWordOffset(count: Int = 1): Int
+}

api/src/main/kotlin/com/intellij/vim/api/scopes/editor/caret/CaretTransaction.kt

@@ -0,0 +1,121 @@
+/*
+ * 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.intellij.vim.api.scopes.editor.caret
+
+import com.intellij.vim.api.models.Range
+import com.intellij.vim.api.scopes.VimApiDsl
+import com.intellij.vim.api.scopes.editor.EditorAccessor
+
+/**
+ * Scope for caret operations that should be executed under the write lock.
+ */
+@VimApiDsl
+interface CaretTransaction : CaretRead, EditorAccessor {
+  /**
+   * Updates the caret position and optionally sets a selection.
+   *
+   * If a selection is provided, the caret will have this selection after moving to the new offset.
+   * If no selection is provided, any existing selection will be removed.
+   *
+   * The selection range is exclusive, meaning that the character at the end offset is not
+   * included in the selection. For example, a selection of (0, 3) would select the first
+   * three characters of the text.
+   *
+   * @param offset The new offset (position) for the caret
+   * @param selection Optional selection range
+   * @throws IllegalArgumentException If the offset is not in the valid range [0, fileSize),
+   *                                 or if the selection range is invalid (start or end out of range,
+   *                                 or start > end)
+   */
+  fun updateCaret(offset: Int, selection: Range.Simple? = null)
+
+  /**
+   * Inserts text at the specified position in the document.
+   *
+   * @param position The position (offset) where the text should be inserted
+   *      (a zero-base character offset from the start of the document)
+   * @param text The text to insert
+   * @param caretAtEnd If true (default), places the caret after on the last character of the inserted text;
+   *                              if false, places the caret at the beginning of the inserted text
+   * @param insertBeforeCaret If true, inserts the text before the specified position;
+   *                    if false (default), inserts the text at the specified position
+   * @return true if the insertion was successful, false otherwise
+   * @throws IllegalArgumentException If the position is not in the valid range [0, fileSize)
+   */
+  fun insertText(
+    position: Int,
+    text: String,
+    caretAtEnd: Boolean = true,
+    insertBeforeCaret: Boolean = false,
+  ): Boolean
+
+  /**
+   * Replaces the text between startOffset (inclusive) and endOffset (exclusive)
+   * with the specified text. After the operation, the caret is positioned before the last
+   * character of the replaced text.
+   *
+   * @param startOffset The start offset (inclusive) of the text to be replaced
+   * @param endOffset The end offset (exclusive) of the text to be replaced
+   * @param text The new text to replace the existing text
+   * @return true if the replacement was successful, false otherwise
+   * @throws IllegalArgumentException If the offsets are not in the valid range [0, fileSize),
+   *                                 or if startOffset > endOffset
+   */
+  fun replaceText(
+    startOffset: Int,
+    endOffset: Int,
+    text: String,
+  ): Boolean
+
+  /**
+   * Replaces text in multiple ranges (blocks) with new text.
+   *
+   * This function performs a blockwise replacement, replacing each range in the block
+   * with the corresponding string from the text list. The number of replacement strings
+   * must match the number of ranges in the block.
+   *
+   * @param range A block of ranges to be replaced
+   * @param text A list of strings to replace each range in the block
+   * @throws IllegalArgumentException If the size of the text list doesn't match the number of ranges in the block,
+   *                                 or if any range in the block is invalid
+   */
+  fun replaceTextBlockwise(
+    range: Range.Block,
+    text: List<String>,
+  )
+
+  /**
+   * Deletes text between the specified offsets.
+   *
+   * This function deletes the text between startOffset (inclusive) and endOffset (exclusive).
+   * If startOffset equals endOffset, no text is deleted.
+   * If startOffset > endOffset, the implementation swaps them and deletes the text between them.
+   *
+   * @param startOffset The start offset (inclusive) of the text to be deleted
+   * @param endOffset The end offset (exclusive) of the text to be deleted
+   * @return true if the deletion was successful, false otherwise
+   * @throws Exception If endOffset is beyond the file size
+   */
+  fun deleteText(
+    startOffset: Int,
+    endOffset: Int,
+  ): Boolean
+
+  /**
+   * Adds a jump with the current caret's position to the jump list.
+   *
+   * @param reset Whether to reset the current position in the jump list
+   */
+  fun addJump(reset: Boolean)
+
+  /**
+   * Saves the location of the current caret to the jump list and sets the ' mark.
+   */
+  fun saveJumpLocation()
+}

build.gradle.kts

@@ -31,12 +31,13 @@ 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
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 import org.kohsuke.github.GHUser
-import java.net.HttpURLConnection
-import java.net.URL
 
 buildscript {
   repositories {
@@ -45,19 +46,19 @@ buildscript {
   }
 
   dependencies {
-    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.21")
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.2.0")
     classpath("com.github.AlexPl292:mark-down-to-slack:1.1.2")
     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.3.0.202506031305-r")
     classpath("org.kohsuke:github-api:1.305")
 
-    classpath("io.ktor:ktor-client-core:3.1.1")
-    classpath("io.ktor:ktor-client-cio:3.1.1")
-    classpath("io.ktor:ktor-client-auth:3.1.1")
-    classpath("io.ktor:ktor-client-content-negotiation:3.1.1")
-    classpath("io.ktor:ktor-serialization-kotlinx-json:3.1.1")
+    classpath("io.ktor:ktor-client-core:3.3.0")
+    classpath("io.ktor:ktor-client-cio:3.3.0")
+    classpath("io.ktor:ktor-client-auth:3.3.0")
+    classpath("io.ktor:ktor-client-content-negotiation:3.3.0")
+    classpath("io.ktor:ktor-serialization-kotlinx-json:3.3.0")
 
     // This comes from the changelog plugin
 //        classpath("org.jetbrains:markdown:0.3.1")
@@ -66,14 +67,19 @@ buildscript {
 
 plugins {
   java
-  kotlin("jvm") version "2.0.21"
+  kotlin("jvm") version "2.2.0"
   application
   id("java-test-fixtures")
-  id("org.jetbrains.intellij.platform") version "2.3.0"
-  id("org.jetbrains.changelog") version "2.2.1"
+
+  // 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.9.0"
+
+  id("org.jetbrains.changelog") version "2.4.0"
   id("org.jetbrains.kotlinx.kover") version "0.6.1"
   id("com.dorongold.task-tree") version "4.0.1"
-  id("com.google.devtools.ksp") version "2.0.21-1.0.25"
+  id("com.google.devtools.ksp") version "2.2.0-2.0.2"
 }
 
 val moduleSources by configurations.registering
@@ -103,21 +109,26 @@ repositories {
 
 dependencies {
   api(project(":vim-engine"))
+  api(project(":api"))
   ksp(project(":annotation-processors"))
   compileOnly(project(":annotation-processors"))
 
   compileOnly("org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion")
-  compileOnly("org.jetbrains:annotations:26.0.2")
+  compileOnly("org.jetbrains:annotations:26.0.2-1")
 
   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")
     // Or something like: intellijIdeaUltimate(ideaVersion)
-    create(ideaType, ideaVersion, useInstaller)
+    create(ideaType, ideaVersion) { this.useInstaller = useInstaller }
 
     pluginVerifier()
     zipSigner()
@@ -127,16 +138,27 @@ 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", "243.21565.122")
+    plugin("com.intellij.classic.ui", "251.23774.318")
 
-    bundledPlugins("org.jetbrains.plugins.terminal", "com.intellij.modules.json")
+    bundledPlugins("org.jetbrains.plugins.terminal")
+
+    // VERSION UPDATE: This module is required since 2025.2
+    if (ideaVersion == "LATEST-EAP-SNAPSHOT") {
+      bundledModule("intellij.spellchecker")
+    }
+    if (ideaVersion.startsWith("2025.2")) {
+      bundledModule("intellij.spellchecker")
+    }
+    if (ideaVersion.startsWith("2025.3")) {
+      bundledModule("intellij.spellchecker")
+    }
   }
 
   moduleSources(project(":vim-engine", "sourcesJarArtifacts"))
 
   // --------- Test dependencies ----------
 
-  testApi("com.squareup.okhttp3:okhttp:4.12.0")
+  testApi("com.squareup.okhttp3:okhttp:5.0.0")
 
   // https://mvnrepository.com/artifact/com.ensarsarajcic.neovim.java/neovim-api
   testImplementation("com.ensarsarajcic.neovim.java:neovim-api:0.2.3")
@@ -149,19 +171,19 @@ dependencies {
   testFixturesImplementation("org.jetbrains.kotlin:kotlin-test:$kotlinVersion")
 
   // https://mvnrepository.com/artifact/org.mockito.kotlin/mockito-kotlin
-  testImplementation("org.mockito.kotlin:mockito-kotlin:5.4.0")
+  testImplementation("org.mockito.kotlin:mockito-kotlin:6.1.0")
 
-  testImplementation("org.junit.jupiter:junit-jupiter-api:5.12.0")
-  testImplementation("org.junit.jupiter:junit-jupiter-engine:5.12.0")
-  testImplementation("org.junit.jupiter:junit-jupiter-params:5.12.0")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-api:5.12.0")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-engine:5.12.0")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-params:5.12.0")
+  testImplementation("org.junit.jupiter:junit-jupiter-api:6.0.0")
+  testImplementation("org.junit.jupiter:junit-jupiter-engine:6.0.0")
+  testImplementation("org.junit.jupiter:junit-jupiter-params:6.0.0")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-api:6.0.0")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-engine:6.0.0")
+  testFixturesImplementation("org.junit.jupiter:junit-jupiter-params:6.0.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:6.0.0")
 //  testFixturesImplementation("org.junit.vintage:junit-vintage-engine:5.10.3")
 }
 
@@ -189,12 +211,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,
-    //   so we can turn it on for local development
-    if (environment["TEAMCITY_VERSION"] == null) {
-      println("Set env TEAMCITY_VERSION to X to enable project leak checks from the platform")
-      environment("TEAMCITY_VERSION" to "X")
-    }
+    println("Project leak checks: If you experience project leaks on TeamCity that doesn't reproduce locally")
+    println("Uncomment the following line in build.gradle to enable leak checks (see build.gradle config)")
+//      environment("TEAMCITY_VERSION" to "X")
 
     systemProperty("ideavim.nvim.test", System.getProperty("nvim") ?: false)
 
@@ -214,42 +233,11 @@ tasks {
     options.encoding = "UTF-8"
   }
 
-  compileKotlin {
-    kotlinOptions {
-      jvmTarget = javaVersion
-      // See https://plugins.jetbrains.com/docs/intellij/using-kotlin.html#kotlin-standard-library
-      // For the list of bundled versions
-      apiVersion = "2.0"
-      freeCompilerArgs = listOf(
-        "-Xjvm-default=all-compatibility",
-
-        // Needed to compile the AceJump which uses kotlin beta
-        //  Without these two option compilation fails
-        "-Xskip-prerelease-check",
-        "-Xallow-unstable-dependencies",
-      )
-//            allWarningsAsErrors = true
-    }
-  }
-
-  compileTestKotlin {
-    enabled = false
-    
-    kotlinOptions {
-      jvmTarget = javaVersion
-      apiVersion = "2.0"
-
-      // Needed to compile the AceJump which uses kotlin beta
-      //  Without these two option compilation fails
-      freeCompilerArgs += listOf("-Xskip-prerelease-check", "-Xallow-unstable-dependencies")
-//            allWarningsAsErrors = true
-    }
-  }
-
   // Note that this will run the plugin installed in the IDE specified in dependencies. To run in a different IDE, use
   // 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
@@ -318,6 +306,23 @@ kotlin {
   jvmToolchain {
     languageVersion.set(JavaLanguageVersion.of(javaVersion))
   }
+
+  compilerOptions {
+    jvmTarget.set(JvmTarget.fromTarget(javaVersion))
+
+    // See https://plugins.jetbrains.com/docs/intellij/using-kotlin.html#kotlin-standard-library
+    // For the list of bundled versions
+    apiVersion.set(KotlinVersion.KOTLIN_2_0)
+    freeCompilerArgs = listOf(
+      "-Xjvm-default=all-compatibility",
+
+      // Needed to compile the AceJump which uses kotlin beta
+      //  Without these two option compilation fails
+      "-Xskip-prerelease-check",
+      "-Xallow-unstable-dependencies",
+    )
+//            allWarningsAsErrors = true
+  }
 }
 
 gradle.projectsEvaluated {
@@ -364,7 +369,7 @@ intellijPlatform {
     password.set(providers.environmentVariable("PRIVATE_KEY_PASSWORD"))
   }
 
-  verifyPlugin {
+  pluginVerification {
     teamCityOutputFormat = true
     ides {
       recommended()
@@ -379,6 +384,7 @@ ksp {
   arg("vimscript_functions_file", "intellij_vimscript_functions.json")
   arg("ex_commands_file", "intellij_ex_commands.json")
   arg("commands_file", "intellij_commands.json")
+  arg("extensions_file", "ideavim_extensions.json")
 }
 
 afterEvaluate {
@@ -409,7 +415,7 @@ koverMerged {
 
 // --- Slack notification
 
-tasks.register("slackNotification") {
+tasks.register<Task>("slackNotification") {
   doLast {
     if (version.toString().last() != '0') return@doLast
     if (slackUrl.isBlank()) {
@@ -437,20 +443,25 @@ tasks.register("slackNotification") {
         """.trimIndent()
 
     println("Parsed data: $slackDown")
-    val post = URL(slackUrl)
-    with(post.openConnection() as HttpURLConnection) {
-      requestMethod = "POST"
-      doOutput = true
-      setRequestProperty("Content-Type", "application/json")
 
-      outputStream.write(message.toByteArray())
+    runBlocking {
+      val client = HttpClient(CIO)
+      try {
+        val response = client.post(slackUrl) {
+          contentType(ContentType.Application.Json)
+          setBody(message)
+        }
 
-      val postRc = responseCode
-      println("Response code: $postRc")
-      if (postRc == 200) {
-        println(inputStream.bufferedReader().use { it.readText() })
-      } else {
-        println(errorStream.bufferedReader().use { it.readText() })
+        val responseCode = response.status.value
+        println("Response code: $responseCode")
+
+        val responseBody = response.body<String>()
+        println(responseBody)
+      } catch (e: Exception) {
+        println("Error sending Slack notification: ${e.message}")
+        throw e
+      } finally {
+        client.close()
       }
     }
   }
@@ -465,7 +476,7 @@ tasks.register("slackNotification") {
 // }
 
 // --- Update authors
-tasks.register("updateAuthors") {
+tasks.register<Task>("updateAuthors") {
   doLast {
     val uncheckedEmails = setOf(
       "aleksei.plate@jetbrains.com",
@@ -481,7 +492,7 @@ tasks.register("updateAuthors") {
 
 val prId: String by project
 
-tasks.register("updateMergedPr") {
+tasks.register<Task>("updateMergedPr") {
   doLast {
     val x = changelog.getUnreleased()
     println("x")
@@ -494,13 +505,13 @@ tasks.register("updateMergedPr") {
   }
 }
 
-tasks.register("updateChangelog") {
+tasks.register<Task>("updateChangelog") {
   doLast {
     updateChangelog()
   }
 }
 
-tasks.register("updateYoutrackOnCommit") {
+tasks.register<Task>("updateYoutrackOnCommit") {
   doLast {
     updateYoutrackOnCommit()
   }
@@ -511,12 +522,13 @@ val fixVersionsFieldId = "123-285"
 val fixVersionsFieldType = "VersionProjectCustomField"
 val fixVersionsElementType = "VersionBundleElement"
 
-tasks.register("releaseActions") {
+tasks.register<Task>("releaseActions") {
   group = "other"
   doLast {
     if (releaseType == "patch") return@doLast
 
-    val tickets = getYoutrackTicketsByQuery("%23%7BReady+To+Release%7D%20and%20tag:%20%7BIdeaVim%20Released%20In%20EAP%7D%20")
+    val tickets =
+      getYoutrackTicketsByQuery("%23%7BReady+To+Release%7D%20and%20tag:%20%7BIdeaVim%20Released%20In%20EAP%7D%20")
     if (tickets.isNotEmpty()) {
       println("Updating statuses for tickets: $tickets")
       setYoutrackStatus(tickets, "Fixed")
@@ -534,7 +546,7 @@ tasks.register("releaseActions") {
   }
 }
 
-tasks.register("integrationsTest") {
+tasks.register<Task>("integrationsTest") {
   group = "other"
   doLast {
     val testTicketId = "VIM-2784"
@@ -583,7 +595,7 @@ fun guard(check: Boolean, ifWrong: () -> String) {
   }
 }
 
-tasks.register("testUpdateChangelog") {
+tasks.register<Task>("testUpdateChangelog") {
   group = "verification"
   description = "This is a task to manually assert the correctness of the update tasks"
   doLast {
@@ -822,7 +834,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,137 @@ in `~/.ideavimrc`. E.g. `set nosurround`.
 Available plugins:
 
 <details>
-<summary><h2>easymotion</h2></summary>
+<summary><h2>anyobject: Useful text objects like functions, arguments, classes, loops, list items, block comments, and more.</h2></summary>
+
+### Summary:
+An extension for IdeaVim plugin that adds useful text objects to improve your productivity on JetBrains IDEs.
+
+Text objects allow a more efficient way of communicating edition or selection actions in the editor. Instead of thinking in terms of characters, words, lines, or paragraphs, use more advance text constructs like quoted text, text between brackets, items in a collection, or programming language constructs like arguments, classes, functions, loops, or comments.
+
+By Ricardo Rodriguez
+
+### Setup
+
+- Install [Vim AnyObject](https://plugins.jetbrains.com/plugin/28333-vim-anyobject)
+- Add `set anyobject` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
+or restart the IDE.
+
+### Instructions
+
+[https://plugins.jetbrains.com/plugin/28333-vim-anyobject](https://plugins.jetbrains.com/plugin/28333-vim-anyobject)
+</details>
+<details>
+<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>dial: Advanced text increment and decrement functionality.</h2></summary>
+
+### Summary:
+IdeaVim extension with advanced text increment and decrement functionality. It enhances the standard increment/decrement functionality found in Vim editors by adding support for complex text patterns beyond simple numbers.
+
+Cycle through related values from various text elements, including numbers, dates, boolean values, operators, and programming language-specific keywords.
+
+By Ricardo Rodriguez
+
+### Setup
+
+- Install [Vim Dial](https://plugins.jetbrains.com/plugin/28237-vim-dial)
+- Add `set dial` to your `~/.ideavimrc` file, then run `:source ~/.ideavimrc`
+or restart the IDE.
+
+### Instructions
+
+[https://plugins.jetbrains.com/plugin/28237-vim-dial](https://plugins.jetbrains.com/plugin/28237-vim-dial)
+</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 +168,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'`
-   
-### 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'`
+- Add the following command to `~/.ideavimrc`: `Plug 'tommcdo/vim-exchange'`
     <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>
-   
-Original plugin: [vim-surround](https://github.com/tpope/vim-surround).
-   
+<summary><h2>FunctionTextObj: Adds text objects for manipulating functions/methods</h2></summary>
+
+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 +350,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 +376,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)  
-Original plugin: [commentary.vim](https://github.com/tpope/vim-commentary).
+### Summary:
+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>
-      <br/>
-      <code>set commentary</code>
+      <code>set NERDTree</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 +506,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>
-      <br/>
-      <code>set argtextobj</code>
+      <code>set surround</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
+https://github.com/tpope/vim-surround/blob/master/doc/surround.txt
 
 </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 +619,13 @@ https://github.com/kana/vim-textobj-entire/blob/master/doc/textobj-entire.txt
 </details>
    
 <details>
-<summary><h2>highlightedyank</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>
+<summary><h2>Which-Key: Displays available keybindings in popup</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 +635,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
-

doc/Plugin-API-introduction.md

@@ -0,0 +1,113 @@
+# Introduction to IdeaVim Plugin Development
+
+> **⚠️ EXPERIMENTAL API WARNING**
+> 
+> The Plugin API is currently in an **experimental stage** and is not yet recommended for production use.
+> 
+> - The API is subject to breaking changes without notice
+> - Features may be added, modified, or removed in future releases
+> - Documentation may not fully reflect the current implementation
+> - Use at your own risk for experimental purposes only
+> 
+> We welcome feedback and bug reports to help improve the API, but please be aware that stability is not guaranteed at this time.
+
+This guide explains and gives examples on how to create plugins for IdeaVim, the Vim emulation plugin for IntelliJ-based IDEs.
+Existing plugins can be found [here](IdeaVim%20Plugins.md).
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Plugin Architecture](#plugin-architecture)
+- [Scopes](#scopes)
+  - [Examples](#scopes-example)
+  - [Read and write operations](#read-and-transaction-operations)
+
+## Introduction
+
+IdeaVim plugins aim to extend the functionality of the IdeaVim plugin, allowing you to add custom Vim-like features to your IntelliJ-based IDE.
+These plugins can define new commands, mappings, operators, and more, just like Vim plugins do.
+
+The IdeaVim API provides a Kotlin DSL that makes it easy to create new plugins.
+
+## Plugin Architecture
+
+IdeaVim plugins are built using a scope-based architecture.
+Starting scope is the `VimApi`, which provides access to various aspects of the editor and Vim functionality.
+
+An IdeaVim plugin written with this API consists of:
+
+1. An entry point function with no parameters and return value annotated with `@VimPlugin`
+2. One or more scope blocks that define the plugin's functionality
+3. Mappings, commands, or other extensions that users can interact with
+
+Here's a minimal plugin structure:
+
+```kotlin
+@VimPlugin(name = "MyPlugin")
+fun VimApi.init() {
+    // Plugin initialization code
+    mappings {
+        nmap(keys = "<leader>x", label = "MyPluginAction") {
+            // Action implementation
+        }
+    }
+}
+```
+
+## Scopes
+
+IdeaVim plugins are written in scopes.
+They provide a structured way to write code, improve readability and ensure that functions can be called only within a specific scope.
+
+The base scope is `VimApi`, which provides access to general Vim functionality. From there, plugin writers can access more specialized scopes.
+The list of all scopes and their functions is available in the API reference ([link](Plugin-API-reference.md)).
+
+### Scopes example
+
+```kotlin
+editor {
+  // Now in EditorScope
+  change {
+    // Make changes to the document
+    withPrimaryCaret {
+      insertText(offset, "New text")
+    }
+  }
+}
+
+mappings {
+  // Now in MappingScope
+  nmap(keys = "gx", label = "OpenURL") {
+    // Action implementation
+  }
+}
+```
+
+### Read and Transaction Operations
+
+In the IdeaVim API there is a distinction between read and write operations:
+
+- **Read operations** access the state of the editor without modifying it
+- **Transaction operations** modify the state of the editor
+
+These operations must be executed under the appropriate locks to ensure thread safety:
+
+```kotlin
+// Read operation
+val deferred: Deferred<CharSequence> = editor {
+  read {
+    text  // Get the text of the document
+  }
+}
+runBlocking { println(deferred.await()) }
+
+// Transaction operation
+val job: Job = editor {
+  change {
+    forEachCaret {
+      insertText(offset, "Hello, world!")
+    }
+  }
+}
+runBlocking { job.join() }
+```

doc/Plugin-API-quick-start-guide.md

@@ -0,0 +1,177 @@
+# Quick Start Guide for IdeaVim Plugin Development
+
+> **⚠️ EXPERIMENTAL API WARNING**
+> 
+> The Plugin API is currently in an **experimental stage** and is not yet recommended for production use.
+> 
+> - The API is subject to breaking changes without notice
+> - Features may be added, modified, or removed in future releases
+> - Documentation may not fully reflect the current implementation
+> - Use at your own risk for experimental purposes only
+> 
+> We welcome feedback and bug reports to help improve the API, but please be aware that stability is not guaranteed at this time.
+
+This guide will help you get started with developing plugins for IdeaVim.
+We'll cover the essential concepts and show you how to create a simple plugin.
+
+## Setting Up Your First Plugin
+
+### 1. Project Setup
+
+For now, you can create plugin in the IdeaVim extensions package - [link](https://github.com/JetBrains/ideavim/tree/4764ffbbf545607ad4a5c482d74e0219002a5aca/src/main/java/com/maddyhome/idea/vim/extension).
+
+### 2. Create the Plugin Entry Point
+
+The entry point for an IdeaVim plugin is a function annotated with `@VimPlugin`:
+
+```kotlin
+@VimPlugin(name = "MyFirstPlugin")
+fun VimApi.init() {
+    // Plugin initialization code goes here
+}
+```
+
+Here we will register mappings, listeners, commands etc.
+
+### 3. Add Functionality
+
+Let's add a simple mapping that displays a message in the output panel:
+
+```kotlin
+@VimPlugin(name = "MyFirstPlugin")
+fun VimApi.init() {
+    mappings {
+        nmap(keys = "<leader>h", label = "HelloWorld") {
+            outputPanel {
+                setText("Hello from my first IdeaVim plugin!")
+            }
+        }
+    }
+}
+```
+
+## Basic Functionality Examples
+
+### Key Mappings
+
+You can define mappings for different Vim modes:
+
+```kotlin
+mappings {
+    // Normal mode mapping
+    nmap(keys = "<leader>x", label = "MyNormalAction") {
+        // Action implementation
+    }
+    
+    // Visual mode mapping
+    vmap(keys = "<leader>y", label = "MyVisualAction") {
+        // Action implementation
+    }
+    
+    // Insert mode mapping
+    imap(keys = "<C-d>", label = "MyInsertAction") {
+        // Action implementation
+    }
+}
+```
+
+### Working with Variables
+
+You can get and set Vim variables:
+
+```kotlin
+// Get a variable
+val count = getVariable<Int>("v:count1") ?: 1
+val register = getVariable<String>("v:register") ?: "\""
+
+// Set a variable
+setVariable("g:my_plugin_enabled", true)
+```
+
+### Executing Commands
+
+You can execute normal mode commands and Ex commands:
+
+```kotlin
+// Execute a normal mode command
+normal("dd")
+
+// Execute an Ex command
+execute(":set number")
+```
+
+### Text Manipulation
+
+You can manipulate text in the editor:
+
+```kotlin
+editor {
+    change {
+        forEachCaret {
+            // Insert text at the current caret position
+            insertText(offset, "Hello, world!")
+            
+            // Replace text in a range
+            replaceText(startOffset, endOffset, "New text")
+            
+            // Delete text in a range
+            deleteText(startOffset, endOffset)
+        }
+    }
+}
+```
+
+### Working with Registers
+
+Since JetBrains IDEs have multiple-caret support, in IdeaVim every caret has its own registers and marks.
+You can read from and write to registers like this:
+
+```kotlin
+// Read from register 'a'
+val text = editor {
+    read {
+        withPrimaryCaret { getReg('a') }
+    }
+}
+runBlocking { println(text.await()) }
+
+// Write to register 'b'
+val job = editor {
+    change {
+        withPrimaryCaret {
+            setReg('b', "New content", TextType.CHARACTER_WISE)
+        }
+    }
+}
+runBlocking { job.join() }
+```
+
+## A Simple Plugin Example
+
+Here's a simple plugin that adds a mapping to uppercase the selected text:
+
+```kotlin
+@VimPlugin(name = "ToUppercase")
+fun VimApi.init() {
+    mappings {
+        vmap(keys = "<leader>ll", label = "ToUpperCase") {
+            editor {
+                val job = change {
+                    forEachCaret {
+                        // Get the current selection
+                        val selectionStart = (selection as Range.Simple).start
+                        val selectionEnd = (selection as Range.Simple).end
+
+                        // Get the selected text
+                        val selectedText = text.substring(selectionStart, selectionEnd)
+
+                        // Replace with uppercase version
+                        replaceText(selectionStart, selectionEnd, selectedText.uppercase())
+                    }
+                }
+            }
+        }
+    }
+
+}
+```

doc/Plugin-API-reference.md

@@ -0,0 +1,564 @@
+# API Reference
+
+> **⚠️ EXPERIMENTAL API WARNING**
+> 
+> The Plugin API is currently in an **experimental stage** and is not yet recommended for production use.
+> 
+> - The API is subject to breaking changes without notice
+> - Features may be added, modified, or removed in future releases
+> - Documentation may not fully reflect the current implementation
+> - Use at your own risk for experimental purposes only
+> 
+> We welcome feedback and bug reports to help improve the API, but please be aware that stability is not guaranteed at this time.
+
+## VimApi
+
+The `VimApi` class is the main entry point for interacting with the Vim editor. It provides access to various functionalities like variable management, window operations, and text manipulation.
+
+### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `mode` | `Mode` | The current mode of the Vim editor. |
+| `tabCount` | `Int` | Gets the number of tabs in the current window. |
+| `currentTabIndex` | `Int?` | The index of the current tab or null if there is no tab selected or no tabs are open. |
+
+### Methods
+
+#### Variable Management
+
+| Method | Description                                                                                             | Return Value |
+|--------|---------------------------------------------------------------------------------------------------------|--------------|
+| `getVariable<T : Any>(name: String): T?` | Gets a variable with the specified name and scope.                                                      | The variable value or null if not found. |
+| `setVariable<T : Any>(name: String, value: T)` | Sets a variable with the specified name and value. In Vim, this is equivalent to `let varname = value`. | None |
+
+#### Operator Functions
+
+| Method                                                                         | Description | Return Value |
+|--------------------------------------------------------------------------------|-------------|--------------|
+| `exportOperatorFunction(name: String, function: suspend VimApi.() -> Boolean)` | Exports a function as an operator function. | None |
+| `setOperatorFunction(name: String)`                                            | Sets the operator function to use. | None |
+| `normal(command: String)`                                                      | Executes a normal mode command. | None |
+
+#### Editor Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `editor<T>(block: EditorScope.() -> T): T` | Executes a block of code in the context of the current editor. | The result of the block. |
+| `forEachEditor<T>(block: EditorScope.() -> T): List<T>` | Executes a block of code for each open editor. | A list of results from each editor. |
+
+#### Scope Access
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `mappings(block: MappingScope.() -> Unit)` | Executes a block of code in the mapping scope. | None |
+| `listeners(block: ListenersScope.() -> Unit)` | Executes a block of code in the listeners scope. | None |
+| `outputPanel(block: OutputPanelScope.() -> Unit)` | Executes a block of code in the output panel scope. | None |
+| `modalInput(): ModalInput` | Gets the modal input scope. | The modal input scope. |
+| `commandLine(block: CommandLineScope.() -> Unit)` | Executes a block of code in the command line scope. | None |
+| `option<T>(block: OptionScope.() -> T): T` | Executes a block of code in the option scope. | The result of the block execution. |
+| `digraph(block: DigraphScope.() -> Unit)` | Executes a block of code in the digraph scope. | None |
+
+#### Tab Management
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `removeTabAt(indexToDelete: Int, indexToSelect: Int)` | Removes a tab at the specified index and selects another tab. | None |
+| `moveCurrentTabToIndex(index: Int)` | Moves the current tab to the specified index. | None |
+| `closeAllExceptCurrentTab()` | Closes all tabs except the current one. | None |
+
+#### Pattern Matching
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `matches(pattern: String, text: String, ignoreCase: Boolean = false): Boolean` | Checks if a pattern matches a text. | True if the pattern matches the text, false otherwise. |
+| `getAllMatches(text: String, pattern: String): List<Pair<Int, Int>>` | Finds all matches of a pattern in a text. | A list of pairs representing the start and end offsets of each match. |
+
+#### Window Management
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `selectNextWindow()` | Selects the next window in the editor. | None |
+| `selectPreviousWindow()` | Selects the previous window in the editor. | None |
+| `selectWindow(index: Int)` | Selects a window by its index. | None |
+| `splitWindowVertically(filename: String? = null)` | Splits the current window vertically and optionally opens a file in the new window. | None |
+| `splitWindowHorizontally(filename: String? = null)` | Splits the current window horizontally and optionally opens a file in the new window. | None |
+| `closeAllExceptCurrentWindow()` | Closes all windows except the current one. | None |
+| `closeCurrentWindow()` | Closes the current window. | None |
+| `closeAllWindows()` | Closes all windows in the editor. | None |
+
+#### Script Execution
+
+| Method                                                     | Description | Return Value |
+|------------------------------------------------------------|-------------|--------------|
+| `execute(script: String): Boolean`                         | Parses and executes the given Vimscript string. It can be used to execute ex commands, such as `:set`, `:map`, etc. | The result of the execution, which can be Success or Error. |
+| `command(command: String, block: VimApi.(String) -> Unit)` | Defines a new command. | None |
+
+#### Data Storage
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `getDataFromWindow<T>(key: String): T?` | Gets keyed data from a Vim window. | The data associated with the key, or null if no data is found. |
+| `putDataToWindow<T>(key: String, data: T)` | Stores keyed user data in a Vim window. | None |
+| `getDataFromBuffer<T>(key: String): T?` | Gets data from buffer. Vim stores there buffer scoped (`b:`) variables and local options. | The data associated with the key, or null if no data is found. |
+| `putDataToBuffer<T>(key: String, data: T)` | Puts data to buffer. Vim stores there buffer scoped (`b:`) variables and local options. | None |
+| `getDataFromTab<T>(key: String): T?` | Gets data from tab (group of windows). Vim stores there tab page scoped (`t:`) variables. | The data associated with the key, or null if no data is found. |
+| `putDataToTab<T>(key: String, data: T)` | Puts data to tab (group of windows). Vim stores there tab page scoped (`t:`) variables. | None |
+| `getOrPutWindowData<T>(key: String, provider: () -> T): T` | Gets data from window or puts it if it doesn't exist. | The existing data or the newly created data. |
+| `getOrPutBufferData<T>(key: String, provider: () -> T): T` | Gets data from buffer or puts it if it doesn't exist. | The existing data or the newly created data. |
+| `getOrPutTabData<T>(key: String, provider: () -> T): T` | Gets data from tab or puts it if it doesn't exist. | The existing data or the newly created data. |
+
+#### File Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `saveFile()` | Saves the current file. In Vim, this is equivalent to the `:w` command. | None |
+| `closeFile()` | Closes the current file. In Vim, this is equivalent to the `:q` command. | None |
+
+#### Text Navigation
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `getNextCamelStartOffset(chars: CharSequence, startIndex: Int, count: Int = 1): Int?` | Finds the start offset of the next word in camel case or snake case text. | The offset of the next word start, or null if not found. |
+| `getPreviousCamelStartOffset(chars: CharSequence, endIndex: Int, count: Int = 1): Int?` | Finds the start offset of the previous word in camel case or snake case text. | The offset of the previous word start, or null if not found. |
+| `getNextCamelEndOffset(chars: CharSequence, startIndex: Int, count: Int = 1): Int?` | Finds the end offset of the next word in camel case or snake case text. | The offset of the next word end, or null if not found. |
+| `getPreviousCamelEndOffset(chars: CharSequence, endIndex: Int, count: Int = 1): Int?` | Finds the end offset of the previous word in camel case or snake case text. | The offset of the previous word end, or null if not found. |
+
+## EditorScope
+
+The `EditorScope` class provides access to read and write operations on the editor. It serves as a bridge between the read-only and transaction-based operations.
+
+### Methods
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `read<T>(block: suspend Read.() -> T): Deferred<T>` | Executes a block of code in the context of read operations. This allows for reading the editor state without modifying it. | A Deferred result of the block execution. |
+| `change(block: suspend Transaction.() -> Unit): Job` | Executes a block of code in the context of transaction operations. This allows for modifying the editor state. | A Job representing the asynchronous operation. |
+
+## ReadScope
+
+The `ReadScope` interface provides read-only access to the editor content and state. It includes methods for navigating text, working with carets, and querying editor information.
+
+### Properties
+
+| Property           | Type              | Description                                     |
+|--------------------|-------------------|-------------------------------------------------|
+| `textLength`       | `Long`            | The total length of the text in the editor.     |
+| `text`             | `CharSequence`    | The entire text content of the editor.          |
+| `lineCount`        | `Int`             | The number of lines in the editor.              |
+| `filePath`         | `Path`            | File path of the editor.                        |
+| `caretData`        | `List<CaretData>` | Information about all carets in the editor.     |
+| `caretIds`         | `List<CaretId>`   | The IDs of all carets in the editor.            |
+| `globalMarks`      | `Set<Mark>`       | All global marks defined in the editor.         |
+| `jumps`            | `List<Jump>`      | All jumps in the jump list.                     |
+| `currentJumpIndex` | `Int`             | Index of the current position in the jump list. |
+
+### Methods
+
+#### Caret Operations
+
+| Method                                                           | Description | Return Value                       |
+|------------------------------------------------------------------|-------------|------------------------------------|
+| `forEachCaret<T>(block: suspend CaretRead.() -> T): List<T>`     | Executes a block of code for each caret in the editor. | A list of results from each caret. |
+| `with<T>(caretId: CaretId, block: suspend CaretRead.() -> T): T` | Executes a block of code with a specific caret. | Result from caret.                 |
+| `withPrimaryCaret<T>(block: suspend CaretRead.() -> T): T`       | Executes a block of code with the primary caret. | Result from caret.                 |
+
+#### Line Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `getLineStartOffset(line: Int): Int` | Gets the offset of the start of a line. | The offset of the line start. |
+| `getLineEndOffset(line: Int, allowEnd: Boolean): Int` | Gets the offset of the end of a line. | The offset of the line end. |
+| `getLine(offset: Int): Line` | Gets the line at the specified offset. | The Line object. |
+
+#### Mark and Jump Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `getGlobalMark(char: Char): Mark?` | Gets a global mark by its character key. | The mark, or null if the mark doesn't exist. |
+| `getJump(count: Int = 0): Jump?` | Gets a jump from the jump list. | The jump, or null if there is no jump at the specified position. |
+
+#### Scrolling Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `scrollCaretIntoView()` | Scrolls the caret into view. | None |
+| `scrollVertically(lines: Int): Boolean` | Scrolls the editor by a specified number of lines. | True if the scroll was successful, false otherwise. |
+| `scrollLineToTop(line: Int, start: Boolean): Boolean` | Scrolls the current line to the top of the display. | True if the scroll was successful, false otherwise. |
+| `scrollLineToMiddle(line: Int, start: Boolean): Boolean` | Scrolls the current line to the middle of the display. | True if the scroll was successful, false otherwise. |
+| `scrollLineToBottom(line: Int, start: Boolean): Boolean` | Scrolls the current line to the bottom of the display. | True if the scroll was successful, false otherwise. |
+| `scrollHorizontally(columns: Int): Boolean` | Scrolls the editor horizontally by a specified number of columns. | True if the scroll was successful, false otherwise. |
+| `scrollCaretToLeftEdge(): Boolean` | Scrolls the editor to position the caret column at the left edge of the display. | True if the scroll was successful, false otherwise. |
+| `scrollCaretToRightEdge(): Boolean` | Scrolls the editor to position the caret column at the right edge of the display. | True if the scroll was successful, false otherwise. |
+
+#### Text Navigation
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `getNextParagraphBoundOffset(startLine: Int, count: Int = 1, includeWhitespaceLines: Boolean = true): Int?` | Find the next paragraph-bound offset in the editor. | The offset of the next paragraph bound, or null if not found. |
+| `getNextSentenceStart(startOffset: Int, count: Int = 1, includeCurrent: Boolean, requireAll: Boolean = true): Int?` | Finds the next sentence start in the editor from the given offset. | The offset of the next sentence start, or null if not found. |
+| `getNextSectionStart(startLine: Int, marker: Char, count: Int = 1): Int` | Find the next section in the editor. | The offset of the next section. |
+| `getPreviousSectionStart(startLine: Int, marker: Char, count: Int = 1): Int` | Find the start of the previous section in the editor. | The offset of the previous section. |
+| `getNextSentenceEnd(startOffset: Int, count: Int = 1, includeCurrent: Boolean, requireAll: Boolean = true): Int?` | Find the next sentence end from the given offset. | The offset of the next sentence end, or null if not found. |
+| `getNextWordStartOffset(startOffset: Int, count: Int = 1, isBigWord: Boolean): Int?` | Find the next word in the editor's document, from the given starting point. | The offset of the next word, or null if not found. |
+| `getNextWordEndOffset(startOffset: Int, count: Int = 1, isBigWord: Boolean, stopOnEmptyLine: Boolean = true): Int` | Find the end offset of the next word in the editor's document. | The offset of the next word end. |
+| `getNextCharOnLineOffset(startOffset: Int, count: Int = 1, char: Char): Int` | Find the next character on the current line. | The offset of the next character, or -1 if not found. |
+| `getNearestWordOffset(startOffset: Int): Range?` | Find the word at or nearest to the given offset. | The range of the word, or null if not found. |
+| `getParagraphRange(line: Int, count: Int = 1, isOuter: Boolean): Range?` | Returns range of a paragraph containing the given line. | The paragraph text range, or null if not found. |
+| `getBlockQuoteInLineRange(startOffset: Int, quote: Char, isOuter: Boolean): Range?` | Find a block quote in the current line. | The range of the block quote, or null if not found. |
+
+#### Pattern Matching
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `findAll(pattern: String, startLine: Int, endLine: Int, ignoreCase: Boolean = false): List<Range>` | Finds all occurrences of the given pattern within a specified line range. | A list of Ranges representing all matches found. |
+| `findPattern(pattern: String, startOffset: Int, count: Int = 1, backwards: Boolean = false): Range?` | Finds text matching the given Vim-style regular expression pattern. | A Range representing the matched text, or null if no match is found. |
+
+## Transaction
+
+The `Transaction` interface provides methods for modifying the editor content and state. It includes operations for working with carets, highlights, marks, and jumps.
+
+### Methods
+
+#### Caret Operations
+
+| Method                                                                  | Description | Return Value                       |
+|-------------------------------------------------------------------------|-------------|------------------------------------|
+| `forEachCaret<T>(block: suspend CaretTransaction.() -> T): List<T>`     | Executes a block of code for each caret in the editor. | A list of results from each caret. |
+| `with<T>(caretId: CaretId, block: suspend CaretTransaction.() -> T): T` | Executes a block of code with a specific caret. | Result from caret.                 |
+| `withPrimaryCaret<T>(block: suspend CaretTransaction.() -> T): T`       | Executes a block of code with the primary caret. | Result from caret.                               |
+| `addCaret(offset: Int): CaretId`                                        | Adds a new caret at the specified offset. | The ID of the newly created caret. |
+| `removeCaret(caretId: CaretId)`                                         | Removes a caret with the specified ID. | None                               |
+
+#### Highlighting
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `addHighlight(startOffset: Int, endOffset: Int, backgroundColor: Color?, foregroundColor: Color?): HighlightId` | Adds a highlight to the editor. | The ID of the newly created highlight. |
+| `removeHighlight(highlightId: HighlightId)` | Removes a highlight with the specified ID. | None |
+
+#### Mark Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `setMark(char: Char): Boolean` | Sets a mark at the current position for each caret in the editor. | True if the mark was successfully set, false otherwise. |
+| `removeMark(char: Char)` | Removes a mark for all carets in the editor. | None |
+| `setGlobalMark(char: Char): Boolean` | Sets a global mark at the current position. | True if the mark was successfully set, false otherwise. |
+| `removeGlobalMark(char: Char)` | Removes a global mark. | None |
+| `setGlobalMark(char: Char, offset: Int): Boolean` | Sets a global mark at the specified offset. | True if the mark was successfully set, false otherwise. |
+| `resetAllMarks()` | Resets all marks. | None |
+
+#### Jump List Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `addJump(jump: Jump, reset: Boolean)` | Adds a specific jump to the jump list. | None |
+| `removeJump(jump: Jump)` | Removes a jump from the jump list. | None |
+| `dropLastJump()` | Removes the last jump from the jump list. | None |
+| `clearJumps()` | Clears all jumps from the jump list. | None |
+
+## CaretRead
+
+The `CaretRead` interface provides read-only access to a caret in the editor. It includes methods for working with registers, marks, scrolling, and text navigation.
+
+### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `caretId` | `CaretId` | The unique identifier for this caret. |
+| `offset` | `Int` | The current offset (position) of the caret in the document. |
+| `selection` | `Range` | The current selection range of the caret. |
+| `line` | `Line` | Information about the current line where the caret is positioned. |
+| `lastSelectedReg` | `Char` | The last register that was selected for operations. Example: After using `"ay` to yank into register 'a', this would return 'a'. In VimScript, variable `v:register` contains this value. |
+| `defaultRegister` | `Char` | The default register used when no register is explicitly specified. In Vim, this is typically the unnamed register ("). |
+| `isRegisterSpecifiedExplicitly` | `Boolean` | Indicates whether the current register was explicitly specified by the user. Example: After `"ay`, this would be true; after just `y`, this would be false. |
+| `selectionMarks` | `Range?` | The marks for the current visual selection. In Vim, these are the '< and '> marks. |
+| `changeMarks` | `Range?` | The marks for the last change. In Vim, these are the '[ and '] marks. |
+| `localMarks` | `Set<Mark>` | All local marks for the current caret. |
+
+### Methods
+
+#### Register Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `selectRegister(register: Char): Boolean` | Selects a register for subsequent operations. Example: In Vim, pressing `"a` before an operation selects register 'a'. | True if the register was successfully selected, false otherwise. |
+| `resetRegisters()` | Resets all registers to their default state. | None |
+| `isWritable(register: Char): Boolean` | Checks if a register is writable. Some registers in Vim are read-only. | True if the register is writable, false otherwise. |
+| `isSystemClipboard(register: Char): Boolean` | Checks if a register is connected to the system clipboard. In Vim, registers '+' and '*' are connected to the system clipboard. | True if the register is connected to the system clipboard, false otherwise. |
+| `isPrimaryRegisterSupported(): Boolean` | Checks if the primary selection register is supported. Example: On Linux, using `"*y` yanks text to the primary selection. | True if the primary selection register is supported, false otherwise. |
+| `getReg(register: Char): String?` | Gets the text content of a register. | The text content of the register, or null if the register is empty or doesn't exist. |
+| `getRegType(register: Char): TextType?` | Gets the type of text stored in a register (character-wise, line-wise, or block-wise). | The type of text in the register, or null if the register is empty or doesn't exist. |
+| `setReg(register: Char, text: String, textType: TextType = TextType.CHARACTER_WISE): Boolean` | Sets the text content and type of a register. | True if the register was successfully set, false otherwise. |
+
+#### Mark Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `getMark(char: Char): Mark?` | Gets a mark by its character key for the current caret. | The mark, or null if the mark doesn't exist. |
+| `setMark(char: Char): Boolean` | Sets a mark at the current caret position. | True if the mark was successfully set, false otherwise. |
+| `setMark(char: Char, offset: Int): Boolean` | Sets a mark at the specified offset. | True if the mark was successfully set, false otherwise. |
+| `removeLocalMark(char: Char)` | Removes a local mark for the current caret. | None |
+| `resetAllMarksForCaret()` | Resets all marks for the current caret. | None |
+
+#### Scrolling Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `scrollFullPage(pages: Int): Boolean` | Scrolls a full page up or down. Positive values scroll down, negative values scroll up. | True if the scroll was successful, false otherwise. |
+| `scrollHalfPageUp(lines: Int): Boolean` | Scrolls half a page up. | True if the scroll was successful, false otherwise. |
+| `scrollHalfPageDown(lines: Int): Boolean` | Scrolls half a page down. | True if the scroll was successful, false otherwise. |
+| `selectWindowHorizontally(relativePosition: Int)` | Selects a window in the same row as the current window. Positive values select windows to the right, negative values select windows to the left. | None |
+| `selectWindowInVertically(relativePosition: Int)` | Selects a window in the same column as the current window. Positive values select the windows below, negative values select the windows above. | None |
+
+#### Text Navigation
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `getNextParagraphBoundOffset(count: Int = 1, includeWhitespaceLines: Boolean = true): Int?` | Finds the offset of the next paragraph boundary. | The offset of the next paragraph bound, or null if not found. |
+| `getNextSentenceStart(count: Int = 1, includeCurrent: Boolean, requireAll: Boolean = true): Int?` | Finds the next sentence start in the editor from the given offset. | The offset of the next sentence start, or null if not found. |
+| `getNextSectionStart(marker: Char, count: Int = 1): Int` | Find the next section in the editor. | The offset of the next section. |
+| `getPreviousSectionStart(marker: Char, count: Int = 1): Int` | Find the start of the previous section in the editor. | The offset of the previous section. |
+| `getNextSentenceEnd(count: Int = 1, includeCurrent: Boolean, requireAll: Boolean = true): Int?` | Finds the end offset of the next sentence from the current caret position. | The offset of the next sentence end, or null if not found. |
+| `getMethodEndOffset(count: Int = 1): Int` | Finds the end offset of the next method from the current caret position. | The offset of the end of the next method. |
+| `getMethodStartOffset(count: Int = 1): Int` | Finds the start offset of the next method from the current caret position. | The offset of the start of the next method. |
+| `getNextCharOnLineOffset(count: Int = 1, char: Char): Int` | Finds the next occurrence of a specific character on the current line. | The offset of the found character, or -1 if not found. |
+| `getNearestWordOffset(): Range?` | Finds the word at or nearest to the current caret position. | A Range representing the found word, or null if no word is found. |
+| `getWordTextObjectRange(count: Int = 1, isOuter: Boolean, isBigWord: Boolean): Range` | Find the range of the word text object at the location of the caret. | The range of the word text object. |
+| `getSentenceRange(count: Int = 1, isOuter: Boolean): Range` | Find the range of the sentence text object at the location of the caret. | The range of the sentence text object. |
+| `getParagraphRange(count: Int = 1, isOuter: Boolean): Range?` | Returns range of a paragraph containing the caret. | The paragraph text range, or null if not found. |
+| `getBlockTagRange(count: Int = 1, isOuter: Boolean): Range?` | Find the range of a block tag at the location of the caret. | The range of the block tag, or null if not found. |
+| `getBlockQuoteInLineRange(quote: Char, isOuter: Boolean): Range?` | Find a block quote in the current line at the location of the caret. | The range of the block quote, or null if not found. |
+| `getNextMisspelledWordOffset(count: Int = 1): Int` | Finds the offset of the next misspelled word from the current caret position. | The offset of the next misspelled word. |
+
+## CaretTransaction
+
+The `CaretTransaction` interface extends `CaretRead` and provides methods for modifying the caret and text in the editor. It includes operations for updating the caret position, inserting text, replacing text, and deleting text.
+
+### Methods
+
+#### Caret Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `updateCaret(offset: Int, selection: Range.Simple? = null)` | Updates the caret position and optionally sets a selection. If a selection is provided, the caret will have this selection after moving to the new offset. If no selection is provided, any existing selection will be removed. | None |
+
+#### Text Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `insertText(position: Int, text: String, caretAtEnd: Boolean = true, insertBeforeCaret: Boolean = false): Boolean` | Inserts text at the specified position in the document. | True if the insertion was successful, false otherwise. |
+| `replaceText(startOffset: Int, endOffset: Int, text: String): Boolean` | Replaces text between the specified offsets with new text. | True if the replacement was successful, false otherwise. |
+| `replaceTextBlockwise(range: Range.Block, text: List<String>)` | Replaces text in multiple ranges (blocks) with new text. | None |
+| `deleteText(startOffset: Int, endOffset: Int): Boolean` | Deletes text between the specified offsets. | True if the deletion was successful, false otherwise. |
+
+#### Jump Operations
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `addJump(reset: Boolean)` | Adds a jump with the current caret's position to the jump list. | None |
+| `saveJumpLocation()` | Saves the location of the current caret to the jump list and sets the ' mark. | None |
+
+## OptionScope
+
+The `OptionScope` interface provides comprehensive methods for managing Vim options. It supports different scopes for options (global, local, and effective) and allows for type-safe access to option values. The `option` function returns a value, making it easy to retrieve option values directly.
+
+### Core Methods
+
+| Method                                 | Description                                                                                                                                                                      | Return Value                                                                                           |
+|----------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------|
+| `get<T>(name: String): T`              | Gets the value of an option with the specified type. In Vim, options can be accessed with the `&` prefix. Example: `&ignorecase` returns the value of the 'ignorecase' option.   | The value of the option. Throws IllegalArgumentException if the option doesn't exist or type is wrong. |
+| `set<T>(name: String, value: T)`       | Sets the effective value of an option with the specified type. In Vim, this is equivalent to `:set option=value`. Example: `:set ignorecase` or `let &ignorecase = 1`            | None                                                                                                   |
+| `setGlobal<T>(name: String, value: T)` | Sets the global value of an option with the specified type. In Vim, this is equivalent to `:setglobal option=value`. Example: `:setglobal ignorecase` or `let &g:ignorecase = 1` | None                                                                                                   |
+| `setLocal<T>(name: String, value: T)`  | Sets the local value of an option with the specified type. In Vim, this is equivalent to `:setlocal option=value`. Example: `:setlocal ignorecase` or `let &l:ignorecase = 1`    | None                                                                                                   |
+| `reset(name: String)`                  | Resets an option to its default value. In Vim, this is equivalent to `:set option&`. Example: `:set ignorecase&` resets the 'ignorecase' option to its default value.            | None                                                                                                   |
+
+### List Option Methods
+
+These extension functions provide convenient ways to manipulate comma-separated list options (like `virtualedit`, `whichwrap`, etc.):
+
+| Method                                         | Description                                                 | Vim Equivalent       |
+|------------------------------------------------|-------------------------------------------------------------|----------------------|
+| `append(name: String, vararg values: String)`  | Appends values to a list option. Duplicates are not added.  | `:set option+=value` |
+| `prepend(name: String, vararg values: String)` | Prepends values to a list option. Duplicates are not added. | `:set option^=value` |
+| `remove(name: String, vararg values: String)`  | Removes values from a list option.                          | `:set option-=value` |
+
+### Utility Methods
+
+| Method                         | Description                                                             | Return Value    |
+|--------------------------------|-------------------------------------------------------------------------|-----------------|
+| `toggle(name: String)`         | Toggles a boolean option value.                                         | None            |
+| `String.split(): List<String>` | Extension function to split a comma-separated option value into a list. | List of strings |
+
+### Usage Examples
+
+```kotlin
+// Getting option values
+val history = myVimApi.option { get<Int>("history") }
+val ignoreCase = myVimApi.option { get<Boolean>("ignorecase") }
+
+// Setting options
+myVimApi.option {
+    set("number", true)          // Line numbers
+    setGlobal("history", 100)    // Command history
+    setLocal("tabstop", 4)       // Tab width for current buffer
+}
+
+// Working with list options
+myVimApi.option {
+    // Add values to a list option
+    append("virtualedit", "block", "onemore")
+    
+    // Remove values from a list option
+    remove("virtualedit", "block")
+    
+    // Prepend values to a list option
+    prepend("whichwrap", "b", "s")
+}
+
+// Toggle boolean options
+myVimApi.option {
+    toggle("ignorecase")  // true → false or false → true
+}
+
+// Reset to default value
+myVimApi.option {
+    reset("tabstop")  // Reset to default value
+}
+
+// Process list options
+myVimApi.option {
+    val virtualEditModes = get<String>("virtualedit").split()
+    // "block,all" → ["block", "all"]
+}
+
+// Complex operations with return value
+val isIgnoreCaseEnabled = myVimApi.option {
+    val current = get<Boolean>("ignorecase")
+    if (!current) {
+        set("ignorecase", true)
+        set("smartcase", true)
+    }
+    current
+}
+```
+
+## OutputPanelScope
+
+The `OutputPanelScope` interface provides methods for interacting with the Vim output panel. The output panel is used to display text output from Vim commands and operations.
+
+### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `text` | `String` | The text displayed in the output panel. |
+| `label` | `String` | The label text displayed at the bottom of the output panel. This is used for status information like "-- MORE --" to indicate that there is more content to scroll through. |
+
+### Methods
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `setText(text: String)` | Sets the text content of the output panel. This replaces any existing text in the panel with the provided text. | None |
+| `appendText(text: String, startNewLine: Boolean = false)` | Appends text to the existing content of the output panel. If startNewLine is true and there is existing text, a newline character will be inserted before the appended text. | None |
+| `setLabel(label: String)` | Sets the label text at the bottom of the output panel. | None |
+| `clearText()` | Clears all text from the output panel. | None |
+
+## ModalInput
+
+The `ModalInput` interface provides methods for creating and managing modal input dialogs, which can be used to get user input in a Vim-like way.
+
+### Methods
+
+| Method                                                         | Description | Return Value |
+|----------------------------------------------------------------|-------------|--------------|
+| `updateLabel(block: (String) -> String): ModalInput`           | Updates the label of the modal input dialog using the provided function. | The ModalInput instance for method chaining. |
+| `repeatWhile(condition: () -> Boolean): ModalInput`            | Repeats the modal input dialog while the provided condition is true. | The ModalInput instance for method chaining. |
+| `repeat(count: Int): ModalInput`                               | Repeats the modal input dialog the specified number of times. | The ModalInput instance for method chaining. |
+| `inputString(label: String, handler: VimApi.(String) -> Unit)` | Creates a modal input dialog with the given label and handler. The handler will be executed after the user presses ENTER. | None |
+| `inputChar(label: String, handler: VimApi.(Char) -> Unit)`     | Creates a modal input dialog with the given label and handler. The handler will be executed after the user enters a character. | None |
+| `closeCurrentInput(refocusEditor: Boolean = true): Boolean`    | Closes the current modal input dialog, if any. If refocusEditor is true, the editor will be refocused after closing the dialog. | True if a dialog was closed, false otherwise. |
+
+## ListenerScope
+
+The `ListenerScope` interface provides methods for registering callbacks for various events in the Vim editor, such as mode changes, yanking text, editor lifecycle events, and more.
+
+### Methods
+
+#### Mode and Action Listeners
+
+| Method                                                                  | Description | Return Value |
+|-------------------------------------------------------------------------|-------------|--------------|
+| `onModeChange(callback: suspend VimApi.(Mode) -> Unit)`                 | Registers a callback that is invoked when the editor mode changes (e.g., from Normal to Insert). | None |
+| `onYank(callback: suspend VimApi.(Map<CaretId, Range.Simple>) -> Unit)` | Registers a callback that is invoked when text is yanked. The callback receives a map of caret IDs to yanked text ranges. | None |
+
+#### Editor Lifecycle Listeners
+
+| Method                                                   | Description | Return Value |
+|----------------------------------------------------------|-------------|--------------|
+| `onEditorCreate(callback: suspend VimApi.() -> Unit)`    | Registers a callback that is invoked when a new editor is created. | None |
+| `onEditorRelease(callback: suspend VimApi.() -> Unit)`   | Registers a callback that is invoked when an editor is released (closed). | None |
+| `onEditorFocusGain(callback: suspend VimApi.() -> Unit)` | Registers a callback that is invoked when an editor gains focus. | None |
+| `onEditorFocusLost(callback: suspend VimApi.() -> Unit)` | Registers a callback that is invoked when an editor loses focus. | None |
+
+#### Macro Recording Listeners
+
+| Method                                                        | Description | Return Value |
+|---------------------------------------------------------------|-------------|--------------|
+| `onMacroRecordingStart(callback: suspend VimApi.() -> Unit)`  | Registers a callback that is invoked when macro recording starts. | None |
+| `onMacroRecordingFinish(callback: suspend VimApi.() -> Unit)` | Registers a callback that is invoked when macro recording finishes. | None |
+
+#### Plugin State Listeners
+
+| Method                                                   | Description | Return Value |
+|----------------------------------------------------------|-------------|--------------|
+| `onIdeaVimEnabled(callback: suspend VimApi.() -> Unit)`  | Registers a callback that is invoked when IdeaVim is enabled. | None |
+| `onIdeaVimDisabled(callback: suspend VimApi.() -> Unit)` | Registers a callback that is invoked when IdeaVim is disabled. | None |
+
+## DigraphScope
+
+The `DigraphScope` interface provides access to Vim's digraph functionality. Digraphs are special character combinations that produce a single character, often used for entering non-ASCII characters.
+
+### Methods
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `getCharacter(ch1: Char, ch2: Char): Int` | Gets the character for a digraph. | The Unicode codepoint of the character represented by the digraph, or the codepoint of ch2 if no digraph is found. |
+| `addDigraph(ch1: Char, ch2: Char, codepoint: Int)` | Adds a custom digraph. | None |
+| `clearCustomDigraphs()` | Clears all custom digraphs. | None |
+
+## CommandLineScope
+
+The `CommandLineScope` class provides methods for interacting with the Vim command line. The command line is used for entering Ex commands, search patterns, and other input.
+
+### Methods
+
+| Method                                                                             | Description | Return Value |
+|------------------------------------------------------------------------------------|-------------|--------------|
+| `input(prompt: String, finishOn: Char? = null, callback: VimApi.(String) -> Unit)` | Reads input from the command line and processes it with the provided function. | None |
+| `read<T>(block: suspend CommandLineRead.() -> T): Deferred<T>`                     | Executes a block of code in the context of read operations on the command line. This allows for reading the command line state without modifying it. | A Deferred result of the block execution. |
+| `change(block: suspend CommandLineTransaction.() -> Unit): Job`                    | Executes a block of code in the context of transaction operations on the command line. This allows for modifying the command line state. | A Job representing the asynchronous operation. |
+
+## CommandLineRead
+
+The `CommandLineRead` interface provides read-only access to the command line state. It includes properties for accessing the current text, caret position, and active state of the command line.
+
+### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `text` | `String` | The text currently displayed in the command line. |
+| `caretPosition` | `Int` | The current position of the caret in the command line. |
+| `isActive` | `Boolean` | True if the command line is currently active, false otherwise. |
+
+## CommandLineTransaction
+
+The `CommandLineTransaction` interface provides methods for modifying the command line state. It includes operations for setting text, inserting text, setting the caret position, and closing the command line.
+
+### Methods
+
+| Method | Description | Return Value |
+|--------|-------------|--------------|
+| `setText(text: String)` | Sets the text content of the command line. This replaces any existing text in the command line with the provided text. | None |
+| `insertText(offset: Int, text: String)` | Inserts text at the specified position in the command line. | None |
+| `setCaretPosition(position: Int)` | Sets the caret position in the command line. | None |
+| `close(refocusEditor: Boolean = true): Boolean` | Closes the command line. If refocusEditor is true, the editor will be refocused after closing the command line. | True if the command line was closed, false if it was not active. |

doc/Plugin-API-tutorial-replace-with-register.md

@@ -0,0 +1,275 @@
+# Tutorial: Creating an IdeaVim Plugin with the New API
+
+> **⚠️ EXPERIMENTAL API WARNING**
+> 
+> The Plugin API is currently in an **experimental stage** and is not yet recommended for production use.
+> 
+> - The API is subject to breaking changes without notice
+> - Features may be added, modified, or removed in future releases
+> - Documentation may not fully reflect the current implementation
+> - Use at your own risk for experimental purposes only
+> 
+> We welcome feedback and bug reports to help improve the API, but please be aware that stability is not guaranteed at this time.
+
+This tutorial will guide you through the process of creating a plugin for IdeaVim using the new API. We'll implement a "Replace with Register" plugin that allows you to replace text with the contents of a register.
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Prerequisites](#prerequisites)
+- [Project Setup](#project-setup)
+- [Plugin Structure](#plugin-structure)
+- [Implementing the Plugin](#implementing-the-plugin)
+  - [Step 1: Create the init function](#step-1-create-the-init-function)
+  - [Step 2: Define Mappings](#step-2-define-mappings)
+  - [Step 3: Implement Core Functionality](#step-3-implement-core-functionality)
+  - [Step 4: Handle Different Selection Types](#step-4-handle-different-selection-types)
+- [Testing Your Plugin](#testing-your-plugin)
+
+## Introduction
+
+The "Replace with Register" plugin ([link](https://github.com/vim-scripts/ReplaceWithRegister) to the original Vim plugin) demonstrates several important concepts in IdeaVim plugin development:
+
+- Creating custom mappings for different Vim modes
+- Working with registers
+- Manipulating text in the editor
+- Handling different types of selections (character-wise, line-wise, block-wise)
+- Creating operator functions
+
+This tutorial will walk you through each part of the implementation, explaining the concepts and techniques used.
+
+## Project Setup
+
+1. Clone the IdeaVim repo. (Todo: update)
+
+## Plugin Structure
+
+IdeaVim plugins using the new API are typically structured as follows:
+
+1. An `init` function that sets up mappings and functionality
+2. Helper functions that implement specific features
+
+Let's look at how to implement each part of our "Replace with Register" plugin.
+
+## Implementing the Plugin
+
+### Step 1: Create the init function
+
+First, create a Kotlin file for your plugin:
+
+```kotlin
+@VimPlugin(name = "ReplaceWithRegister")
+fun VimApi.init() {
+  // We'll add mappings and functionality here
+}
+```
+
+The `init` function has a responsibility to set up our plugin within the `VimApi`.
+
+### Step 2: Define Mappings
+
+Now, let's add mappings to our plugin. We'll define three mappings:
+
+1. `gr` + motion: Replace the text covered by a motion with register contents
+2. `grr`: Replace the current line with register contents
+3. `gr` in visual mode: Replace the selected text with register contents
+
+Add this code to the `init` function:
+
+```kotlin
+@VimPlugin(name = "ReplaceWithRegister", shortPath = "username/ReplaceWithRegister")
+fun VimApi.init() {
+    mappings {
+        nmap(keys = "gr", label = "ReplaceWithRegisterOperator", isRepeatable = true) {
+            rewriteMotion()
+        }
+        nmap(keys = "grr", label = "ReplaceWithRegisterLine", isRepeatable = true) {
+            rewriteLine()
+        }
+        vmap(keys = "gr", label = "ReplaceWithRegisterVisual", isRepeatable = true) {
+            rewriteVisual()
+        }
+    }
+
+    exportOperatorFunction("ReplaceWithRegisterOperatorFunc") {
+        operatorFunction()
+    }
+}
+```
+
+Let's break down what's happening:
+
+- The `mappings` block gives us access to the `MappingScope`
+- `nmap` defines a normal mode mapping, `vmap` defines a visual mode mapping
+- Each mapping has:
+  - `keys`: The key sequence to trigger the mapping
+  - `label`: A unique identifier for the mapping
+  - `isRepeatable`: Whether the mapping can be repeated with the `.` command
+- The lambda for each mapping calls a function that we'll implement next
+- `exportOperatorFunction` registers a function that will be called when the operator is used with a motion
+
+### Step 3: Implement Core Functionality
+
+Now, let's implement the functions we referenced in our mappings:
+
+```kotlin
+private fun VimApi.rewriteMotion() {
+    setOperatorFunction("ReplaceWithRegisterOperatorFunc")
+    normal("g@")
+}
+
+private suspend fun VimApi.rewriteLine() {
+    val count1 = getVariable<Int>("v:count1") ?: 1
+    val job: Job
+    editor {
+        job = change {
+            forEachCaret {
+              val endOffset = getLineEndOffset(line.number + count1 - 1, true)
+              val lineStartOffset = line.start
+              val registerData = prepareRegisterData() ?: return@forEachCaret
+              replaceText(lineStartOffset, endOffset, registerData.first)
+              updateCaret(offset = lineStartOffset)
+            }
+        }
+    }
+    job.join()
+}
+
+private suspend fun VimApi.rewriteVisual() {
+    val job: Job
+    editor {
+        job = change {
+            forEachCaret {
+                val selectionRange = selection
+                val registerData = prepareRegisterData() ?: return@forEachCaret
+                replaceTextAndUpdateCaret(this@rewriteVisual, selectionRange, registerData)
+            }
+        }
+    }
+    job.join()
+    mode = Mode.NORMAL()
+}
+
+private suspend fun VimApi.operatorFunction(): Boolean {
+    fun CaretTransaction.getSelection(): Range? {
+        return when (this@operatorFunction.mode) {
+            is Mode.NORMAL -> changeMarks
+            is Mode.VISUAL -> selection
+            else -> null
+        }
+    }
+
+    val job: Job
+    editor {
+        job = change {
+            forEachCaret {
+                val selectionRange = getSelection() ?: return@forEachCaret
+                val registerData = prepareRegisterData() ?: return@forEachCaret
+                replaceTextAndUpdateCaret(this@operatorFunction, selectionRange, registerData)
+            }
+        }
+    }
+    job.join()
+    return true
+}
+```
+
+Let's examine each function:
+
+- `rewriteMotion()`: Sets up an operator function and triggers it with `g@`
+- `rewriteLine()`: Replaces one or more lines with register contents
+- `rewriteVisual()`: Replaces the visual selection with register contents
+- `operatorFunction()`: Implements the operator function
+
+Notice the use of scopes:
+- `editor { }` gives us access to the editor
+- `change { }` creates a transaction for modifying text
+- `forEachCaret { }` iterates over all carets (useful for multi-cursor editing)
+
+### Step 4: Handle Different Selection Types
+
+Now, let's implement the helper functions that prepare register data and handle different types of selections:
+
+```kotlin
+private suspend fun CaretTransaction.prepareRegisterData(): Pair<String, TextType>? {
+    val lastRegisterName: Char = lastSelectedReg
+    var registerText: String = getReg(lastRegisterName) ?: return null
+    var registerType: TextType = getRegType(lastRegisterName) ?: return null
+
+    if (registerType.isLine && registerText.endsWith("\n")) {
+        registerText = registerText.removeSuffix("\n")
+        registerType = TextType.CHARACTER_WISE
+    }
+
+    return registerText to registerType
+}
+
+private suspend fun CaretTransaction.replaceTextAndUpdateCaret(
+    vimApi: VimApi,
+    selectionRange: Range,
+    registerData: Pair<String, TextType>,
+) {
+    val (text, registerType) = registerData
+
+    if (registerType == TextType.BLOCK_WISE) {
+        val lines = text.lines()
+
+        if (selectionRange is Range.Simple) {
+            val startOffset = selectionRange.start
+            val endOffset = selectionRange.end
+            val startLine = getLine(startOffset)
+            val diff = startOffset - startLine.start
+
+            lines.forEachIndexed { index, lineText ->
+                val offset = getLineStartOffset(startLine.number + index) + diff
+                if (index == 0) {
+                    replaceText(offset, endOffset, lineText)
+                } else {
+                    insertText(offset, lineText)
+                }
+            }
+
+            updateCaret(offset = startOffset)
+        } else if (selectionRange is Range.Block) {
+            val selections: Array<Range.Simple> = selectionRange.ranges
+
+            selections.zip(lines).forEach { (range, lineText) ->
+                replaceText(range.start, range.end, lineText)
+            }
+        }
+    } else {
+        if (selectionRange is Range.Simple) {
+            val textLength = this.text.length
+            if (textLength == 0) {
+              insertText(0, text)
+            } else {
+              replaceText(selectionRange.start, selectionRange.end, text)
+            }
+        } else if (selectionRange is Range.Block) {
+            val selections: Array<Range.Simple> = selectionRange.ranges.sortedByDescending { it.start }.toTypedArray()
+            val lines = List(selections.size) { text }
+
+            replaceTextBlockwise(selectionRange, lines)
+
+            vimApi.mode = Mode.NORMAL()
+            updateCaret(offset = selections.last().start)
+        }
+    }
+}
+```
+
+These functions handle:
+
+1. `prepareRegisterData()`: Gets the content and type of the last used register
+2. `replaceTextAndUpdateCaret()`: Handles the replacement logic for different types of selections and register contents
+
+## Testing Your Plugin
+
+For the "Replace with Register" plugin, you can test it by:
+
+1. Yanking some text with `y`
+2. Moving to different text and using `gr` followed by a motion
+3. Selecting text in visual mode and using `gr`
+4. Using `grr` to replace a whole line
+
+For more information, check out the [API Reference](Plugin-API-reference.md) and the [Quick Start Guide](Plugin-API-quick-start-guide.md).

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
+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=chylex-44
+version=chylex-52
 javaVersion=21
 remoteRobotVersion=0.11.23
 antlrVersion=4.10.1
@@ -28,7 +28,7 @@ antlrVersion=4.10.1
 
 # Please don't forget to update kotlin version in buildscript section
 # Also update kotlinxSerializationVersion version
-kotlinVersion=2.0.21
+kotlinVersion=2.2.0
 publishToken=token
 publishChannels=eap
 

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
-' "$PWD" ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum

scripts/build.gradle.kts

@@ -20,27 +20,25 @@ repositories {
 }
 
 dependencies {
-  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:2.1.10")
+  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:2.2.20")
 
-  implementation("io.ktor:ktor-client-core:3.1.1")
-  implementation("io.ktor:ktor-client-cio:3.1.1")
-  implementation("io.ktor:ktor-client-content-negotiation:3.1.1")
-  implementation("io.ktor:ktor-serialization-kotlinx-json:3.1.1")
-  implementation("io.ktor:ktor-client-auth:3.1.1")
+  implementation("io.ktor:ktor-client-core:3.3.0")
+  implementation("io.ktor:ktor-client-cio:3.3.0")
+  implementation("io.ktor:ktor-client-content-negotiation:3.3.0")
+  implementation("io.ktor:ktor-serialization-kotlinx-json:3.3.0")
+  implementation("io.ktor:ktor-client-auth:3.3.0")
   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.3.0.202506031305-r")
   implementation("com.vdurmont:semver4j:3.1.0")
 }
 
 val releaseType: String? by project
 
-tasks {
-  compileKotlin {
-    kotlinOptions {
-      freeCompilerArgs = listOf("-Xjvm-default=all-compatibility")
-    }
+kotlin {
+  compilerOptions {
+    freeCompilerArgs = listOf("-Xjvm-default=all-compatibility")
   }
 }
 

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

@@ -43,6 +43,14 @@ 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
+
+  "cn.mumukehao.plugin",
+
+  "com.magidc.ideavim.anyObject",
+  "dev.ghostflyby.ideavim.toggleIME",
+  "com.magidc.ideavim.dial",
 )
 
 suspend fun main() {

settings.gradle.kts

@@ -19,4 +19,5 @@ include("tests:long-running-tests")
 include("tests:ui-ij-tests")
 include("tests:ui-py-tests")
 include("tests:ui-fixtures")
+include("api")
 include("tests:ui-rd-tests")

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

@@ -37,6 +37,7 @@ import com.maddyhome.idea.vim.helper.MacKeyRepeat;
 import com.maddyhome.idea.vim.listener.VimListenerManager;
 import com.maddyhome.idea.vim.newapi.IjVimInjectorKt;
 import com.maddyhome.idea.vim.newapi.IjVimSearchGroup;
+import com.maddyhome.idea.vim.thinapi.IjPluginExtensionsScanner;
 import com.maddyhome.idea.vim.ui.StatusBarIconFactory;
 import com.maddyhome.idea.vim.vimscript.services.VariableService;
 import com.maddyhome.idea.vim.yank.YankGroupBase;
@@ -330,6 +331,12 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
     // 2.2) Register extensions
     VimExtensionRegistrar.registerExtensions();
 
+    // 2.2.1) Register extensions with new API
+    //VimInjectorKt.getInjector().getJsonExtensionProvider().init();
+    //VimInjectorKt.getInjector()
+    //  .getJsonExtensionProvider()
+    //  .addExtensions(IjPluginExtensionsScanner.Companion.instance().scanAllPlugins());
+
     // 2.3) Register functions
     VimInjectorKt.getInjector().getFunctionService().registerHandlers();
 
@@ -355,7 +362,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 +383,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 = keyRepeat.isEnabled();
+        final Boolean enabled = MacKeyRepeat.INSTANCE.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 +393,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/VimProjectService.kt

@@ -18,7 +18,7 @@ import com.maddyhome.idea.vim.ui.ex.ExEntryPanel
 internal class VimProjectService(val project: Project) : Disposable {
   override fun dispose() {
     // Not sure if this is a best solution
-    ExEntryPanel.getInstance().setEditor(null)
+    ExEntryPanel.instance?.setEditor(null)
   }
 
   companion object {

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

@@ -1,52 +0,0 @@
-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

@@ -35,11 +35,9 @@ import com.maddyhome.idea.vim.handler.enableOctopus
 import com.maddyhome.idea.vim.handler.isOctopusEnabled
 import com.maddyhome.idea.vim.helper.EditorHelper
 import com.maddyhome.idea.vim.helper.HandlerInjector
-import com.maddyhome.idea.vim.helper.inInsertMode
 import com.maddyhome.idea.vim.helper.inNormalMode
 import com.maddyhome.idea.vim.helper.isIdeaVimDisabledHere
 import com.maddyhome.idea.vim.helper.isPrimaryEditor
-import com.maddyhome.idea.vim.helper.isTemplateActive
 import com.maddyhome.idea.vim.helper.updateCaretsVisualAttributes
 import com.maddyhome.idea.vim.key.ShortcutOwner
 import com.maddyhome.idea.vim.key.ShortcutOwnerInfo
@@ -59,11 +57,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 +87,10 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
           val duration = System.currentTimeMillis() - start
           LOG.info("VimShortcut execution '$keyStroke': $duration ms")
         }
-      } catch (_: ProcessCanceledException) {
-        // Control-flow exceptions (like ProcessCanceledException) should never be logged
+      } catch (e: ProcessCanceledException) {
+        // 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)
       }
@@ -177,33 +173,6 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
       }
     }
 
-    if (keyCode == KeyEvent.VK_TAB && editor.isTemplateActive()) {
-      return ActionEnableStatus.no("The key is tab and the template is active", LogLevel.INFO)
-    }
-
-    if (editor.inInsertMode) {
-      if (keyCode == KeyEvent.VK_TAB) {
-        // TODO: This stops VimEditorTab seeing <Tab> in insert mode and correctly scrolling the view
-        // There are multiple actions registered for VK_TAB. The important items, in order, are this, the Live
-        // Templates action and TabAction. Returning false in insert mode means that the Live Template action gets to
-        // execute, and this allows Emmet to work (VIM-674). But it also means that the VimEditorTab handle is never
-        // called, so we can't scroll the caret into view correctly.
-        // If we do return true, VimEditorTab handles the Vim side of things and then invokes
-        // IdeActions.ACTION_EDITOR_TAB, which inserts the tab. It also bypasses the Live Template action, and Emmet
-        // no longer works.
-        // This flag is used when recording text entry/keystrokes for repeated insertion. Because we return false and
-        // don't execute the VimEditorTab handler, we don't record tab as an action. Instead, we see an incoming text
-        // change of multiple whitespace characters, which is normally ignored because it's auto-indent content from
-        // hitting <Enter>. When this flag is set, we record the whitespace as the output of the <Tab>
-        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) {
       return ActionEnableStatus.yes("Vim only editor keys", LogLevel.INFO)
     }
@@ -271,7 +240,7 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
   private fun getEditor(e: AnActionEvent): Editor? {
     return e.getData(PlatformDataKeys.EDITOR)
       ?: if (e.getData(PlatformDataKeys.CONTEXT_COMPONENT) is ExTextField) {
-        ExEntryPanel.getInstance().ijEditor
+        ExEntryPanel.getOrCreatePanelInstance().ijEditor
       } else {
         null
       }
@@ -292,7 +261,7 @@ class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
       return keyStroke !in parsedLookupKeys
     }
 
-    private fun parseLookupKeys(value: VimString) = IjOptions.lookupkeys.split(value.asString())
+    private fun parseLookupKeys(keys: VimString) = IjOptions.lookupkeys.split(keys.value)
       .map { injector.parser.parseKeys(it) }
       .filter { it.isNotEmpty() }
       .map { it.first() }
@@ -349,14 +318,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/action/change/OperatorAction.kt

@@ -10,7 +10,6 @@ package com.maddyhome.idea.vim.action.change
 import com.intellij.vim.annotations.CommandOrMotion
 import com.intellij.vim.annotations.Mode
 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.VimEditor
@@ -27,7 +26,6 @@ import com.maddyhome.idea.vim.group.MotionGroup
 import com.maddyhome.idea.vim.group.visual.VimSelection
 import com.maddyhome.idea.vim.handler.VimActionHandler
 import com.maddyhome.idea.vim.handler.VisualOperatorActionHandler
-import com.maddyhome.idea.vim.helper.MessageHelper
 import com.maddyhome.idea.vim.helper.inRepeatMode
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.state.mode.SelectionType
@@ -45,7 +43,7 @@ private fun doOperatorAction(
 ): Boolean {
   val func = injector.globalOptions().operatorfunc
   if (func.isEmpty()) {
-    VimPlugin.showMessage(MessageHelper.message("E774"))
+    injector.messages.showStatusBarMessage(editor, injector.messages.message("E774"))
     return false
   }
 
@@ -63,21 +61,21 @@ private fun doOperatorAction(
           handler = value.handler
         }
       } catch (_: ExException) {
-        // Get the argument for function('...') or funcref('...') for the error message
+        // Get the argument for function(...) or funcref(...) for the error message
         val functionName = if (expression is FunctionCallExpression && expression.arguments.isNotEmpty()) {
-          expression.arguments[0].evaluate(editor, context, scriptContext).toString()
+          expression.arguments[0].evaluate(editor, context, scriptContext).toOutputString()
         } else {
           func
         }
 
-        VimPlugin.showMessage("E117: Unknown function: $functionName")
+        injector.messages.showStatusBarMessage(editor, injector.messages.message("E117", functionName))
         return false
       }
     }
   }
 
   if (handler == null) {
-    VimPlugin.showMessage("E117: Unknown function: $func")
+    injector.messages.showStatusBarMessage(editor, injector.messages.message("E117", func))
     return false
   }
 

src/main/java/com/maddyhome/idea/vim/action/editor/VimEditorActions.kt

@@ -9,8 +9,10 @@
 package com.maddyhome.idea.vim.action.editor
 
 import com.intellij.openapi.actionSystem.IdeActions
+import com.intellij.openapi.editor.actions.TabAction
 import com.intellij.vim.annotations.CommandOrMotion
 import com.intellij.vim.annotations.Mode
+import com.maddyhome.idea.vim.action.VimShortcutKeyAction
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.injector
@@ -20,6 +22,7 @@ import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.handler.IdeActionHandler
 import com.maddyhome.idea.vim.handler.VimActionHandler
 import com.maddyhome.idea.vim.helper.enumSetOf
+import com.maddyhome.idea.vim.key.VimActionsPromoter
 import com.maddyhome.idea.vim.undo.VimKeyBasedUndoService
 import com.maddyhome.idea.vim.undo.VimTimestampBasedUndoService
 import java.util.*
@@ -52,6 +55,27 @@ internal class VimEditorDown : IdeActionHandler(IdeActions.ACTION_EDITOR_MOVE_CA
   }
 }
 
+/**
+ * Invoke the IDE's "EditorTab" action
+ *
+ * Insert mode handler for `<Tab>` and `<C-I>`. This will invoke the IDE's "EditorTab" action, which will insert the
+ * tab or the appropriate number of spaces.
+ *
+ * Note that `Tab` has special handling in [VimActionsPromoter]. Typically, the promoter makes sure that
+ * [VimShortcutKeyAction] is the first action to be evaluated and potentially invoked. However, when the list of
+ * possible actions for the shortcut includes [TabAction], the promoter will actually demote [VimShortcutKeyAction] so
+ * that it is invoked almost last, second only to [TabAction]. This means the user has the chance to invoke context
+ * specific IDE `Tab` actions without the Vim commands interfering, e.g., accepting LLM output, Next Edit Suggestions,
+ * expanding Live Templates, etc.
+ *
+ * In Normal mode, the Vim handler for `Tab` will not insert a tab but move around the jump list. In Insert mode (below)
+ * it invokes "EditorTab" and inserts the text. In both cases, [VimShortcutKeyAction] handles the shortcut and the
+ * default [TabAction] is not involved. The benefit of this is that we can now map `<Tab>` in both Normal and Insert
+ * modes.
+ *
+ * Also, by inserting `Tab` with our action, we will correctly update the scroll position to keep the caret visible,
+ * applying `'scrolloff'` and `'sidescrolloff'`.
+ */
 @CommandOrMotion(keys = ["<Tab>", "<C-I>"], modes = [Mode.INSERT])
 internal class VimEditorTab : IdeActionHandler(IdeActions.ACTION_EDITOR_TAB) {
   override val type: Command.Type = Command.Type.INSERT

src/main/java/com/maddyhome/idea/vim/action/macro/PlaybackRegisterInOpenFilesAction.kt

@@ -0,0 +1,67 @@
+package com.maddyhome.idea.vim.action.macro
+
+import com.intellij.openapi.command.CommandProcessor
+import com.intellij.openapi.command.UndoConfirmationPolicy
+import com.intellij.openapi.command.impl.FinishMarkAction
+import com.intellij.openapi.command.impl.StartMarkAction
+import com.intellij.openapi.fileEditor.TextEditor
+import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
+import com.intellij.vim.annotations.CommandOrMotion
+import com.intellij.vim.annotations.Mode
+import com.maddyhome.idea.vim.KeyHandler
+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.command.Argument
+import com.maddyhome.idea.vim.command.Command
+import com.maddyhome.idea.vim.command.OperatorArguments
+import com.maddyhome.idea.vim.handler.VimActionHandler
+import com.maddyhome.idea.vim.newapi.ij
+import com.maddyhome.idea.vim.newapi.vim
+
+@CommandOrMotion(keys = ["z@"], modes = [Mode.NORMAL])
+class PlaybackRegisterInOpenFilesAction : VimActionHandler.SingleExecution() {
+  override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
+
+  override val argumentType: Argument.Type = Argument.Type.CHARACTER
+
+  private val playbackRegisterAction = PlaybackRegisterAction()
+  
+  override fun execute(
+    editor: VimEditor,
+    context: ExecutionContext,
+    cmd: Command,
+    operatorArguments: OperatorArguments,
+  ): Boolean {
+    val argument = cmd.argument as? Argument.Character ?: return false
+
+    val project = editor.ij.project ?: return false
+    val fileEditorManager = FileEditorManagerEx.getInstanceExIfCreated(project) ?: return false
+
+    val register = argument.character.let { if (it == '@') injector.macro.lastRegister else it }
+    val commandName = "Execute Macro '$register' in All Open Files"
+
+    val action = Runnable {
+      CommandProcessor.getInstance().markCurrentCommandAsGlobal(project)
+      
+      for (textEditor in fileEditorManager.allEditors.filterIsInstance<TextEditor>()) {
+        fileEditorManager.openFile(textEditor.file, true)
+
+        val editor = textEditor.editor
+        val vimEditor = editor.vim
+
+        vimEditor.mode = com.maddyhome.idea.vim.state.mode.Mode.NORMAL()
+        KeyHandler.Companion.getInstance().reset(vimEditor)
+
+        val startMarkAction = StartMarkAction.start(editor, project, commandName)
+        playbackRegisterAction.execute(vimEditor, context, cmd, operatorArguments)
+        FinishMarkAction.finish(project, editor, startMarkAction)
+      }
+    }
+
+    CommandProcessor.getInstance()
+      .executeCommand(project, action, commandName, null, UndoConfirmationPolicy.REQUEST_CONFIRMATION)
+
+    return true
+  }
+}

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/ex/ExOutputModel.kt

@@ -67,6 +67,14 @@ class ExOutputModel(private val myEditor: WeakReference<Editor>) : VimOutputPane
     panel.scrollLine()
   }
 
+  override fun setContent(text: String) {
+    this.text = text
+  }
+
+  override fun clearText() {
+    text = ""
+  }
+
   override var text: String = ""
     get() = if (!ApplicationManager.getApplication().isUnitTestMode) {
       editor?.let { ExOutputPanel.getInstance(it).text } ?: ""
@@ -79,7 +87,7 @@ class ExOutputModel(private val myEditor: WeakReference<Editor>) : VimOutputPane
       // never pass null to ExOutputPanel, but we do store it for tests, so we know if we're active or not
       val newValue = value.removeSuffix("\n")
       if (!ApplicationManager.getApplication().isUnitTestMode) {
-        editor?.let { ExOutputPanel.getInstance(it).setText(newValue) }
+        editor?.let { ExOutputPanel.getInstance(it).text = newValue }
       } else {
         field = newValue
         isActiveInTestMode = newValue.isNotEmpty()
@@ -109,7 +117,7 @@ class ExOutputModel(private val myEditor: WeakReference<Editor>) : VimOutputPane
     get() {
       val notNullEditor = editor ?: return false
       val panel = ExOutputPanel.getNullablePanel(notNullEditor) ?: return false
-      return panel.isAtEnd()
+      return panel.isAtEnd
     }
 
   override fun onBadKey() {

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

@@ -0,0 +1,118 @@
+/*
+ * 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.extension
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.CustomShortcutSet
+import com.intellij.openapi.actionSystem.KeyboardShortcut
+import com.intellij.openapi.actionSystem.ShortcutSet
+import com.intellij.openapi.project.DumbAwareAction
+import com.intellij.ui.KeyStrokeAdapter
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.key.KeyStrokeTrie
+import java.awt.event.KeyEvent
+import javax.swing.JComponent
+import javax.swing.KeyStroke
+
+internal open class ShortcutDispatcher<T>(
+  name: String,
+  data: Map<List<KeyStroke>, T>,
+  private val listener: Listener<T>,
+) : DumbAwareAction() {
+  interface Listener<T> {
+    fun onMatch(e: AnActionEvent, keyStrokes: MutableList<KeyStroke>, data: T) {}
+    fun onInvalid(e: AnActionEvent, keyStrokes: MutableList<KeyStroke>) {}
+    fun onKey(e: AnActionEvent, keyStrokes: MutableList<KeyStroke>, entries: Sequence<KeyStrokeTrie.TrieNode<T>>) {}
+  }
+
+  constructor(
+    name: String,
+    data: Map<String, T>,
+    onMatch: (T) -> Unit,
+    onInvalid: () -> Unit,
+    onKey: (Sequence<KeyStrokeTrie.TrieNode<T>>) -> Unit,
+  ) : this(name, data.mapKeys { injector.parser.parseKeys(it.key) }.toMap(), object : Listener<T> {
+    override fun onMatch(e: AnActionEvent, keyStrokes: MutableList<KeyStroke>, data: T) = onMatch(data)
+    override fun onInvalid(e: AnActionEvent, keyStrokes: MutableList<KeyStroke>) = onInvalid()
+    override fun onKey(
+      e: AnActionEvent,
+      keyStrokes: MutableList<KeyStroke>,
+      entries: Sequence<KeyStrokeTrie.TrieNode<T>>,
+    ) = onKey(entries)
+  })
+
+  protected val trie = KeyStrokeTrie<T>(name)
+  private val shortcutSet: ShortcutSet
+
+  init {
+    val keys: MutableList<KeyStroke> = mutableListOf()
+    for ((k, v) in data) {
+      keys.addAll(k)
+      trie.add(k, v)
+    }
+    val shortcuts = keys.map { KeyboardShortcut(it, null) }
+    shortcutSet = CustomShortcutSet(*shortcuts.toTypedArray())
+  }
+
+  protected val keyStrokes: MutableList<KeyStroke> = mutableListOf()
+
+  final override fun actionPerformed(e: AnActionEvent) {
+    var keyStroke = getKeyStroke(e) ?: return
+    // Omit the modifier (shift) from keyStroke
+    keyStroke.keyChar.let {
+      if (it != KeyEvent.CHAR_UNDEFINED) {
+        keyStroke = KeyStroke.getKeyStroke(it)
+      }
+    }
+    keyStrokes.add(keyStroke)
+    listener.onKey(e, keyStrokes, trie.getEntries(keyStrokes))
+
+    trie.getData(keyStrokes)?.let {
+      listener.onMatch(e, keyStrokes, it)
+      return
+    }
+    if (!trie.isPrefix(keyStrokes)) {
+      listener.onInvalid(e, keyStrokes)
+    }
+  }
+
+  fun register(component: JComponent?) = registerCustomShortcutSet(shortcutSet, component)
+  fun register(component: JComponent?, parentDisposable: Disposable?) =
+    registerCustomShortcutSet(shortcutSet, component, parentDisposable)
+
+  /**
+   * getDefaultKeyStroke is needed for NEO layout keyboard VIM-987
+   * but we should cache the value because on the second call (isEnabled -> actionPerformed)
+   * the event is already consumed
+   *
+   * @author Alex Plate
+   */
+  private var keyStrokeCache: Pair<KeyEvent?, KeyStroke?> = null to null
+
+  /**
+   * @author Alex Plate
+   */
+  private fun getKeyStroke(e: AnActionEvent): KeyStroke? {
+    val inputEvent = e.inputEvent
+    if (inputEvent is KeyEvent) {
+      val defaultKeyStroke = KeyStrokeAdapter.getDefaultKeyStroke(inputEvent)
+      val strokeCache = keyStrokeCache
+      if (defaultKeyStroke != null) {
+        keyStrokeCache = inputEvent to defaultKeyStroke
+        return defaultKeyStroke
+      } else if (strokeCache.first === inputEvent) {
+        keyStrokeCache = null to null
+        return strokeCache.second
+      }
+      return KeyStroke.getKeyStrokeForEvent(inputEvent)
+    }
+    return null
+  }
+}

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

@@ -0,0 +1,19 @@
+/*
+ * 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.extension
+
+import com.intellij.vim.api.VimApi
+import com.maddyhome.idea.vim.common.ListenerOwner
+import com.maddyhome.idea.vim.key.MappingOwner
+import com.maddyhome.idea.vim.thinapi.VimApiImpl
+
+internal fun VimExtension.api(): VimApi = VimApiImpl(
+  ListenerOwner.Plugin.get(this.name),
+  MappingOwner.Plugin.get(this.name),
+)

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())
   }
 
@@ -264,7 +270,7 @@ object VimExtensionFacade {
 fun VimExtensionFacade.exportOperatorFunction(name: String, function: OperatorFunction) {
   exportScriptFunction(null, name, listOf("type"), emptyList(), false, noneOfEnum()) { editor, context, args ->
 
-    val type = args["type"]?.asString()
+    val type = args["type"]?.toVimString()?.value
     val selectionType = when (type) {
       "line" -> SelectionType.LINE_WISE
       "block" -> SelectionType.BLOCK_WISE

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

@@ -65,7 +65,7 @@ internal object VimExtensionRegistrar : VimExtensionRegistrator {
     val option = ToggleOption(name, OptionDeclaredScope.GLOBAL, getAbbrev(name), false)
     VimPlugin.getOptionGroup().addOption(option)
     VimPlugin.getOptionGroup().addGlobalOptionChangeListener(option) {
-      if (injector.optionGroup.getOptionValue(option, OptionAccessScope.GLOBAL(null)).asBoolean()) {
+      if (injector.optionGroup.getOptionValue(option, OptionAccessScope.GLOBAL(null)).booleanValue) {
         initExtension(extensionBean, name)
         PluginState.Util.enabledExtensions.add(name)
       } else {

src/main/java/com/maddyhome/idea/vim/extension/argtextobj/VimArgTextObjExtension.java

@@ -204,7 +204,7 @@ public class VimArgTextObjExtension implements VimExtension {
             bracketPairs = BracketPairs.fromBracketPairList(bracketPairsVar);
           } catch (BracketPairs.ParseException parseException) {
             @VimNlsSafe String message =
-              MessageHelper.message("argtextobj.invalid.value.of.g.argtextobj.pairs.0", parseException.getMessage());
+              MessageHelper.message("argtextobj.error.invalid.value.of.g.argtextobj.pairs.0", parseException.getMessage());
             VimPlugin.showMessage(message);
             VimPlugin.indicateError();
             return null;

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)) {
-          return false
+        when {
+          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 true
+      return hasComment
     }
 
     private fun isComment(element: PsiElement) =

src/main/java/com/maddyhome/idea/vim/extension/exchange/VimExchangeExtension.kt

@@ -33,7 +33,6 @@ import com.maddyhome.idea.vim.extension.VimExtensionFacade.putExtensionHandlerMa
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissing
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.setRegister
 import com.maddyhome.idea.vim.extension.exportOperatorFunction
-import com.maddyhome.idea.vim.helper.fileSize
 import com.maddyhome.idea.vim.helper.moveToInlayAwareLogicalPosition
 import com.maddyhome.idea.vim.helper.moveToInlayAwareOffset
 import com.maddyhome.idea.vim.key.OperatorFunction
@@ -138,7 +137,7 @@ internal class VimExchangeExtension : VimExtension {
         val endAdj = if (!(isVisualLine) && (hlArea == HighlighterTargetArea.EXACT_RANGE || isVisual)) 1 else 0
         return ijEditor.markupModel.addRangeHighlighter(
           ijEditor.getMarkOffset(ex.start),
-          (ijEditor.getMarkOffset(ex.end) + endAdj).coerceAtMost(ijEditor.fileSize),
+          (ijEditor.getMarkOffset(ex.end) + endAdj).coerceAtMost(editor.fileSize().toInt()),
           HighlighterLayer.SELECTION - 1,
           attributes,
           hlArea,

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

@@ -209,13 +209,15 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, ModeChangeLis
     }
 
     private fun extractUsersHighlightColor(): Color {
-      val value = VimPlugin.getVariableService().getGlobalVariableValue(HIGHLIGHT_COLOR_VARIABLE_NAME)
+      val value =
+        VimPlugin.getVariableService().getGlobalVariableValue(HIGHLIGHT_COLOR_VARIABLE_NAME)?.toVimString()?.value
       if (value != null) {
         return try {
-          parseRgbaColor(value.asString())
+          parseRgbaColor(value)
         } catch (e: Exception) {
+          @Suppress("DialogTitleCapitalization")
           @VimNlsSafe val message = MessageHelper.message(
-            "highlightedyank.invalid.value.of.0.1",
+            "highlightedyank.error.invalid.value.of.0.1",
             "g:$HIGHLIGHT_COLOR_VARIABLE_NAME",
             e.message ?: "",
           )
@@ -227,14 +229,17 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, ModeChangeLis
     }
 
     private fun extractUserHighlightForegroundColor(): Color? {
-      val value = VimPlugin.getVariableService().getGlobalVariableValue(HIGHLIGHT_FOREGROUND_COLOR_VARIABLE_NAME)
-        ?: return null
+      val value =
+        VimPlugin.getVariableService().getGlobalVariableValue(HIGHLIGHT_FOREGROUND_COLOR_VARIABLE_NAME)
+          ?.toVimString()?.value
+          ?: return null
 
       return try {
-        parseRgbaColor(value.asString())
+        parseRgbaColor(value)
       } catch (e: Exception) {
+        @Suppress("DialogTitleCapitalization")
         @VimNlsSafe val message = MessageHelper.message(
-          "highlightedyank.invalid.value.of.0.1",
+          "highlightedyank.error.invalid.value.of.0.1",
           "g:$HIGHLIGHT_FOREGROUND_COLOR_VARIABLE_NAME",
           e.message ?: "",
         )
@@ -263,8 +268,9 @@ internal class VimHighlightedYank : VimExtension, VimYankListener, ModeChangeLis
         return try {
           extractFun(value)
         } catch (e: Exception) {
+          @Suppress("DialogTitleCapitalization")
           @VimNlsSafe val message = MessageHelper.message(
-            "highlightedyank.invalid.value.of.0.1",
+            "highlightedyank.error.invalid.value.of.0.1",
             "g:$variable",
             e.message ?: "",
           )

src/main/java/com/maddyhome/idea/vim/extension/hints/HintGenerator.kt

@@ -0,0 +1,121 @@
+/*
+ * 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.extension.hints
+
+import com.intellij.ui.treeStructure.Tree
+import java.awt.Component
+import java.awt.Point
+import java.util.*
+import javax.accessibility.Accessible
+import javax.swing.SwingUtilities
+
+internal sealed class HintGenerator {
+  private var hints: Map<Accessible, String> = emptyMap()
+  protected val previousHints get() = hints
+
+  abstract fun generate(targets: List<HintTarget>)
+
+  fun <T> generate(root: T, glassPane: Component): List<HintTarget> where T : Accessible, T : Component =
+    collectTargets(root, glassPane).also { targets ->
+      generate(targets)
+      hints = WeakHashMap(targets.associateBy(HintTarget::component, HintTarget::hint).filterValues(String::isNotEmpty))
+    }
+
+  class Permutation(private val alphabet: List<Char>) : HintGenerator() {
+    init {
+      require(alphabet.size > 1) { "Alphabet must contain at least two characters" }
+    }
+
+    override fun generate(targets: List<HintTarget>) = generate(targets, true)
+
+    /**
+     * @param preserve Whether to preserve the previous hints if possible
+     */
+    private fun generate(targets: List<HintTarget>, preserve: Boolean) {
+      val length = generateSequence(1) { it * alphabet.size }.takeWhile {
+        it < targets.size + if (preserve) previousHints.size else 0
+      }.count()
+      val hintIterator = alphabet.permutations(length).map { it.joinToString("") }.iterator()
+      targets.forEach { target ->
+        target.hint = if (preserve) {
+          previousHints[target.component] ?: hintIterator.firstOrNull {
+            // Check if the hint is not already used by previous targets
+            !previousHints.values.any { hint -> hint.startsWith(it) || it.startsWith(hint) }
+          } ?: return generate(targets, false) // do not preserve previous hints if failed
+        } else {
+          hintIterator.next()
+        }
+      }
+    }
+  }
+}
+
+private fun <T> collectTargets(
+  component: T,
+  destination: Component,
+): List<HintTarget> where T : Accessible, T : Component = mutableMapOf<Accessible, HintTarget>().also {
+  collectTargets(it, component, SwingUtilities.convertPoint(component.parent, component.location, destination))
+}.values.toList()
+
+private fun collectTargets(
+  targets: MutableMap<Accessible, HintTarget>,
+  component: Accessible,
+  location: Point,
+  depth: Int = 0,
+): Unit = with(component.accessibleContext) {
+  val accessible = accessibleComponent ?: return
+  val location = location + (accessible.location ?: return)
+
+  accessible.size?.let { size ->
+    if (accessible.isShowing && (component.isClickable() || component is Tree)) {
+      targets[component].let {
+        // For some reason, the same component may appear multiple times in the accessible tree.
+        if (it == null || it.depth > depth) {
+          targets[component] = HintTarget(component, location, size, depth)
+        }
+      }
+    }
+  }
+
+  // Skip the children of the Tree, otherwise it will easily lead to performance problems
+  if (component is Tree) return
+  // recursively collect children
+  for (i in 0..<accessibleChildrenCount) {
+    collectTargets(targets, getAccessibleChild(i), location, depth + 1)
+  }
+}
+
+/**
+ * Check if the component is clickable
+ *
+ * @return whether the component is clickable
+ */
+private fun Accessible.isClickable(): Boolean = (accessibleContext.accessibleAction?.accessibleActionCount ?: 0) > 0
+
+private operator fun Point.plus(other: Point) = Point(x + other.x, y + other.y)
+
+private fun <T> Collection<T>.permutations(length: Int): Sequence<List<T>> = sequence {
+  if (length == 0) {
+    yield(emptyList())
+    return@sequence
+  }
+  for (element in this@permutations) {
+    this@permutations.permutations(length - 1).forEach { subPermutation ->
+      yield(listOf(element) + subPermutation)
+    }
+  }
+}
+
+private fun <T> Iterator<T>.firstOrNull(predicate: (T) -> Boolean): T? {
+  while (hasNext()) {
+    val next = next()
+    if (predicate(next)) return next
+  }
+  return null
+}

src/main/java/com/maddyhome/idea/vim/extension/hints/HintTarget.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.extension.hints
+
+import java.awt.Dimension
+import java.awt.Point
+import java.awt.Rectangle
+import javax.accessibility.Accessible
+
+internal data class HintTarget(val component: Accessible, val location: Point, val size: Dimension, val depth: Int) {
+  var hint: String = ""
+
+  val bounds: Rectangle get() = Rectangle(location, size)
+}

src/main/java/com/maddyhome/idea/vim/extension/hints/ToggleHintsAction.kt

@@ -0,0 +1,136 @@
+/*
+ * 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.extension.hints
+
+import com.intellij.openapi.actionSystem.ActionUpdateThread
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.PlatformDataKeys
+import com.intellij.openapi.project.DumbAwareToggleAction
+import com.intellij.openapi.ui.popup.JBPopupFactory
+import com.intellij.openapi.ui.popup.JBPopupListener
+import com.intellij.openapi.ui.popup.LightweightWindowEvent
+import com.intellij.openapi.wm.impl.IdeGlassPaneImpl
+import com.intellij.ui.JBColor
+import com.intellij.util.Alarm
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.extension.ShortcutDispatcher
+import com.maddyhome.idea.vim.newapi.globalIjOptions
+import java.awt.Color
+import javax.swing.JComponent
+import javax.swing.JLabel
+import javax.swing.JPanel
+import javax.swing.JRootPane
+import javax.swing.SwingUtilities
+
+class ToggleHintsAction : DumbAwareToggleAction() {
+  /** The mask layer container for placing all hints */
+  private var cover: JComponent? = null
+
+  private val alarm = Alarm(Alarm.ThreadToUse.SWING_THREAD)
+  private val highlight = HighlightComponent()
+
+  private val generator = HintGenerator.Permutation(alphabet)
+
+  override fun getActionUpdateThread(): ActionUpdateThread = ActionUpdateThread.BGT
+
+  override fun isSelected(e: AnActionEvent): Boolean = cover != null
+
+  override fun setSelected(e: AnActionEvent, selected: Boolean) {
+    val rootPane = SwingUtilities.getRootPane(e.getData(PlatformDataKeys.CONTEXT_COMPONENT)) ?: return
+    if (!injector.globalIjOptions().vimHints) return
+    val glassPane = rootPane.glassPane as IdeGlassPaneImpl
+    if (selected) {
+      enable(rootPane, glassPane)
+    } else {
+      disable(glassPane)
+    }
+  }
+
+  private fun enable(rootPane: JRootPane, glassPane: IdeGlassPaneImpl) {
+    val targets = generator.generate(rootPane, glassPane)
+
+    val cover = JPanel().apply {
+      cover = this
+      layout = null // no layout manager (absolute positioning)
+      isOpaque = false
+      targets.map(HintTarget::createCover).forEach(::add)
+      size = glassPane.size
+    }
+
+    if (highlight !in glassPane.components) glassPane.add(highlight)
+    if (cover !in glassPane.components) glassPane.add(cover)
+    glassPane.isVisible = true
+
+    val select = JPanel()
+    val popup = JBPopupFactory.getInstance().createComponentPopupBuilder(select, select).createPopup()
+    popup.setRequestFocus(true)
+    popup.addListener(object : JBPopupListener {
+      override fun onClosed(event: LightweightWindowEvent) {
+        disable(glassPane)
+      }
+    })
+    ShortcutDispatcher("hints", targets.associateBy { it.hint.lowercase() }, { target ->
+      popup.closeOk(null)
+      alarm.cancelAllRequests()
+      target.component.accessibleContext?.apply {
+        if (accessibleAction?.doAccessibleAction(0) == null && !accessibleComponent.isFocusTraversable) return@apply
+        accessibleComponent.requestFocus()
+        highlight.setTarget(target)
+        alarm.addRequest({ highlight.setTarget(null) }, highlightDuration)
+      }
+    }, {
+      popup.cancel()
+      injector.messages.indicateError()
+    }, { entries ->
+      cover.removeAll()
+      entries.map { it.data!! }.map(HintTarget::createCover).forEach(cover::add)
+      cover.revalidate()
+      cover.repaint()
+    }).register(select, popup)
+    popup.showInCenterOf(rootPane)
+  }
+
+  private fun disable(glassPane: IdeGlassPaneImpl) {
+    cover?.let(glassPane::remove)
+    glassPane.revalidate()
+    glassPane.repaint()
+    cover = null
+  }
+}
+
+private fun HintTarget.createCover() = JPanel().apply {
+  isOpaque = false
+  bounds = this@createCover.bounds
+  add(JLabel().apply {
+    text = hint
+    isOpaque = true
+    background = JBColor.YELLOW.let { Color(it.red, it.green, it.blue, 200) }
+    foreground = JBColor.foreground()
+  })
+}
+
+private class HighlightComponent : JPanel() {
+  init {
+    background = JBColor.GREEN.let { Color(it.red, it.green, it.blue, 100) }
+    border = javax.swing.border.LineBorder(JBColor.GREEN, 1)
+  }
+
+  fun setTarget(target: HintTarget?) {
+    if (target != null) {
+      bounds = target.bounds
+      isVisible = true
+    } else {
+      isVisible = false
+    }
+  }
+}
+
+private const val highlightDuration = 500
+
+private val alphabet = "ASDFGHJKL".toList()

src/main/java/com/maddyhome/idea/vim/extension/multiplecursors/VimMultipleCursorsExtension.kt

@@ -210,7 +210,7 @@ internal class VimMultipleCursorsExtension : VimExtension {
         if (nextOffset != -1) {
           caretModel.allCarets.forEach {
             if (it.selectionStart == nextOffset) {
-              VimPlugin.showMessage(MessageHelper.message("message.no.more.matches"))
+              VimPlugin.showMessage(MessageHelper.message("multiple-cursors.message.no.more.matches"))
               return
             }
           }
@@ -219,7 +219,7 @@ internal class VimMultipleCursorsExtension : VimExtension {
           editor.updateCaretsVisualAttributes()
           editor.vimMultipleCursorsLastSelection = selectText(caret, pattern, nextOffset)
         } else {
-          VimPlugin.showMessage(MessageHelper.message("message.no.more.matches"))
+          VimPlugin.showMessage(MessageHelper.message("multiple-cursors.message.no.more.matches"))
         }
       }
     }
@@ -234,7 +234,7 @@ internal class VimMultipleCursorsExtension : VimExtension {
       val text = if (editor.inVisualMode) {
         primaryCaret.selectedText ?: return
       } else {
-        val range = injector.searchHelper.findWordNearestCursor(editor.vim, primaryCaret.vim) ?: return
+        val range = injector.searchHelper.findWordAtOrFollowingCursor(editor.vim, primaryCaret.vim, isBigWord = false) ?: return
         if (range.startOffset > primaryCaret.offset) return
         IjVimEditor(editor).getText(range)
       }
@@ -269,7 +269,7 @@ internal class VimMultipleCursorsExtension : VimExtension {
       if (nextOffset != -1) {
         editor.caretModel.allCarets.forEach {
           if (it.selectionStart == nextOffset) {
-            VimPlugin.showMessage(MessageHelper.message("message.no.more.matches"))
+            VimPlugin.showMessage(MessageHelper.message("multiple-cursors.message.no.more.matches"))
             return
           }
         }
@@ -300,7 +300,7 @@ internal class VimMultipleCursorsExtension : VimExtension {
 
   private fun selectWordUnderCaret(editor: Editor, caret: Caret): TextRange? {
     // TODO: I think vim-multiple-cursors uses a text object rather than the star operator
-    val range = injector.searchHelper.findWordNearestCursor(editor.vim, caret.vim) ?: return null
+    val range = injector.searchHelper.findWordAtOrFollowingCursor(editor.vim, caret.vim, isBigWord = false) ?: return null
     if (range.startOffset > caret.offset) return null
 
     enterVisualMode(editor.vim)

src/main/java/com/maddyhome/idea/vim/extension/nerdtree/AbstractDispatcher.kt

@@ -0,0 +1,63 @@
+/*
+ * 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.extension.nerdtree
+
+import com.intellij.openapi.actionSystem.ActionUpdateThread
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.PlatformDataKeys
+import com.intellij.ui.treeStructure.Tree
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.diagnostic.vimLogger
+import com.maddyhome.idea.vim.extension.ShortcutDispatcher
+import java.awt.event.KeyEvent
+import javax.swing.KeyStroke
+
+/**
+ * Handles keyboard shortcuts and delegates them to appropriate actions.
+ */
+internal abstract class AbstractDispatcher(name: String, mappings: Map<List<KeyStroke>, NerdTreeAction>) :
+  ShortcutDispatcher<NerdTreeAction>(name, mappings, NerdTreeListener) {
+
+  private object NerdTreeListener : Listener<NerdTreeAction> {
+    override fun onMatch(e: AnActionEvent, keyStrokes: MutableList<KeyStroke>, data: NerdTreeAction) {
+      val component = e.getData(PlatformDataKeys.CONTEXT_COMPONENT)
+      if (component is Tree) {
+        data.action(e, component)
+      } else {
+        LOG.error("Component is not a tree: $component")
+      }
+
+      keyStrokes.clear()
+    }
+
+    override fun onInvalid(e: AnActionEvent, keyStrokes: MutableList<KeyStroke>) {
+      keyStrokes.clear()
+      injector.messages.indicateError()
+    }
+  }
+
+  override fun update(e: AnActionEvent) {
+    e.presentation.isEnabled = true
+    // If <ESC> is pressed, clear the keys; skip only if there are no keys
+    if ((e.inputEvent as? KeyEvent)?.keyCode == KeyEvent.VK_ESCAPE) {
+      e.presentation.isEnabled = keyStrokes.isNotEmpty()
+      keyStrokes.clear()
+    }
+    // Skip if SpeedSearch is active
+    if (e.getData(PlatformDataKeys.SPEED_SEARCH_TEXT) != null) {
+      e.presentation.isEnabled = false
+    }
+  }
+
+  override fun getActionUpdateThread() = ActionUpdateThread.BGT
+
+  companion object {
+    val LOG = vimLogger<AbstractDispatcher>()
+  }
+}

src/main/java/com/maddyhome/idea/vim/extension/nerdtree/Mappings.kt

@@ -0,0 +1,137 @@
+/*
+ * 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.extension.nerdtree
+
+import com.intellij.openapi.options.advanced.AdvancedSettings
+import com.intellij.util.ui.tree.TreeUtil
+import com.maddyhome.idea.vim.VimPlugin
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.vimscript.model.datatypes.VimString
+import javax.swing.KeyStroke
+import javax.swing.tree.TreeNode
+
+fun MutableMap<List<KeyStroke>, NerdTreeAction>.register(
+  variable: String,
+  defaultMapping: String,
+  action: NerdTreeAction,
+) {
+  val variableValue = VimPlugin.getVariableService().getGlobalVariableValue(variable)
+  val mapping = if (variableValue is VimString) {
+    variableValue.value
+  } else {
+    defaultMapping
+  }
+  register(mapping, action)
+}
+
+fun MutableMap<List<KeyStroke>, NerdTreeAction>.register(mapping: String, action: NerdTreeAction) {
+  this[injector.parser.parseKeys(mapping)] = action
+}
+
+/**
+ * Navigation-related mappings
+ * <pre><code>
+ * Default~
+ * Key      Description                                                             Map settings
+ *
+ * O........Recursively open the selected directory..................*NERDTreeMapOpenRecursively*
+ * x........Close the current nodes parent..................................*NERDTreeMapCloseDir*
+ * X........Recursively close all children of the current node.........*NERDTreeMapCloseChildren*
+ *
+ * P........Jump to the root node...........................................*NERDTreeMapJumpRoot*
+ * p........Jump to current nodes parent..................................*NERDTreeMapJumpParent*
+ * K........Jump up inside directories at the current tree depth......*NERDTreeMapJumpFirstChild*
+ * J........Jump down inside directories at the current tree depth.....*NERDTreeMapJumpLastChild*
+ * <C-J>....Jump down to next sibling of the current directory.......*NERDTreeMapJumpNextSibling*
+ * <C-K>....Jump up to previous sibling of the current directory.....*NERDTreeMapJumpPrevSibling*
+ * </code></pre>
+ */
+val navigationMappings: Map<List<KeyStroke>, NerdTreeAction> = mutableMapOf<List<KeyStroke>, NerdTreeAction>().apply {
+  // TODO support going [count] lines upward/downward or to line [count]
+  register("k", NerdTreeAction.ij("Tree-selectPrevious"))
+  register("j", NerdTreeAction.ij("Tree-selectNext"))
+  register("G", NerdTreeAction.ij("Tree-selectLast"))
+  register("gg", NerdTreeAction.ij("Tree-selectFirst"))
+
+  // FIXME lazy loaded tree nodes are not expanded
+  register("NERDTreeMapOpenRecursively", "O", NerdTreeAction.ij("FullyExpandTreeNode"))
+  // This action respects `ide.tree.collapse.recursively`. We may prompt the user to disable it
+  register("NERDTreeMapCloseDir", "x", NerdTreeAction { _, tree ->
+    tree.selectionPath?.parentPath?.let {
+      if (tree.getRowForPath(it) >= 0) { // skip if invisible, but we cannot use `tree.isVisible(path)` here
+        tree.selectionPath = it
+        tree.collapsePath(it)
+        tree.scrollPathToVisible(it)
+      }
+    }
+  })
+  register(
+    "NERDTreeMapCloseChildren",
+    "X",
+    NerdTreeAction { _, tree ->
+      val path = tree.selectionPath ?: return@NerdTreeAction
+
+      // FIXME We should avoid relying on `ide.tree.collapse.recursively` since it closes visible paths only
+      val recursive = AdvancedSettings.getBoolean("ide.tree.collapse.recursively")
+      try {
+        AdvancedSettings.setBoolean("ide.tree.collapse.recursively", true)
+        // Note that we cannot use `tree.collapsePaths` here since it does not respect `ide.tree.collapse.recursively`
+        TreeUtil.listChildren(path.lastPathComponent as TreeNode).filterNot(TreeNode::isLeaf)
+          .map(path::pathByAddingChild).forEach(tree::collapsePath)
+      } finally {
+        AdvancedSettings.setBoolean("ide.tree.collapse.recursively", recursive)
+      }
+
+      tree.scrollPathToVisible(path)
+    },
+  )
+
+  register("NERDTreeMapJumpRoot", "P", NerdTreeAction { _, tree ->
+    // Note that we should not consider the root simply the first row
+    // It cannot be guaranteed that the tree has a single visible root
+    var path = tree.selectionPath ?: return@NerdTreeAction
+    while (path.parentPath != null && tree.getRowForPath(path.parentPath) >= 0) {
+      path = path.parentPath
+    }
+    tree.selectionPath = path
+    tree.scrollPathToVisible(path)
+  })
+  register("NERDTreeMapJumpParent", "p", NerdTreeAction.ij("Tree-selectParentNoCollapse"))
+  register(
+    "NERDTreeMapJumpFirstChild",
+    "K",
+    NerdTreeAction { _, tree ->
+      var path = tree.selectionPath ?: return@NerdTreeAction
+      while (true) {
+        val previous = TreeUtil.previousVisibleSibling(tree, path) ?: break
+        path = previous
+      }
+      tree.selectionPath = path
+      tree.scrollPathToVisible(path)
+    },
+  )
+  register(
+    "NERDTreeMapJumpLastChild",
+    "J",
+    NerdTreeAction { _, tree ->
+      var path = tree.selectionPath ?: return@NerdTreeAction
+      while (true) {
+        val next = TreeUtil.nextVisibleSibling(tree, path) ?: break
+        path = next
+      }
+      tree.selectionPath = path
+      tree.scrollPathToVisible(path)
+    },
+  )
+  register("NERDTreeMapJumpNextSibling", "<C-J>", NerdTreeAction.ij("Tree-selectNextSibling"))
+  register("NERDTreeMapJumpPrevSibling", "<C-K>", NerdTreeAction.ij("Tree-selectPreviousSibling"))
+
+  register("/", NerdTreeAction.ij("SpeedSearch"))
+  register("<ESC>", NerdTreeAction { _, _ -> })
+}

src/main/java/com/maddyhome/idea/vim/extension/nerdtree/NerdAction.kt

@@ -1,18 +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.extension.nerdtree
-
-import com.intellij.openapi.actionSystem.AnActionEvent
-import com.intellij.openapi.actionSystem.DataContext
-import com.intellij.openapi.project.Project
-
-internal sealed class NerdAction {
-  class ToIj(val name: String) : NerdAction()
-  class Code(val action: (Project, DataContext, AnActionEvent) -> Unit) : NerdAction()
-}

src/main/java/com/maddyhome/idea/vim/extension/nerdtree/NerdTree.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
@@ -9,49 +9,32 @@
 package com.maddyhome.idea.vim.extension.nerdtree
 
 import com.intellij.ide.projectView.ProjectView
-import com.intellij.ide.projectView.impl.AbstractProjectViewPane
 import com.intellij.ide.projectView.impl.ProjectViewImpl
-import com.intellij.openapi.actionSystem.ActionManager
-import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
-import com.intellij.openapi.actionSystem.PlatformDataKeys
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.diagnostic.logger
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.components.service
 import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
-import com.intellij.openapi.project.DumbAwareAction
+import com.intellij.openapi.fileEditor.impl.EditorWindow
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.project.ProjectManager
 import com.intellij.openapi.startup.ProjectActivity
-import com.intellij.openapi.wm.ToolWindow
 import com.intellij.openapi.wm.ToolWindowId
 import com.intellij.openapi.wm.ex.ToolWindowManagerEx
-import com.intellij.openapi.wm.ex.ToolWindowManagerListener
-import com.intellij.ui.KeyStrokeAdapter
-import com.intellij.ui.TreeExpandCollapse
-import com.intellij.ui.speedSearch.SpeedSearchSupply
-import com.intellij.util.ui.tree.TreeUtil
-import com.maddyhome.idea.vim.VimPlugin
 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.CommandAlias
 import com.maddyhome.idea.vim.common.CommandAliasHandler
+import com.maddyhome.idea.vim.diagnostic.vimLogger
 import com.maddyhome.idea.vim.ex.ranges.Range
 import com.maddyhome.idea.vim.extension.VimExtension
-import com.maddyhome.idea.vim.group.KeyGroup
-import com.maddyhome.idea.vim.helper.MessageHelper
-import com.maddyhome.idea.vim.helper.runAfterGotFocus
-import com.maddyhome.idea.vim.key.KeyStrokeTrie
-import com.maddyhome.idea.vim.key.MappingOwner
-import com.maddyhome.idea.vim.key.RequiredShortcut
-import com.maddyhome.idea.vim.key.add
+import com.maddyhome.idea.vim.extension.VimExtensionFacade
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
-import com.maddyhome.idea.vim.vimscript.model.datatypes.VimString
-import java.awt.event.KeyEvent
+import java.util.concurrent.locks.ReentrantReadWriteLock
 import javax.swing.KeyStroke
 import javax.swing.SwingConstants
+import kotlin.concurrent.read
+import kotlin.concurrent.write
 
 /**
  * Features and issues:
@@ -113,29 +96,42 @@ import javax.swing.SwingConstants
  * ?........Toggle the display of the quick help.......................|NERDTree-?|
  */
 internal class NerdTree : VimExtension {
-  override fun getName(): String = pluginName
+  override fun getName(): String = PLUGIN_NAME
 
   override fun init() {
     LOG.info("IdeaVim: Initializing NERDTree extension. Disable this extension if you observe a strange behaviour of the project tree. E.g. moving down on 'j'")
+    lock.write {
+      enabled = true
 
-    registerCommands()
-
-    addCommand("NERDTreeFocus", IjCommandHandler("ActivateProjectToolWindow"))
-    addCommand("NERDTree", IjCommandHandler("ActivateProjectToolWindow"))
-    addCommand("NERDTreeToggle", ToggleHandler())
-    addCommand("NERDTreeClose", CloseHandler())
-    addCommand("NERDTreeFind", IjCommandHandler("SelectInProjectView"))
-    addCommand("NERDTreeRefreshRoot", IjCommandHandler("Synchronize"))
-
-    synchronized(Util.monitor) {
-      Util.commandsRegistered = true
-      ProjectManager.getInstance().openProjects.forEach { project -> installDispatcher(project) }
+      VimExtensionFacade.addCommand("NERDTreeFocus", IjCommandHandler("ActivateProjectToolWindow"))
+      VimExtensionFacade.addCommand("NERDTree", IjCommandHandler("ActivateProjectToolWindow"))
+      VimExtensionFacade.addCommand("NERDTreeToggle", ToggleHandler())
+      VimExtensionFacade.addCommand("NERDTreeClose", CloseHandler())
+      VimExtensionFacade.addCommand("NERDTreeFind", IjCommandHandler("SelectInProjectView"))
+      VimExtensionFacade.addCommand("NERDTreeRefreshRoot", IjCommandHandler("Synchronize"))
     }
+    ProjectManager.getInstance().openProjects.forEach(::installDispatcher)
+  }
+
+  override fun dispose() {
+    lock.write {
+      enabled = false
+      // TODO remove ex-commands
+      ProjectManager.getInstance().openProjects.forEach { project ->
+        val component = (ProjectView.getInstance(project) as ProjectViewImpl).component
+        if (component != null) {
+          NerdDispatcher.getInstance(project).unregisterCustomShortcutSet(component)
+        } else {
+          LOG.error("$project: project view component is null")
+        }
+      }
+    }
+    super.dispose()
   }
 
   class IjCommandHandler(private val actionId: String) : CommandAliasHandler {
     override fun execute(command: String, range: Range, editor: VimEditor, context: ExecutionContext) {
-      Util.callAction(editor, actionId, context)
+      NerdTreeAction.callAction(editor, actionId, context)
     }
   }
 
@@ -146,7 +142,7 @@ internal class NerdTree : VimExtension {
       if (toolWindow.isVisible) {
         toolWindow.hide()
       } else {
-        Util.callAction(editor, "ActivateProjectToolWindow", context)
+        NerdTreeAction.callAction(editor, "ActivateProjectToolWindow", context)
       }
     }
   }
@@ -161,403 +157,142 @@ internal class NerdTree : VimExtension {
     }
   }
 
-  class ProjectViewListener(private val project: Project) : ToolWindowManagerListener {
-    override fun toolWindowShown(toolWindow: ToolWindow) {
-      if (ToolWindowId.PROJECT_VIEW != toolWindow.id) return
-
-      val dispatcher = NerdDispatcher.getInstance(project)
-      if (dispatcher.speedSearchListenerInstalled) return
-
-      // I specify nullability explicitly as we've got a lot of exceptions saying this property is null
-      val currentProjectViewPane: AbstractProjectViewPane? = ProjectView.getInstance(project).currentProjectViewPane
-      val tree = currentProjectViewPane?.tree ?: return
-      val supply = SpeedSearchSupply.getSupply(tree, true) ?: return
-
-      // NB: Here might be some issues with concurrency, but it's not really bad, I think
-      dispatcher.speedSearchListenerInstalled = true
-      supply.addChangeListener {
-        dispatcher.waitForSearch = false
-      }
-    }
-  }
-
-  // TODO I'm not sure is this activity runs at all? Should we use [RunOnceUtil] instead?
   class NerdStartupActivity : ProjectActivity {
     override suspend fun execute(project: Project) {
-      synchronized(Util.monitor) {
-        if (!Util.commandsRegistered) return
-        installDispatcher(project)
-      }
+      installDispatcher(project)
     }
   }
 
-  class NerdDispatcher : DumbAwareAction() {
-    internal var waitForSearch = false
-    internal var speedSearchListenerInstalled = false
-
-    private val keys = mutableListOf<KeyStroke>()
-
-    override fun actionPerformed(e: AnActionEvent) {
-      var keyStroke = getKeyStroke(e) ?: return
-      val keyChar = keyStroke.keyChar
-      if (keyChar != KeyEvent.CHAR_UNDEFINED) {
-        keyStroke = KeyStroke.getKeyStroke(keyChar)
-      }
-
-      keys.add(keyStroke)
-      actionsRoot.getData(keys)?.let { action ->
-        when (action) {
-          is NerdAction.ToIj -> Util.callAction(null, action.name, e.dataContext.vim)
-          is NerdAction.Code -> e.project?.let { action.action(it, e.dataContext, e) }
-        }
-
-        keys.clear()
-      }
-    }
-
-    override fun update(e: AnActionEvent) {
-      // Special processing of esc.
-      if ((e.inputEvent as? KeyEvent)?.keyCode == ESCAPE_KEY_CODE) {
-        e.presentation.isEnabled = waitForSearch
-        return
-      }
-
-      if (waitForSearch) {
-        e.presentation.isEnabled = false
-        return
-      }
-      e.presentation.isEnabled = !speedSearchIsHere(e)
-    }
-
-    override fun getActionUpdateThread() = ActionUpdateThread.BGT
-
-    private fun speedSearchIsHere(e: AnActionEvent): Boolean {
-      val searchText = e.getData(PlatformDataKeys.SPEED_SEARCH_TEXT)
-      return !searchText.isNullOrEmpty()
-    }
-
+  @Service(Service.Level.PROJECT)
+  class NerdDispatcher : AbstractDispatcher(PLUGIN_NAME, createMappings()) {
     companion object {
       fun getInstance(project: Project): NerdDispatcher {
-        return project.getService(NerdDispatcher::class.java)
-      }
-
-      private const val ESCAPE_KEY_CODE = 27
-    }
-
-    /**
-     * getDefaultKeyStroke is needed for NEO layout keyboard VIM-987
-     * but we should cache the value because on the second call (isEnabled -> actionPerformed)
-     * the event is already consumed
-     */
-    private var keyStrokeCache: Pair<KeyEvent?, KeyStroke?> = null to null
-
-    private fun getKeyStroke(e: AnActionEvent): KeyStroke? {
-      val inputEvent = e.inputEvent
-      if (inputEvent is KeyEvent) {
-        val defaultKeyStroke = KeyStrokeAdapter.getDefaultKeyStroke(inputEvent)
-        val strokeCache = keyStrokeCache
-        if (defaultKeyStroke != null) {
-          keyStrokeCache = inputEvent to defaultKeyStroke
-          return defaultKeyStroke
-        } else if (strokeCache.first === inputEvent) {
-          keyStrokeCache = null to null
-          return strokeCache.second
-        }
-        return KeyStroke.getKeyStrokeForEvent(inputEvent)
-      }
-      return null
-    }
-  }
-
-  private fun registerCommands() {
-    // TODO: 22.01.2021 Should not just to the last line after the first
-    registerCommand("j", NerdAction.ToIj("Tree-selectNext"))
-    registerCommand("k", NerdAction.ToIj("Tree-selectPrevious"))
-    registerCommand(
-      "NERDTreeMapActivateNode",
-      "o",
-      NerdAction.Code { project, dataContext, _ ->
-        val tree = ProjectView.getInstance(project).currentProjectViewPane.tree
-
-        val array = CommonDataKeys.NAVIGATABLE_ARRAY.getData(dataContext)?.filter { it.canNavigateToSource() }
-        if (array.isNullOrEmpty()) {
-          val row = tree.selectionRows?.getOrNull(0) ?: return@Code
-          if (tree.isExpanded(row)) {
-            tree.collapseRow(row)
-          } else {
-            tree.expandRow(row)
-          }
-        } else {
-          array.forEach { it.navigate(true) }
-        }
-      },
-    )
-    registerCommand(
-      "NERDTreeMapPreview",
-      "go",
-      NerdAction.Code { _, dataContext, _ ->
-        CommonDataKeys.NAVIGATABLE_ARRAY
-          .getData(dataContext)
-          ?.filter { it.canNavigateToSource() }
-          ?.forEach { it.navigate(false) }
-      },
-    )
-    registerCommand(
-      "NERDTreeMapOpenInTab",
-      "t",
-      NerdAction.Code { _, dataContext, _ ->
-        // FIXME: 22.01.2021 Doesn't work correct
-        CommonDataKeys.NAVIGATABLE_ARRAY
-          .getData(dataContext)
-          ?.filter { it.canNavigateToSource() }
-          ?.forEach { it.navigate(true) }
-      },
-    )
-    registerCommand(
-      "NERDTreeMapOpenInTabSilent",
-      "T",
-      NerdAction.Code { _, dataContext, _ ->
-        // FIXME: 22.01.2021 Doesn't work correct
-        CommonDataKeys.NAVIGATABLE_ARRAY
-          .getData(dataContext)
-          ?.filter { it.canNavigateToSource() }
-          ?.forEach { it.navigate(true) }
-      },
-    )
-
-    // TODO: 21.01.2021 Should option in left split
-    registerCommand("NERDTreeMapOpenVSplit", "s", NerdAction.ToIj("OpenInRightSplit"))
-    // TODO: 21.01.2021 Should option in above split
-    registerCommand(
-      "NERDTreeMapOpenSplit",
-      "i",
-      NerdAction.Code { project, _, event ->
-        val file = event.getData(CommonDataKeys.VIRTUAL_FILE) ?: return@Code
-        if (file.isDirectory) return@Code
-        val splitters = FileEditorManagerEx.getInstanceEx(project).splitters
-        val currentWindow = splitters.currentWindow
-        currentWindow?.split(SwingConstants.HORIZONTAL, true, file, true)
-      },
-    )
-    registerCommand(
-      "NERDTreeMapPreviewVSplit",
-      "gs",
-      NerdAction.Code { project, context, event ->
-        val file = event.getData(CommonDataKeys.VIRTUAL_FILE) ?: return@Code
-        val splitters = FileEditorManagerEx.getInstanceEx(project).splitters
-        val currentWindow = splitters.currentWindow
-        currentWindow?.split(SwingConstants.VERTICAL, true, file, true)
-
-        // FIXME: 22.01.2021 This solution bouncing a bit
-        Util.callAction(null, "ActivateProjectToolWindow", context.vim)
-      },
-    )
-    registerCommand(
-      "NERDTreeMapPreviewSplit",
-      "gi",
-      NerdAction.Code { project, context, event ->
-        val file = event.getData(CommonDataKeys.VIRTUAL_FILE) ?: return@Code
-        val splitters = FileEditorManagerEx.getInstanceEx(project).splitters
-        val currentWindow = splitters.currentWindow
-        currentWindow?.split(SwingConstants.HORIZONTAL, true, file, true)
-
-        Util.callAction(null, "ActivateProjectToolWindow", context.vim)
-      },
-    )
-    registerCommand(
-      "NERDTreeMapOpenRecursively",
-      "O",
-      NerdAction.Code { project, _, _ ->
-        val tree = ProjectView.getInstance(project).currentProjectViewPane.tree
-        TreeExpandCollapse.expandAll(tree)
-        tree.selectionPath?.let {
-          TreeUtil.scrollToVisible(tree, it, false)
-        }
-      },
-    )
-    registerCommand(
-      "NERDTreeMapCloseChildren",
-      "X",
-      NerdAction.Code { project, _, _ ->
-        val tree = ProjectView.getInstance(project).currentProjectViewPane.tree
-        TreeExpandCollapse.collapse(tree)
-        tree.selectionPath?.let {
-          TreeUtil.scrollToVisible(tree, it, false)
-        }
-      },
-    )
-    registerCommand(
-      "NERDTreeMapCloseDir",
-      "x",
-      NerdAction.Code { project, _, _ ->
-        val tree = ProjectView.getInstance(project).currentProjectViewPane.tree
-        val currentPath = tree.selectionPath ?: return@Code
-        if (tree.isExpanded(currentPath)) {
-          tree.collapsePath(currentPath)
-        } else {
-          val parentPath = currentPath.parentPath ?: return@Code
-          if (parentPath.parentPath != null) {
-            // The real root of the project is not shown in the project view, so we check the grandparent of the node
-            tree.collapsePath(parentPath)
-            TreeUtil.scrollToVisible(tree, parentPath, false)
-          }
-        }
-      },
-    )
-    registerCommand("NERDTreeMapJumpRoot", "P", NerdAction.ToIj("Tree-selectFirst"))
-    registerCommand(
-      "NERDTreeMapJumpParent",
-      "p",
-      NerdAction.Code { project, _, _ ->
-        val tree = ProjectView.getInstance(project).currentProjectViewPane.tree
-        val currentPath = tree.selectionPath ?: return@Code
-        val parentPath = currentPath.parentPath ?: return@Code
-        if (parentPath.parentPath != null) {
-          // The real root of the project is not shown in the project view, so we check the grandparent of the node
-          tree.selectionPath = parentPath
-          TreeUtil.scrollToVisible(tree, parentPath, false)
-        }
-      },
-    )
-    registerCommand(
-      "NERDTreeMapJumpFirstChild",
-      "K",
-      NerdAction.Code { project, _, _ ->
-        val tree = ProjectView.getInstance(project).currentProjectViewPane.tree
-        val currentPath = tree.selectionPath ?: return@Code
-        val parent = currentPath.parentPath ?: return@Code
-        val row = tree.getRowForPath(parent)
-        tree.setSelectionRow(row + 1)
-
-        tree.scrollRowToVisible(row + 1)
-      },
-    )
-    registerCommand(
-      "NERDTreeMapJumpLastChild",
-      "J",
-      NerdAction.Code { project, _, _ ->
-        val tree = ProjectView.getInstance(project).currentProjectViewPane.tree
-        val currentPath = tree.selectionPath ?: return@Code
-
-        val currentPathCount = currentPath.pathCount
-        var row = tree.getRowForPath(currentPath)
-
-        var expectedRow = row
-        while (true) {
-          row++
-          val nextPath = tree.getPathForRow(row) ?: break
-          val pathCount = nextPath.pathCount
-          if (pathCount == currentPathCount) expectedRow = row
-          if (pathCount < currentPathCount) break
-        }
-        tree.setSelectionRow(expectedRow)
-
-        tree.scrollRowToVisible(expectedRow)
-      },
-    )
-    registerCommand(
-      "NERDTreeMapJumpNextSibling",
-      "<C-J>",
-      NerdAction.ToIj("Tree-selectNextSibling"),
-    )
-    registerCommand(
-      "NERDTreeMapJumpPrevSibling",
-      "<C-K>",
-      NerdAction.ToIj("Tree-selectPreviousSibling"),
-    )
-    registerCommand(
-      "NERDTreeMapRefresh",
-      "r",
-      NerdAction.ToIj("SynchronizeCurrentFile"),
-    )
-    registerCommand("NERDTreeMapToggleHidden", "I", NerdAction.ToIj("ProjectView.ShowExcludedFiles"))
-    registerCommand("NERDTreeMapNewFile", "n", NerdAction.ToIj("NewFile"))
-    registerCommand("NERDTreeMapNewDir", "N", NerdAction.ToIj("NewDir"))
-    registerCommand("NERDTreeMapDelete", "d", NerdAction.ToIj("\$Delete"))
-    registerCommand("NERDTreeMapCopy", "y", NerdAction.ToIj("\$Copy"))
-    registerCommand("NERDTreeMapPaste", "v", NerdAction.ToIj("\$Paste"))
-    registerCommand("NERDTreeMapRename", "<C-r>", NerdAction.ToIj("RenameElement"))
-    registerCommand("NERDTreeMapRefreshRoot", "R", NerdAction.ToIj("Synchronize"))
-    registerCommand("NERDTreeMapMenu", "m", NerdAction.ToIj("ShowPopupMenu"))
-    registerCommand("NERDTreeMapQuit", "q", NerdAction.ToIj("HideActiveWindow"))
-    registerCommand(
-      "NERDTreeMapToggleZoom",
-      "A",
-      NerdAction.ToIj("MaximizeToolWindow"),
-    )
-
-    registerCommand(
-      "/",
-      NerdAction.Code { project, _, _ ->
-        NerdDispatcher.getInstance(project).waitForSearch = true
-      },
-    )
-
-    registerCommand(
-      "<ESC>",
-      NerdAction.Code { project, _, _ ->
-        val instance = NerdDispatcher.getInstance(project)
-        if (instance.waitForSearch) {
-          instance.waitForSearch = false
-        }
-      },
-    )
-  }
-
-  object Util {
-    internal val monitor = Any()
-    internal var commandsRegistered = false
-    fun callAction(editor: VimEditor?, name: String, context: ExecutionContext) {
-      val action = ActionManager.getInstance().getAction(name) ?: run {
-        VimPlugin.showMessage(MessageHelper.message("action.not.found.0", name))
-        return
-      }
-      val application = ApplicationManager.getApplication()
-      if (application.isUnitTestMode) {
-        injector.actionExecutor.executeAction(editor, action.vim, context)
-      } else {
-        runAfterGotFocus {
-          injector.actionExecutor.executeAction(editor, action.vim, context)
-        }
+        return project.service<NerdDispatcher>()
       }
     }
   }
 
   companion object {
-    const val pluginName = "NERDTree"
-    private val LOG = logger<NerdTree>()
+    const val PLUGIN_NAME = "NERDTree"
+    private val LOG = vimLogger<NerdTree>()
   }
 }
 
-private fun addCommand(alias: String, handler: CommandAliasHandler) {
-  VimPlugin.getCommand().setAlias(alias, CommandAlias.Call(0, -1, alias, handler))
-}
+private fun createMappings(): Map<List<KeyStroke>, NerdTreeAction> = navigationMappings.toMutableMap().apply {
+  register(
+    "NERDTreeMapActivateNode",
+    "o",
+    NerdTreeAction { event, tree ->
+      val array = CommonDataKeys.NAVIGATABLE_ARRAY.getData(event.dataContext)?.filter { it.canNavigateToSource() }
+      if (array.isNullOrEmpty()) {
+        val row = tree.selectionRows?.getOrNull(0) ?: return@NerdTreeAction
+        if (tree.isExpanded(row)) {
+          tree.collapseRow(row)
+        } else {
+          tree.expandRow(row)
+        }
+      } else {
+        array.forEach { it.navigate(true) }
+      }
+    },
+  )
+  register(
+    "NERDTreeMapPreview",
+    "go",
+    NerdTreeAction { event, _ ->
+      CommonDataKeys.NAVIGATABLE_ARRAY.getData(event.dataContext)?.filter { it.canNavigateToSource() }
+        ?.forEach { it.navigate(false) }
+    },
+  )
+  register(
+    "NERDTreeMapOpenInTab",
+    "t",
+    NerdTreeAction { event, _ ->
+      // FIXME: 22.01.2021 Doesn't work correct
+      CommonDataKeys.NAVIGATABLE_ARRAY.getData(event.dataContext)?.filter { it.canNavigateToSource() }
+        ?.forEach { it.navigate(true) }
+    },
+  )
+  register(
+    "NERDTreeMapOpenInTabSilent",
+    "T",
+    NerdTreeAction { event, _ ->
+      // FIXME: 22.01.2021 Doesn't work correct
+      CommonDataKeys.NAVIGATABLE_ARRAY.getData(event.dataContext)?.filter { it.canNavigateToSource() }
+        ?.forEach { it.navigate(true) }
+    },
+  )
 
-private fun registerCommand(variable: String, defaultMapping: String, action: NerdAction) {
-  val variableValue = VimPlugin.getVariableService().getGlobalVariableValue(variable)
-  val mapping = if (variableValue is VimString) {
-    variableValue.value
-  } else {
-    defaultMapping
-  }
-  registerCommand(mapping, action)
-}
+  // TODO: 21.01.2021 Should option in left split
+  register("NERDTreeMapOpenVSplit", "s", NerdTreeAction.ij("OpenInRightSplit"))
+  // TODO: 21.01.2021 Should option in above split
+  register(
+    "NERDTreeMapOpenSplit",
+    "i",
+    NerdTreeAction { event, _ ->
+      val file = event.getData(CommonDataKeys.VIRTUAL_FILE) ?: return@NerdTreeAction
+      if (file.isDirectory) return@NerdTreeAction
+      val currentWindow = getSplittersCurrentWindow(event)
+      currentWindow?.split(SwingConstants.HORIZONTAL, true, file, true)
+    },
+  )
+  register(
+    "NERDTreeMapPreviewVSplit",
+    "gs",
+    NerdTreeAction { event, _ ->
+      val file = event.getData(CommonDataKeys.VIRTUAL_FILE) ?: return@NerdTreeAction
+      val currentWindow = getSplittersCurrentWindow(event)
+      currentWindow?.split(SwingConstants.VERTICAL, true, file, true)
 
-private fun registerCommand(mapping: String, action: NerdAction) {
-  actionsRoot.add(mapping, action)
-  injector.parser.parseKeys(mapping).forEach {
-    distinctShortcuts.add(it)
-  }
-}
+      // FIXME: 22.01.2021 This solution bouncing a bit
+      NerdTreeAction.callAction(null, "ActivateProjectToolWindow", event.dataContext.vim)
+    },
+  )
+  register(
+    "NERDTreeMapPreviewSplit",
+    "gi",
+    NerdTreeAction { event, _ ->
+      val file = event.getData(CommonDataKeys.VIRTUAL_FILE) ?: return@NerdTreeAction
+      val currentWindow = getSplittersCurrentWindow(event)
+      currentWindow?.split(SwingConstants.HORIZONTAL, true, file, true)
 
-private val actionsRoot: KeyStrokeTrie<NerdAction> = KeyStrokeTrie<NerdAction>("NERDTree")
-private val distinctShortcuts = mutableSetOf<KeyStroke>()
-
-private fun installDispatcher(project: Project) {
-  val dispatcher = NerdTree.NerdDispatcher.getInstance(project)
-  val shortcuts = distinctShortcuts.map { RequiredShortcut(it, MappingOwner.Plugin.get(NerdTree.pluginName)) }
-  dispatcher.registerCustomShortcutSet(
-    KeyGroup.toShortcutSet(shortcuts),
-    (ProjectView.getInstance(project) as ProjectViewImpl).component,
+      NerdTreeAction.callAction(null, "ActivateProjectToolWindow", event.dataContext.vim)
+    },
+  )
+  register(
+    "NERDTreeMapRefresh",
+    "r",
+    NerdTreeAction.ij("SynchronizeCurrentFile"),
+  )
+  register("NERDTreeMapToggleHidden", "I", NerdTreeAction.ij("ProjectView.ShowExcludedFiles"))
+  register("NERDTreeMapNewFile", "n", NerdTreeAction.ij("NewFile"))
+  register("NERDTreeMapNewDir", "N", NerdTreeAction.ij("NewDir"))
+  register("NERDTreeMapDelete", "d", NerdTreeAction.ij($$"$Delete"))
+  register("NERDTreeMapCopy", "y", NerdTreeAction.ij($$"$Copy"))
+  register("NERDTreeMapPaste", "v", NerdTreeAction.ij($$"$Paste"))
+  register("NERDTreeMapRename", "<C-r>", NerdTreeAction.ij("RenameElement"))
+  register("NERDTreeMapRefreshRoot", "R", NerdTreeAction.ij("Synchronize"))
+  register("NERDTreeMapMenu", "m", NerdTreeAction.ij("ShowPopupMenu"))
+  register("NERDTreeMapQuit", "q", NerdTreeAction.ij("HideActiveWindow"))
+  register(
+    "NERDTreeMapToggleZoom",
+    "A",
+    NerdTreeAction.ij("MaximizeToolWindow"),
   )
 }
+
+private fun getSplittersCurrentWindow(event: AnActionEvent): EditorWindow? {
+  val splitters = FileEditorManagerEx.getInstanceEx(event.project ?: return null).splitters
+  return splitters.currentWindow
+}
+
+private val lock = ReentrantReadWriteLock()
+private var enabled = false
+
+private fun installDispatcher(project: Project) {
+  lock.read {
+    if (!enabled) return
+    val dispatcher = NerdTree.NerdDispatcher.getInstance(project)
+    dispatcher.register((ProjectView.getInstance(project) as ProjectViewImpl).component)
+  }
+}

src/main/java/com/maddyhome/idea/vim/extension/nerdtree/NerdTreeAction.kt

@@ -0,0 +1,51 @@
+/*
+ * 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.extension.nerdtree
+
+import com.intellij.openapi.actionSystem.ActionManager
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.ui.treeStructure.Tree
+import com.maddyhome.idea.vim.VimPlugin
+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.helper.MessageHelper
+import com.maddyhome.idea.vim.helper.runAfterGotFocus
+import com.maddyhome.idea.vim.newapi.vim
+
+/**
+ * Defines the actual behavior of actions in NERDTree
+ */
+class NerdTreeAction(val action: (AnActionEvent, Tree) -> Unit) {
+  companion object {
+    fun callAction(editor: VimEditor?, name: String, context: ExecutionContext) {
+      val action = ActionManager.getInstance().getAction(name) ?: run {
+        VimPlugin.showMessage(MessageHelper.message("nerdtree.error.action.not.found", name))
+        return
+      }
+      val application = ApplicationManager.getApplication()
+      if (application.isUnitTestMode) {
+        injector.actionExecutor.executeAction(editor, action.vim, context)
+      } else {
+        runAfterGotFocus {
+          injector.actionExecutor.executeAction(editor, action.vim, context)
+        }
+      }
+    }
+
+    /**
+     * Creates an [NerdTreeAction] that executes an IntelliJ action identified by its ID.
+     *
+     * @param id A string representing the ID of the action to execute.
+     * @return An [NerdTreeAction] that runs the specified action when triggered.
+     */
+    fun ij(id: String) = NerdTreeAction { event, _ -> callAction(null, id, event.dataContext.vim) }
+  }
+}

src/main/java/com/maddyhome/idea/vim/extension/nerdtree/NerdTreeEverywhere.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.extension.nerdtree
+
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.components.service
+import com.intellij.ui.treeStructure.Tree
+import com.maddyhome.idea.vim.extension.VimExtension
+import java.awt.KeyboardFocusManager
+import java.awt.event.ActionEvent
+import java.awt.event.KeyEvent
+import java.beans.PropertyChangeListener
+import javax.swing.KeyStroke
+
+/**
+ * This plugin extends NERDTree support to components other than the Project Tool Window.
+ *
+ * TODO:
+ * It should be considered a "sub-plugin" of NERDTree and cannot be enabled independently,
+ * i.e., should not function after the NERDTree plugin is turned off.
+ */
+internal class NerdTreeEverywhere : VimExtension {
+  companion object {
+    const val PLUGIN_NAME = "NERDTreeEverywhere" // This is a temporary name
+  }
+
+  override fun getName() = PLUGIN_NAME
+
+  val focusListener = PropertyChangeListener { evt ->
+    val newFocusOwner = evt.newValue
+    val oldFocusOwner = evt.oldValue
+    val dispatcher = service<Dispatcher>()
+    if (newFocusOwner is Tree) {
+      // It's okay to have `register` called multiple times, as its internal implementation prevents duplicate registrations
+      dispatcher.register(newFocusOwner)
+    }
+    // Unregistration of the shortcut is required to make the plugin disposable
+    if (oldFocusOwner is Tree) {
+      dispatcher.unregisterCustomShortcutSet(oldFocusOwner)
+    }
+  }
+
+  override fun init() {
+    KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener("focusOwner", focusListener)
+  }
+
+  @Service
+  class Dispatcher : AbstractDispatcher(PLUGIN_NAME, navigationMappings.toMutableMap().apply {
+    register("NERDTreeMapActivateNode", "o", NerdTreeAction { _, tree ->
+      // TODO a more reliable way of invocation (such as double-clicking?)
+      val listener = tree.getActionForKeyStroke(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0))
+      listener.actionPerformed(ActionEvent(tree, ActionEvent.ACTION_PERFORMED, null))
+    })
+  }) {
+    init {
+      templatePresentation.isEnabledInModalContext = true
+    }
+  }
+
+  override fun dispose() {
+    KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener("focusOwner", focusListener)
+    super.dispose()
+  }
+}