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"
+    }
+  }
+}

.gitattributes

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

.github/workflows/checkNewPlugins.yml

@@ -20,10 +20,10 @@ jobs:
       - name: Fetch origin repo
         uses: actions/checkout@v3
 
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'adopt'
           server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
           settings-path: ${{ github.workspace }} # location for the settings.xml file

.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/closeYoutrackOnCommit.yml

@@ -7,6 +7,9 @@ on:
   workflow_dispatch:
   push:
     branches: [ master ]
+    
+permissions:
+  contents: write
 
 jobs:
   build:
@@ -20,10 +23,10 @@ jobs:
           fetch-depth: 300
       - name: Get tags
         run: git fetch --tags origin
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'adopt'
           server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
           settings-path: ${{ github.workspace }} # location for the settings.xml file

.github/workflows/codeql-analysis.yml

@@ -20,6 +20,11 @@ on:
   schedule:
     - cron: '44 12 * * 4'
 
+permissions:
+  actions: read
+  contents: read
+  security-events: write
+
 jobs:
   analyze:
     name: Analyze
@@ -34,12 +39,18 @@ jobs:
         # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
 
     steps:
+    - name: Setup Java
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'temurin' # See 'Supported distributions' for available options
+        java-version: '21'
+
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -50,7 +61,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
+      uses: github/codeql-action/autobuild@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -64,4 +75,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v3

.github/workflows/integrationsTest.yml

@@ -18,16 +18,16 @@ jobs:
       - uses: actions/checkout@v2
         with:
           fetch-depth: 300
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'adopt'
           server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
           settings-path: ${{ github.workspace }} # location for the settings.xml file
 
       - name: Run tests
-        run: ./gradlew integrationsTest
+        run: ./gradlew --no-configuration-cache integrationsTest
         env:
           YOUTRACK_TOKEN: ${{ secrets.YOUTRACK_TOKEN }}
           GITHUB_OAUTH: ${{ secrets.GITHUB_TOKEN }}

.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/kover.yml

@@ -18,10 +18,10 @@ jobs:
       - uses: actions/checkout@v2
         with:
           fetch-depth: 300
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'adopt'
           server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
           settings-path: ${{ github.workspace }} # location for the settings.xml file

.github/workflows/mergePr.yml

@@ -20,10 +20,10 @@ jobs:
           fetch-depth: 50
           # See end of file updateChangeslog.yml for explanation of this secret
           ssh-key: ${{ secrets.PUSH_TO_PROTECTED_BRANCH_SECRET }}
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'adopt'
           server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
           settings-path: ${{ github.workspace }} # location for the settings.xml file

.github/workflows/runUiOctopusTests.yml

@@ -13,17 +13,17 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: zulu
-          java-version: 17
+          java-version: 21
       - name: Setup FFmpeg
         run: brew install ffmpeg
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
+#      - name: Setup Gradle
+#        uses: gradle/gradle-build-action@v2.4.2
       - name: Build Plugin
         run: gradle :buildPlugin
       - name: Run Idea
         run: |
           mkdir -p build/reports
-          gradle testIdeUi -Doctopus.handler=false > build/reports/idea.log &
+          gradle --no-configuration-cache runIdeForUiTests -Doctopus.handler=false > build/reports/idea.log &
       - name: Wait for Idea started
         uses: jtalk/url-health-check-action@v3
         with:
@@ -37,7 +37,7 @@ jobs:
         run: mv tests/ui-ij-tests/video build/reports
       - name: Move sandbox logs
         if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
+        run: mv build/idea-sandbox/IC-*/log_runIdeForUiTests idea-sandbox-log
       - name: Save report
         if: always()
         uses: actions/upload-artifact@v4
@@ -46,7 +46,7 @@ jobs:
           path: |
             build/reports
             tests/ui-ij-tests/build/reports
-            sandbox-idea-log
+            idea-sandbox-log
 #  build-for-ui-test-linux:
 #    runs-on: ubuntu-latest
 #    steps:
@@ -63,7 +63,7 @@ jobs:
 #          export DISPLAY=:99.0
 #          Xvfb -ac :99 -screen 0 1920x1080x16 &
 #          mkdir -p build/reports
-#          gradle :testIdeUi #> build/reports/idea.log
+#          gradle :runIdeForUiTests #> build/reports/idea.log
 #      - name: Wait for Idea started
 #        uses: jtalk/url-health-check-action@1.5
 #        with:

.github/workflows/runUiPyTests.yml

@@ -13,20 +13,20 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: zulu
-          java-version: 17
+          java-version: 21
       - uses: actions/setup-python@v5
         with:
           python-version: '3.10'
       - name: Setup FFmpeg
         run: brew install ffmpeg
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
+#      - name: Setup Gradle
+#        uses: gradle/gradle-build-action@v2.4.2
       - name: Build Plugin
         run: gradle :buildPlugin
       - name: Run Idea
         run: |
           mkdir -p build/reports
-          gradle :testIdeUi -PideaType=PC > build/reports/idea.log &
+          gradle --no-configuration-cache :runIdeForUiTests -PideaType=PC > build/reports/idea.log &
       - name: Wait for Idea started
         uses: jtalk/url-health-check-action@v3
         with:
@@ -40,7 +40,7 @@ jobs:
         run: mv tests/ui-py-tests/video build/reports
       - name: Move sandbox logs
         if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
+        run: mv build/idea-sandbox/PC-*/log_runIdeForUiTests idea-sandbox-log
       - name: Save report
         if: always()
         uses: actions/upload-artifact@v4
@@ -49,4 +49,4 @@ jobs:
           path: |
             build/reports
             tests/ui-py-tests/build/reports
-            sandbox-idea-log
+            idea-sandbox-log

.github/workflows/runUiRdTests.yml

@@ -0,0 +1,51 @@
+name: Run UI Rider Tests
+on:
+  workflow_dispatch:
+  schedule:
+      - cron: '0 12 * * *'
+jobs:
+  build-for-ui-test-mac-os:
+    if: github.repository == 'JetBrains/ideavim'
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: zulu
+          java-version: 21
+      - name: Setup FFmpeg
+        run: brew install ffmpeg
+#      - name: Setup Gradle
+#        uses: gradle/gradle-build-action@v2.4.2
+      - name: Build Plugin
+        run: gradle :buildPlugin
+      - name: Run Idea
+        run: |
+          mkdir -p build/reports
+          gradle --no-configuration-cache :runIdeForUiTests -PideaType=RD > build/reports/idea.log &
+      - name: Wait for Idea started
+        uses: jtalk/url-health-check-action@v3
+        with:
+          url: http://127.0.0.1:8082
+          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
+      - name: Move sandbox logs
+        if: always()
+        run: mv build/idea-sandbox/RD-*/log_runIdeForUiTests idea-sandbox-log
+      - name: Save report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: ui-test-fails-report-mac
+          path: |
+            build/reports
+            tests/ui-rd-tests/build/reports
+            idea-sandbox-log

.github/workflows/runUiTests.yml

@@ -13,17 +13,17 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: zulu
-          java-version: 17
+          java-version: 21
       - name: Setup FFmpeg
         run: brew install ffmpeg
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
+#      - name: Setup Gradle
+#        uses: gradle/gradle-build-action@v2.4.2
       - name: Build Plugin
         run: gradle :buildPlugin
       - name: Run Idea
         run: |
           mkdir -p build/reports
-          gradle testIdeUi > build/reports/idea.log &
+          gradle --no-configuration-cache runIdeForUiTests > build/reports/idea.log &
       - name: Wait for Idea started
         uses: jtalk/url-health-check-action@v3
         with:
@@ -37,7 +37,7 @@ jobs:
         run: mv tests/ui-ij-tests/video build/reports
       - name: Move sandbox logs
         if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
+        run: mv build/idea-sandbox/IC-*/log_runIdeForUiTests idea-sandbox-log
       - name: Save report
         if: always()
         uses: actions/upload-artifact@v4
@@ -46,7 +46,7 @@ jobs:
           path: |
             build/reports
             tests/ui-ij-tests/build/reports
-            sandbox-idea-log
+            idea-sandbox-log
 #  build-for-ui-test-linux:
 #    runs-on: ubuntu-latest
 #    steps:
@@ -63,7 +63,7 @@ jobs:
 #          export DISPLAY=:99.0
 #          Xvfb -ac :99 -screen 0 1920x1080x16 &
 #          mkdir -p build/reports
-#          gradle :testIdeUi #> build/reports/idea.log
+#          gradle :runIdeForUiTests #> build/reports/idea.log
 #      - name: Wait for Idea started
 #        uses: jtalk/url-health-check-action@1.5
 #        with:

.github/workflows/syncDoc.yml

@@ -10,6 +10,9 @@ on:
   push:
     branches: [ master ]
 
+permissions:
+  contents: write
+
 jobs:
   build:
 
@@ -34,6 +37,17 @@ jobs:
         id: update_authors
         run: cp -a origin/doc/. docs
 
+      # The Wiki for github should have no `.md` in references
+      # Otherwise, such links will lead to the raw text.
+      # However, the `.md` should exist to have a navigation in GitHub code.
+      - name: Replace `.md)` with `)`
+        run: |
+          # Define the directory you want to process
+          DIRECTORY="docs"
+
+          # Find all files in the directory and perform the replacement
+          find $DIRECTORY -type f -exec sed -i 's/\.md)/)/g' {} +
+
       - name: Commit changes
         uses: stefanzweifel/git-auto-commit-action@v4
         with:

.github/workflows/updateAuthors.yml

@@ -25,10 +25,10 @@ jobs:
           ssh-key: ${{ secrets.PUSH_TO_PROTECTED_BRANCH_SECRET }}
       - name: Get tags
         run: git fetch --tags origin
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'adopt'
           server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
           settings-path: ${{ github.workspace }} # location for the settings.xml file

.github/workflows/updateChangelog.yml

@@ -22,10 +22,10 @@ jobs:
           ssh-key: ${{ secrets.PUSH_TO_PROTECTED_BRANCH_SECRET }}
       - name: Get tags
         run: git fetch --tags origin
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'adopt'
           server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
           settings-path: ${{ github.workspace }} # location for the settings.xml file

.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/updateFormatting.yml

@@ -20,10 +20,10 @@ jobs:
           fetch-depth: 50
           # See end of file updateChangeslog.yml for explanation of this secret
           ssh-key: ${{ secrets.PUSH_TO_PROTECTED_BRANCH_SECRET }}
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '21'
           distribution: 'adopt'
           server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
           settings-path: ${{ github.workspace }} # location for the settings.xml file

.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
@@ -13,6 +14,7 @@
 !/.idea/vcs.xml
 !/.idea/misc.xml
 !/.idea/.name
+!/.idea/gradle.xml
 
 **/build/
 **/out/
@@ -27,9 +29,10 @@
 # Generated by gradle task "generateGrammarSource"
 vim-engine/src/main/java/com/maddyhome/idea/vim/parser/generated
 vim-engine/src/main/java/com/maddyhome/idea/vim/regexp/parser/generated
-# Generated JSONs for lazy classloading
-/vim-engine/src/main/resources/ksp-generated
-/src/main/resources/ksp-generated
 
 # Created by github automation
 settings.xml
+
+.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

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="modules">
+          <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" />
+            <option value="$PROJECT_DIR$/tests/long-running-tests" />
+            <option value="$PROJECT_DIR$/tests/property-tests" />
+            <option value="$PROJECT_DIR$/tests/ui-fixtures" />
+            <option value="$PROJECT_DIR$/tests/ui-ij-tests" />
+            <option value="$PROJECT_DIR$/tests/ui-py-tests" />
+            <option value="$PROJECT_DIR$/tests/ui-rd-tests" />
+            <option value="$PROJECT_DIR$/vim-engine" />
+          </set>
+        </option>
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

.idea/misc.xml

@@ -18,5 +18,5 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="corretto-17" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="corretto-21" project-jdk-type="JavaSDK" />
 </project>

.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,13 +5,11 @@ object Constants {
   const val EAP_CHANNEL = "eap"
   const val DEV_CHANNEL = "Dev"
 
-  const val GITHUB_TESTS = "2024.1.1"
-  const val NVIM_TESTS = "2024.1.1"
-  const val PROPERTY_TESTS = "2024.1.1"
-  const val LONG_RUNNING_TESTS = "2024.1.1"
-  const val QODANA_TESTS = "2024.1.1"
-  const val RELEASE = "2024.1.1"
+  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.1.1"
-  const val RELEASE_EAP = "2024.1.1"
+  const val RELEASE_DEV = "2025.1"
+  const val RELEASE_EAP = "2025.1"
 }

.teamcity/_Self/Project.kt

@@ -5,10 +5,8 @@ import _Self.buildTypes.LongRunning
 import _Self.buildTypes.Nvim
 import _Self.buildTypes.PluginVerifier
 import _Self.buildTypes.PropertyBased
-import _Self.buildTypes.Qodana
 import _Self.buildTypes.TestingBuildType
 import _Self.subprojects.GitHub
-import _Self.subprojects.OldTests
 import _Self.subprojects.Releases
 import _Self.vcsRoots.GitHubPullRequest
 import _Self.vcsRoots.ReleasesVcsRoot
@@ -18,15 +16,16 @@ import jetbrains.buildServer.configs.kotlin.v2019_2.Project
 object Project : Project({
   description = "Vim engine for JetBrains IDEs"
 
-  subProjects(Releases, OldTests, GitHub)
+  subProjects(Releases, GitHub)
 
   // VCS roots
   vcsRoot(GitHubPullRequest)
   vcsRoot(ReleasesVcsRoot)
 
   // Active tests
-  buildType(TestingBuildType("Latest EAP", "<default>", version = "LATEST-EAP-SNAPSHOT"))
-  buildType(TestingBuildType("2024.1.1", "<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)
@@ -35,14 +34,15 @@ object Project : Project({
   buildType(Nvim)
   buildType(PluginVerifier)
   buildType(Compatibility)
-
-  buildType(Qodana)
 })
 
 // Common build type for all configurations
 abstract class IdeaVimBuildType(init: BuildType.() -> Unit) : BuildType({
   artifactRules = """
         +:build/reports => build/reports
+        +:tests/java-tests/build/reports => java-tests/build/reports
+        +:tests/long-running-tests/build/reports => long-running-tests/build/reports
+        +:tests/property-tests/build/reports => property-tests/build/reports
         +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
     """.trimIndent()
 
@@ -52,7 +52,7 @@ abstract class IdeaVimBuildType(init: BuildType.() -> Unit) : BuildType({
     // These requirements define Linux-Medium configuration.
     // Unfortunately, requirement by name (teamcity.agent.name) doesn't work
     //   IDK the reason for it, but on our agents this property is empty
-    equals("teamcity.agent.hardware.cpuCount", "4")
+    equals("teamcity.agent.hardware.cpuCount", "16")
     equals("teamcity.agent.os.family", "Linux")
   }
 

.teamcity/_Self/buildTypes/Compatibility.kt

@@ -20,7 +20,7 @@ object Compatibility : IdeaVimBuildType({
       name = "Load Verifier"
       scriptContent = """
         mkdir verifier1
-        curl -f -L -o verifier1/verifier-cli-dev-all-1.jar "https://packages.jetbrains.team/files/p/ideavim/plugin-verifier/verifier-cli-dev-all-1.jar"
+        curl -f -L -o verifier1/verifier-cli-dev-all-2.jar "https://packages.jetbrains.team/files/p/ideavim/plugin-verifier/verifier-cli-dev-all-2.jar"
       """.trimIndent()
     }
     script {
@@ -33,13 +33,22 @@ object Compatibility : IdeaVimBuildType({
               # Upload verifier-cli-dev-all.jar artifact to the repo in IdeaVim space repo
               
               java --version
-              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}org.jetbrains.IdeaVim-EasyMotion' [latest-IU] -team-city
-              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}eu.theblob42.idea.whichkey' [latest-IU] -team-city
-              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}IdeaVimExtension' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}org.jetbrains.IdeaVim-EasyMotion' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}eu.theblob42.idea.whichkey' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}IdeaVimExtension' [latest-IU] -team-city
               # Outdated java -jar verifier/verifier-cli-dev-all.jar check-plugin '${'$'}github.zgqq.intellij-enhance' [latest-IU] -team-city
-              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.github.copilot' [latest-IU] -team-city
-              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.github.dankinsoid.multicursor' [latest-IU] -team-city
-              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}com.joshestein.ideavim-quickscope' [latest-IU] -team-city
+              # java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.github.copilot' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.github.dankinsoid.multicursor' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-2.jar check-plugin '${'$'}com.joshestein.ideavim-quickscope' [latest-IU] -team-city
+              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/CreateNewReleaseBranchFromMaster.kt

@@ -1,72 +0,0 @@
-/*
- * Copyright 2003-2024 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 _Self.buildTypes
-
-import _Self.IdeaVimBuildType
-import jetbrains.buildServer.configs.kotlin.v2019_2.CheckoutMode
-import jetbrains.buildServer.configs.kotlin.v2019_2.DslContext
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildFeatures.sshAgent
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.script
-
-object CreateNewReleaseBranchFromMaster : IdeaVimBuildType({
-  name = "EXP: Create new release branch from master"
-
-  vcs {
-    root(DslContext.settingsRoot)
-    branchFilter = "+:<default>"
-
-    checkoutMode = CheckoutMode.AUTO
-  }
-
-  steps {
-    script {
-      name = "Calculate next potential release version"
-      scriptContent = """
-        #!/bin/bash
-
-        # Fetch all remote branches
-        git fetch --all
-
-        # Get a list of all branches matching the pattern releases/x.y.z
-        branches=${'$'}(git branch -r | grep -oE 'releases/[0-9]+\.[0-9]+\.x')
-
-        # If no matching branches are found, print a message and exit
-        if [[ -z "${'$'}branches" ]]; then
-            echo "No release branches found"
-            exit 1
-        fi
-
-        # Find the largest release version
-        largest_release=${'$'}(echo "${'$'}branches" | sort -V | tail -n 1)
-
-        # Print the largest release
-        echo "Largest release branch: ${'$'}largest_release"
-        echo "##teamcity[setParameter name='env.POTENTIAL_VERSION' value='${'$'}largest_release']"
-      """.trimIndent()
-    }
-
-    script {
-      name = "Show potential release version"
-      scriptContent = """
-                #!/bin/bash
-                echo "Calculated or user-provided parameter value is: %env.POTENTIAL_VERSION%"
-            """.trimIndent()
-    }
-  }
-
-  params {
-    param("env.POTENTIAL_VERSION", "")
-  }
-
-  features {
-    sshAgent {
-      teamcitySshKey = "IdeaVim ssh keys"
-    }
-  }
-})

.teamcity/_Self/buildTypes/LongRunning.kt

@@ -25,9 +25,10 @@ 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

@@ -18,7 +18,7 @@ object Nvim : IdeaVimBuildType({
     param("env.ORG_GRADLE_PROJECT_downloadIdeaSources", "false")
     param("env.ORG_GRADLE_PROJECT_ideaVersion", NVIM_TESTS)
     param("env.ORG_GRADLE_PROJECT_instrumentPluginCode", "false")
-    param("env.ideavim.nvim.path", "./nvim-linux64/bin/nvim")
+    param("env.ideavim.nvim.path", "./nvim-linux-x86_64/bin/nvim")
   }
 
   vcs {
@@ -32,16 +32,17 @@ object Nvim : IdeaVimBuildType({
     script {
       name = "Set up NeoVim"
       scriptContent = """
-              wget https://github.com/neovim/neovim/releases/download/v0.7.2/nvim-linux64.tar.gz
-              tar xzf nvim-linux64.tar.gz
-              cd nvim-linux64/bin
+              wget https://github.com/neovim/neovim/releases/download/nightly/nvim-linux-x86_64.tar.gz
+              tar xzf nvim-linux-x86_64.tar.gz
+              cd nvim-linux-x86_64/bin
               chmod +x nvim
               """.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/PluginVerifier.kt

@@ -25,6 +25,7 @@ object PluginVerifier : IdeaVimBuildType({
       tasks = "clean verifyPlugin"
       buildFile = ""
       enableStacktrace = true
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
   }
 

.teamcity/_Self/buildTypes/PrintReleaseBranch.kt

@@ -1,42 +0,0 @@
-/*
- * Copyright 2003-2024 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 _Self.buildTypes
-
-import _Self.IdeaVimBuildType
-import _Self.vcsRoots.ReleasesVcsRoot
-import jetbrains.buildServer.configs.kotlin.v2019_2.CheckoutMode
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildFeatures.sshAgent
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.script
-
-object PrintReleaseBranch : IdeaVimBuildType({
-  name = "EXP: Print release branch"
-
-  vcs {
-    root(ReleasesVcsRoot)
-    branchFilter = "+:heads/releases/*"
-
-    checkoutMode = CheckoutMode.AUTO
-  }
-
-  steps {
-
-    script {
-      name = "Print current branch"
-      scriptContent = """
-                echo "Current branch is: %teamcity.build.branch%"
-            """.trimIndent()
-    }
-  }
-
-  features {
-    sshAgent {
-      teamcitySshKey = "IdeaVim ssh keys"
-    }
-  }
-})

.teamcity/_Self/buildTypes/PropertyBased.kt

@@ -24,9 +24,11 @@ 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/PublishVimEngine.kt

@@ -36,6 +36,7 @@ object PublishVimEngine : IdeaVimBuildType({
       tasks = ":vim-engine:publish"
       buildFile = ""
       enableStacktrace = true
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
   }
 

.teamcity/_Self/buildTypes/Qodana.kt

@@ -1,80 +0,0 @@
-package _Self.buildTypes
-
-import _Self.Constants.QODANA_TESTS
-import _Self.IdeaVimBuildType
-import jetbrains.buildServer.configs.kotlin.v2019_2.CheckoutMode
-import jetbrains.buildServer.configs.kotlin.v2019_2.DslContext
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.Qodana
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.gradle
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.qodana
-import jetbrains.buildServer.configs.kotlin.v2019_2.failureConditions.BuildFailureOnMetric
-import jetbrains.buildServer.configs.kotlin.v2019_2.failureConditions.failOnMetricChange
-import jetbrains.buildServer.configs.kotlin.v2019_2.triggers.schedule
-import jetbrains.buildServer.configs.kotlin.v2019_2.triggers.vcs
-
-object Qodana : IdeaVimBuildType({
-  name = "Qodana checks"
-  params {
-    param("env.ORG_GRADLE_PROJECT_downloadIdeaSources", "false")
-    param("env.ORG_GRADLE_PROJECT_ideaVersion", QODANA_TESTS)
-    param("env.ORG_GRADLE_PROJECT_instrumentPluginCode", "false")
-  }
-
-  vcs {
-    root(DslContext.settingsRoot)
-    branchFilter = "+:<default>"
-
-    checkoutMode = CheckoutMode.AUTO
-  }
-
-  steps {
-    gradle {
-      name = "Generate grammar"
-      tasks = "generateGrammarSource"
-    }
-    qodana {
-      name = "Qodana"
-      param("clonefinder-languages", "")
-      param("collect-anonymous-statistics", "")
-      param("licenseaudit-enable", "")
-      param("clonefinder-languages-container", "")
-      param("linterVersion", "")
-      param("clonefinder-queried-project", "")
-      param("clonefinder-enable", "")
-      param("clonefinder-reference-projects", "")
-      linter = jvm {
-        version = Qodana.JVMVersion.LATEST
-      }
-      reportAsTests = true
-      additionalQodanaArguments = "--baseline qodana.sarif.json"
-      cloudToken = "credentialsJSON:6b79412e-9198-4862-9223-c5019488f903"
-    }
-  }
-
-  triggers {
-    vcs {
-      enabled = false
-      branchFilter = "+:<default>"
-    }
-    schedule {
-      schedulingPolicy = daily {
-        hour = 12
-        minute = 0
-        timezone = "SERVER"
-      }
-      param("dayOfWeek", "Sunday")
-    }
-  }
-
-  failureConditions {
-    failOnMetricChange {
-      threshold = 0
-      units = BuildFailureOnMetric.MetricUnit.DEFAULT_UNIT
-      comparison = BuildFailureOnMetric.MetricComparison.MORE
-      compareTo = value()
-      metric = BuildFailureOnMetric.MetricType.TEST_FAILED_COUNT
-      param("metricKey", "QodanaProblemsNew")
-      enabled = false
-    }
-  }
-})

.teamcity/_Self/buildTypes/ReleaseDev.kt

@@ -47,13 +47,16 @@ object ReleaseDev : IdeaVimBuildType({
     gradle {
       name = "Calculate new dev version"
       tasks = "scripts:calculateNewDevVersion"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
     gradle {
       name = "Set TeamCity build number"
       tasks = "scripts:setTeamCityBuildNumber"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
     gradle {
       tasks = "publishPlugin"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
   }
 

.teamcity/_Self/buildTypes/ReleaseEap.kt

@@ -57,18 +57,22 @@ object ReleaseEap : IdeaVimBuildType({
     gradle {
       name = "Calculate new eap version"
       tasks = "scripts:calculateNewEapVersion"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
     gradle {
       name = "Set TeamCity build number"
       tasks = "scripts:setTeamCityBuildNumber"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
     gradle {
       name = "Add release tag"
       tasks = "scripts:addReleaseTag"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
     gradle {
       name = "Publish plugin"
       tasks = "publishPlugin"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
     script {
       name = "Push changes to the repo"
@@ -86,6 +90,7 @@ object ReleaseEap : IdeaVimBuildType({
     gradle {
       name = "YouTrack post release actions"
       tasks = "scripts:eapReleaseActions"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
   }
 

.teamcity/_Self/buildTypes/ReleaseEapFromBranch.kt

@@ -1,106 +0,0 @@
-package _Self.buildTypes
-
-import _Self.Constants.EAP_CHANNEL
-import _Self.Constants.RELEASE_EAP
-import _Self.IdeaVimBuildType
-import _Self.vcsRoots.ReleasesVcsRoot
-import jetbrains.buildServer.configs.kotlin.v2019_2.CheckoutMode
-import jetbrains.buildServer.configs.kotlin.v2019_2.ParameterDisplay
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildFeatures.sshAgent
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.gradle
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.script
-import jetbrains.buildServer.configs.kotlin.v2019_2.failureConditions.BuildFailureOnMetric
-import jetbrains.buildServer.configs.kotlin.v2019_2.failureConditions.failOnMetricChange
-
-object ReleaseEapFromBranch : IdeaVimBuildType({
-  name = "EXP: Publish EAP Build from branch"
-  description = "Build and publish EAP of IdeaVim plugin"
-
-  artifactRules = "build/distributions/*"
-
-  params {
-    param("env.ORG_GRADLE_PROJECT_ideaVersion", RELEASE_EAP)
-    password(
-      "env.ORG_GRADLE_PROJECT_publishToken",
-      "credentialsJSON:61a36031-4da1-4226-a876-b8148bf32bde",
-      label = "Password"
-    )
-    param("env.ORG_GRADLE_PROJECT_publishChannels", EAP_CHANNEL)
-    password(
-      "env.ORG_GRADLE_PROJECT_slackUrl",
-      "credentialsJSON:a8ab8150-e6f8-4eaf-987c-bcd65eac50b5",
-      label = "Slack Token"
-    )
-    password(
-      "env.YOUTRACK_TOKEN",
-      "credentialsJSON:2479995b-7b60-4fbb-b095-f0bafae7f622",
-      display = ParameterDisplay.HIDDEN
-    )
-  }
-
-  vcs {
-    root(ReleasesVcsRoot)
-    branchFilter = """
-      +:heads/(releases/*)
-      """.trimIndent()
-
-    checkoutMode = CheckoutMode.AUTO
-  }
-
-  steps {
-    script {
-      name = "Pull git tags"
-      scriptContent = "git fetch --tags origin"
-    }
-    script {
-      name = "Pull git history"
-      scriptContent = "git fetch --unshallow"
-    }
-    gradle {
-      name = "Calculate new eap version from branch"
-      tasks = "scripts:calculateNewEapVersionFromBranch"
-    }
-    gradle {
-      name = "Set TeamCity build number"
-      tasks = "scripts:setTeamCityBuildNumber"
-    }
-    gradle {
-      name = "Add release tag"
-      tasks = "scripts:addReleaseTag"
-    }
-    gradle {
-      name = "Publish plugin"
-      tasks = "publishPlugin"
-    }
-    script {
-      name = "Push changes to the repo"
-      scriptContent = """
-      branch=$(git branch --show-current)
-      echo current branch is ${'$'}branch
-      git push origin %build.number%
-      """.trimIndent()
-    }
-    gradle {
-      name = "YouTrack post release actions"
-      tasks = "scripts:eapReleaseActions"
-    }
-  }
-
-  features {
-    sshAgent {
-      teamcitySshKey = "IdeaVim ssh keys"
-    }
-  }
-
-  failureConditions {
-    failOnMetricChange {
-      metric = BuildFailureOnMetric.MetricType.ARTIFACT_SIZE
-      threshold = 5
-      units = BuildFailureOnMetric.MetricUnit.PERCENTS
-      comparison = BuildFailureOnMetric.MetricComparison.DIFF
-      compareTo = build {
-        buildRule = lastSuccessful()
-      }
-    }
-  }
-})

.teamcity/_Self/buildTypes/ReleasePlugin.kt

@@ -28,7 +28,10 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
   name = "Publish $releaseType release"
   description = "Build and publish IdeaVim plugin"
 
-  artifactRules = "build/distributions/*"
+  artifactRules = """
+        build/distributions/*
+        build/reports/*
+    """.trimIndent()
 
   params {
     param("env.ORG_GRADLE_PROJECT_ideaVersion", RELEASE)
@@ -90,10 +93,12 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
     gradle {
       name = "Calculate new version"
       tasks = "scripts:calculateNewVersion"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
     gradle {
       name = "Set TeamCity build number"
       tasks = "scripts:setTeamCityBuildNumber"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
 //    gradle {
 //      name = "Update change log"
@@ -106,14 +111,16 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
     gradle {
       name = "Add release tag"
       tasks = "scripts:addReleaseTag"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
     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"
       tasks = "publishPlugin"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
 //    script {
 //      name = "Checkout master branch"
@@ -144,6 +151,8 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
     gradle {
       name = "Run Integrations"
       tasks = "releaseActions"
+      gradleParams = "--no-configuration-cache"
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
 //    gradle {
 //      name = "Slack Notification"

.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,
@@ -39,9 +39,11 @@ open class TestingBuildType(
 
   steps {
     gradle {
-      tasks = "clean test"
+      clearConditions()
+      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

@@ -1,6 +1,5 @@
 package _Self.subprojects
 
-import _Self.Constants
 import _Self.IdeaVimBuildType
 import _Self.vcsRoots.GitHubPullRequest
 import jetbrains.buildServer.configs.kotlin.v2019_2.CheckoutMode
@@ -16,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({
@@ -25,7 +24,6 @@ class GithubBuildType(command: String, desc: String) : IdeaVimBuildType({
 
   params {
     param("env.ORG_GRADLE_PROJECT_downloadIdeaSources", "false")
-    param("env.ORG_GRADLE_PROJECT_ideaVersion", Constants.GITHUB_TESTS)
     param("env.ORG_GRADLE_PROJECT_instrumentPluginCode", "false")
   }
 
@@ -44,6 +42,7 @@ class GithubBuildType(command: String, desc: String) : IdeaVimBuildType({
       tasks = command
       buildFile = ""
       enableStacktrace = true
+      jdkHome = "/usr/lib/jvm/java-21-amazon-corretto"
     }
   }
 

.teamcity/_Self/subprojects/OldTests.kt

@@ -1,25 +0,0 @@
-package _Self.subprojects
-
-import _Self.buildTypes.TestingBuildType
-import jetbrains.buildServer.configs.kotlin.v2019_2.Project
-
-object OldTests : Project({
-  name = "Old IdeaVim tests"
-  description = "Tests for older versions of IJ"
-
-  buildType(TestingBuildType("IC-2018.1", "181-182", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2018.2", "181-182", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2018.3", "183", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2019.1", "191-193", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2019.2", "191-193", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2019.3", "191-193", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2020.1", "201", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2020.2", "202", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2020.3", "203-212", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2021.1", "203-212", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2021.2.2", "203-212", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2021.3.2", "213-221", javaVersion = "1.8", javaPlugin = false))
-  buildType(TestingBuildType("IC-2022.2.3", branch = "222", javaPlugin = false))
-  buildType(TestingBuildType("IC-2023.1", "231-232", javaPlugin = false))
-  buildType(TestingBuildType("IC-2023.2", "231-232", javaPlugin = false))
-})

.teamcity/_Self/subprojects/Releases.kt

@@ -1,11 +1,8 @@
 package _Self.subprojects
 
-import _Self.buildTypes.CreateNewReleaseBranchFromMaster
-import _Self.buildTypes.PrintReleaseBranch
 import _Self.buildTypes.PublishVimEngine
 import _Self.buildTypes.ReleaseDev
 import _Self.buildTypes.ReleaseEap
-import _Self.buildTypes.ReleaseEapFromBranch
 import _Self.buildTypes.ReleaseMajor
 import _Self.buildTypes.ReleaseMinor
 import _Self.buildTypes.ReleasePatch
@@ -41,8 +38,4 @@ object Releases : Project({
   buildType(ReleaseEap)
   buildType(ReleaseDev)
   buildType(PublishVimEngine)
-
-  buildType(CreateNewReleaseBranchFromMaster)
-  buildType(PrintReleaseBranch)
-  buildType(ReleaseEapFromBranch)
 })

.teamcity/patches/buildTypes/IdeaVimTests_Latest_EAP.kts

@@ -1,39 +0,0 @@
-package patches.buildTypes
-
-import jetbrains.buildServer.configs.kotlin.v2019_2.*
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.GradleBuildStep
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.gradle
-import jetbrains.buildServer.configs.kotlin.v2019_2.ui.*
-
-/*
-This patch script was generated by TeamCity on settings change in UI.
-To apply the patch, change the buildType with id = 'IdeaVimTests_Latest_EAP'
-accordingly, and delete the patch script.
-*/
-changeBuildType(RelativeId("IdeaVimTests_Latest_EAP")) {
-    check(artifactRules == """
-        +:build/reports => build/reports
-        +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
-    """.trimIndent()) {
-        "Unexpected option value: artifactRules = $artifactRules"
-    }
-    artifactRules = """
-        +:build/reports => build/reports
-        +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
-        +:tests/java-tests/build/reports => tests/java-tests/build/reports
-    """.trimIndent()
-
-    expectSteps {
-        gradle {
-            tasks = "clean test"
-            buildFile = ""
-            enableStacktrace = true
-        }
-    }
-    steps {
-        update<GradleBuildStep>(0) {
-            clearConditions()
-            jdkHome = "/usr/lib/jvm/java-17-amazon-corretto"
-        }
-    }
-}

.teamcity/patches/buildTypes/ReleaseEapFromBranch.kts

@@ -1,19 +0,0 @@
-package patches.buildTypes
-
-import jetbrains.buildServer.configs.kotlin.v2019_2.*
-import jetbrains.buildServer.configs.kotlin.v2019_2.ui.*
-
-/*
-This patch script was generated by TeamCity on settings change in UI.
-To apply the patch, change the buildType with id = 'ReleaseEapFromBranch'
-accordingly, and delete the patch script.
-*/
-changeBuildType(RelativeId("ReleaseEapFromBranch")) {
-    vcs {
-
-        check(branchFilter == "+:heads/(releases/*)") {
-            "Unexpected option value: branchFilter = $branchFilter"
-        }
-        branchFilter = "heads/releases/*"
-    }
-}

.teamcity/settings.kts

@@ -30,5 +30,5 @@ node (Plugins -> teamcity-configs -> teamcity-configs:generate),
 the 'Debug' option is available in the context menu for the task.
 */
 
-version = "2024.03"
+version = "2024.12"
 project(_Self.Project)

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)
@@ -498,7 +505,7 @@ Contributors:
 * [![icon][mail]](mailto:81118900+lippfi@users.noreply.github.com)
   [![icon][github]](https://github.com/lippfi)
    
-  lippfi, 
+  lippfi
 * [![icon][mail]](mailto:fillipser143@gmail.com)
   [![icon][github]](https://github.com/Parker7123)
    
@@ -514,7 +521,7 @@ Contributors:
 * [![icon][mail]](mailto:77796630+throwaway69420-69420@users.noreply.github.com)
   [![icon][github]](https://github.com/kun-codes)
    
-  Bishwa Saha, 
+  Bishwa Saha
 * [![icon][mail]](mailto:alexfu@fastmail.com)
   [![icon][github]](https://github.com/alexfu)
    
@@ -523,6 +530,114 @@ Contributors:
   [![icon][github]](https://github.com/LazyScaper)
    
   Jake
+* [![icon][mail]](mailto:the1xdeveloper@gmail.com)
+  [![icon][github]](https://github.com/The1xDeveloper)
+   
+  The1xDeveloper
+* [![icon][mail]](mailto:shaunewilliams@gmail.com)
+  [![icon][github]](https://github.com/shaunlebron)
+   
+  shaun
+* [![icon][mail]](mailto:i.i.babko@gmail.com)
+  [![icon][github]](https://github.com/igorbabko)
+   
+  Igor Babko
+* [![icon][mail]](mailto:533601+felixwiemuth@users.noreply.github.com)
+  [![icon][github]](https://github.com/felixwiemuth)
+   
+  Felix Wiemuth
+* [![icon][mail]](mailto:kirill.karnaukhov@jetbrains.com)
+  [![icon][github]](https://github.com/kkarnauk)
+   
+  Kirill Karnaukhov
+* [![icon][mail]](mailto:sander.hestvik@gmail.com)
+  [![icon][github]](https://github.com/SanderHestvik)
+   
+  SanderHestvik
+* [![icon][mail]](mailto:gregory.shrago@jetbrains.com)
+  [![icon][github]](https://github.com/gregsh)
+   
+  Greg Shrago
+* [![icon][mail]](mailto:jphalip@gmail.com)
+  [![icon][github]](https://github.com/jphalip)
+   
+  Julien Phalip
+* [![icon][mail]](mailto:j.trimailovas@gmail.com)
+  [![icon][github]](https://github.com/trimailov)
+   
+  Justas Trimailovas
+* [![icon][mail]](mailto:justast@wix.com)
+  [![icon][github]](https://github.com/justast-wix)
+   
+  Justas Trimailovas
+* [![icon][mail]](mailto:wangxinhe06@gmail.com)
+  [![icon][github]](https://github.com/wxh06)
+   
+  Xinhe Wang
+* [![icon][mail]](mailto:vladimir.parfinenko@jetbrains.com)
+  [![icon][github]](https://github.com/cypok)
+   
+  Vladimir Parfinenko
+* [![icon][mail]](mailto:sdoerner@google.com)
+  [![icon][github]](https://github.com/sdoerner)
+   
+  Sebastian Dörner
+* [![icon][mail]](mailto:ocordova@pulsarml.com)
+  [![icon][github]](https://github.com/oca159)
+   
+  Osvaldo
+* [![icon][mail]](mailto:nath@squareup.com)
+  [![icon][github]](https://github.com/nath)
+   
+  Nath Tumlin
+* [![icon][mail]](mailto:ilya.usov@jetbrains.com)
+  [![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:
 

CHANGES.md

@@ -27,8 +27,8 @@ usual beta standards.
 
 Since version 2.9.0, the changelog can be found on YouTrack
 
-To Be Released: https://youtrack.jetbrains.com/issues/VIM?q=%23%7BReady%20To%20Release%7D%20
-Latest Fixes: https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20sort%20by:%20updated%20
+* [To Be Released](https://youtrack.jetbrains.com/issues/VIM?q=%23%7BReady%20To%20Release%7D%20)
+* [Version Fixes](https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20sort%20by:%20%7BFix%20versions%7D%20asc)
 
 ## 2.9.0, 2024-02-20
 

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

@@ -1,26 +1,50 @@
 [![TeamCity Build][teamcity-build-status-svg]][teamcity-build-status]
 
-IdeaVim is an open source project created by 80+ contributors. Would you like to make it even better? That’s wonderful!
+IdeaVim is an open source project created by 130+ contributors. Would you like to make it even better? That’s wonderful!
 
 This page is created to help you start contributing. And who knows, maybe in a few days this project will be brighter than ever!
 
-:warning: The plugin is currently under a huge refactoring aiming to split into vim-engine and IdeaVim in order to
-support the new [Fleet IDE](https://www.jetbrains.com/fleet/). Please see [Fleet refactoring](#Fleet-refactoring).
+# Awards for Quality Contributions
+
+In February 2025, we’re starting a program to award one-year All Products Pack subscriptions to the implementers of quality contributions to the IdeaVim project. The program will continue for all of 2025 and may be prolonged.
+
+Subscriptions can be awarded for merged pull requests that meet the following requirements:
+
+
+- The change should be non-trivial, though there might be exceptions — for example, where a trivial fix requires a complicated investigation.
+- The change should fully implement a feature or fix the root cause of a bug. Workarounds or hacks are not accepted.
+- If applicable, the change should be properly covered with unit tests.
+- The work should be performed by the contributor, though the IdeaVim team is happy to review it and give feedback.
+- The change should fix an issue or implement a feature filed by another user. If you want to file an issue and provide a solution to it, your request for a license should be explicitly discussed with the IdeaVim team in the ticket comments.
+
+
+We'd like to make sure this award program is helpful and fair. Since we just started it and still fine-tuning the details, the final say on giving licenses remains with the IdeaVim team and the requirements might evolve over time.
+
+
+Also, a few notes:
+
+
+- If you have any doubts about whether your change or fix is eligible for the award, get in touch with us in the comments on YouTrack or in any other way.
+- Please mention this program in the pull request text. This is not an absolute requirement, but it will help ensure we know you would like to be considered for an award, but this is not required.
+- During 2025, a single person may only receive a single subscription. Even if you make multiple contributions, you will not be eligible for multiple awards.
+- Any delays caused by the IdeaVim team will not affect eligibility for an award if the other requirements are met.
+- Draft pull requests will not be reviewed unless explicitly requested.
+- Tickets with the [ideavim-bounty](https://youtrack.jetbrains.com/issues?q=tag:%20%7BIdeaVim-bounty%7D) tag are good candidates for this award.
+
 
 ## Before you begin
 
-- The project is written in Kotlin and Java. Choose whichever language you feel more comfortable with,
-or maybe one that you’d like to get to know better (why not start [learning Kotlin](https://kotlinlang.org/docs/tutorials/) right now?).
+- The project is primarily written in Kotlin with a few Java files. When contributing to the project, use Kotlin unless
+you’re working in areas where Java is explicitly used.
 
 - If you come across some IntelliJ Platform code, these links may prove helpful:
 
-    * [IntelliJ architectural overview](https://www.jetbrains.org/intellij/sdk/docs/platform/fundamentals.html)
-    * [IntelliJ plugin development resources](https://www.jetbrains.org/intellij/sdk/docs/welcome.html)
+    * [IntelliJ Platform SDK](https://plugins.jetbrains.com/docs/intellij/welcome.html)
+    * [IntelliJ architectural overview](https://plugins.jetbrains.com/docs/intellij/fundamentals.html)
+    * [IntelliJ Platform community space](https://platform.jetbrains.com/)
 
 - Having any difficulties?
-Join the brand new
-[![Join the chat at https://gitter.im/JetBrains/ideavim](https://badges.gitter.im/JetBrains/ideavim.svg)](https://gitter.im/JetBrains/ideavim?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-for IdeaVim developers and contributors! 
+Ask any questions in [GitHub discussions](https://github.com/JetBrains/ideavim/discussions) or [IntelliJ Platform community space](https://platform.jetbrains.com/).
 
 OK, ready to do some coding?
 
@@ -41,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.
@@ -54,20 +78,24 @@ 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
 
 If you are looking for:
 
 - Vim commands (`w`, `<C-O>`, `p`, etc.):
-    - Any particular command: `package-info.java`.
+    - Any particular command:
+      - [Commands common for Fleet and IdeaVim](vim-engine/src/main/resources/ksp-generated/engine_commands.json)
+      - [IdeaVim only commands](src/main/resources/ksp-generated/intellij_commands.json)
     - How commands are executed in common: `EditorActionHandlerBase`.
     - Key mapping: `KeyHandler.handleKey()`.
 
 - Ex commands (`:set`, `:s`, `:nohlsearch`):
-    - Any particular ex command: package `com.maddyhome.idea.vim.ex.handler`.
+    - Any particular command:
+        - [Commands common for Fleet and IdeaVim](vim-engine/src/main/resources/ksp-generated/engine_ex_commands.json)
+        - [IdeaVim only commands](src/main/resources/ksp-generated/intellij_ex_commands.json)
     - Vim script grammar: `Vimscript.g4`.
     - Vim script parsing: package `com.maddyhome.idea.vim.vimscript.parser`.
     - Vim script executor: `Executor`.
@@ -78,7 +106,7 @@ If you are looking for:
 
 - Common features:
     - State machine. How every particular keystroke is parsed in IdeaVim: `KeyHandler.handleKey()`.
-    - Options (`incsearch`, `iskeyword`, `relativenumber`): `OptionServiceImpl`.
+    - Options (`incsearch`, `iskeyword`, `relativenumber`): `VimOptionGroup`.
     - Plugin startup: `PluginStartup`.
     - Notifications: `NotificationService`.
     - Status bar icon: `StatusBar.kt`.
@@ -106,7 +134,7 @@ Cras id tellus in ex imperdiet egestas.
 carets, dollar motion, etc.
    
 ##### Neovim
-IdeaVim has an experimental integration with neovim in tests. Tests that are performed with `doTest` also executed in
+IdeaVim has an integration with neovim in tests. Tests that are performed with `doTest` also executed in
 neovim instance, and the state of IdeaVim is asserted to be the same as the state of neovim.
 - Only tests that use `doTest` are checked with neovim.
 - Tests with `@VimBehaviorDiffers` or `@TestWithoutNeovim` annotations don't use neovim.
@@ -132,14 +160,15 @@ We also support proper command mappings (functions are mapped to `<Plug>...`), t
 - Magic is supported as well. See `Magic`.
 
 
-## Fleet refactoring
-At the moment, IdeaVim is under an active refactoring aiming to split IdeaVim into two modules: vim-engine and IdeaVim.
+## Fleet
+
+The IdeaVim plugin is divided into two main modules: IdeaVim and vim-engine.
+IdeaVim serves as a plugin for JetBrains IDEs, while vim-engine is an IntelliJ Platform-independent Vim engine.
+This engine is utilized in both the Vim plugin for Fleet and IdeaVim.
 
 If you develop a plugin that depends on IdeaVim: We have an instrument to check that our changes don't affect
-the plugins in the marketplace. Also, we commit to support currently used API at least till the end of 2022.
+the plugins in the marketplace.
 If you still encounter any issues with the newer versions of IdeaVim, please [contact maintainers](https://github.com/JetBrains/ideavim#contact-maintainers).
-We kindly ask you not to use anything from the new API (like `VimEditor`, `injector`) because at the moment we don't
-guarantee the compatibility of this API in the future versions.
 
 
 -----
@@ -162,6 +191,7 @@ This is just terrible. [You know what to do](https://github.com/JetBrains/ideavi
 
 * [Continuous integration builds](https://ideavim.teamcity.com/)
 * [Bug tracker](https://youtrack.jetbrains.com/issues/VIM)
+* [IntelliJ Platform community space](https://platform.jetbrains.com/)
 * [Chat on gitter](https://gitter.im/JetBrains/ideavim)
 * [IdeaVim Channel](https://jb.gg/bi6zp7) on [JetBrains Server](https://discord.gg/jetbrains)
 * [Plugin homepage](https://plugins.jetbrains.com/plugin/164-ideavim)

README.md

@@ -29,8 +29,8 @@ IdeaVim is a Vim engine for JetBrains IDEs.
 
 #### Compatibility
 
-IntelliJ IDEA, PyCharm, CLion, PhpStorm, WebStorm, RubyMine, AppCode, 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
 ------------
@@ -85,34 +85,16 @@ Here are some examples of supported vim features and commands:
 * Motion / deletion / change / window / etc. commands
 * Key mappings
 * Marks / Macros / Digraphs / Registers
-* Some [set commands](https://github.com/JetBrains/ideavim/wiki/%22set%22-commands)
+* Some [set commands](https://github.com/JetBrains/ideavim/wiki/set-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:
 
-* [The list of all supported commands](src/main/java/com/maddyhome/idea/vim/package-info.java)
 * [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
 -----
@@ -222,13 +204,13 @@ Ex commands or via `:map` command mappings:
     * Execute an action by `{action_id}`. Works from Ex command line.
     * Please don't use `:action` in mappings. Use `<Action>` instead.
 
-### Finding action ids:
+### Finding action IDs:
 
-* IJ provides `IdeaVim: track action Ids` command to show the id of the executed actions.
+* IJ provides `IdeaVim: track action IDs` command to show the id of the executed actions.
   This command can be found in "Search everywhere" (double `shift`).
 
     <details>
-        <summary><strong>"Track action Ids" Details</strong> (click to see)</summary>
+        <summary><strong>"Track action IDs" Details</strong> (click to see)</summary>
         <picture>
             <source media="(prefers-color-scheme: dark)" srcset="assets/readme/track_action_dark.gif">
             <img src="assets/readme/track_action_light.gif" alt="track action ids"/>
@@ -266,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
@@ -310,7 +291,9 @@ endif
 
 The power of contributing drives IdeaVim :muscle:. Even small contributions matter!
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) to start bringing your value to the project.
+See the contribution guide in [CONTRIBUTING.md](CONTRIBUTING.md) to start bringing your value to the project.
+
+😎 In 2025, we launched a rewards program. See the guide for details.
 
 Authors
 -------
@@ -325,11 +308,11 @@ IdeaVim tips and tricks
     - `set ideajoin` to enable join via the IDE. See the [examples](https://jb.gg/f9zji9).
     - Make sure `ideaput` is enabled for `clipboard` to enable native IJ insertion in Vim.
     - Sync IJ bookmarks and IdeaVim global marks: `set ideamarks` (works for marks with capital letters only)
-    - Check out more [ex commands](https://github.com/JetBrains/ideavim/wiki/%22set%22-commands).
+    - Check out more [ex commands](https://github.com/JetBrains/ideavim/wiki/set-commands).
 
 - Use your vim settings with IdeaVim. Put `source ~/.vimrc` in `~/.ideavimrc`.
-- Control the status bar icon via the [`ideastatusicon` option](https://github.com/JetBrains/ideavim/wiki/%22set%22-commands).
-- Not familiar with the default behaviour during a refactoring? See the [`idearefactormode` option](https://github.com/JetBrains/ideavim/wiki/%22set%22-commands).
+- Control the status bar icon via the [`ideastatusicon` option](https://github.com/JetBrains/ideavim/wiki/set-commands).
+- Not familiar with the default behaviour during a refactoring? See the [`idearefactormode` option](https://github.com/JetBrains/ideavim/wiki/set-commands).
 
 Some facts about Vim
 -------
@@ -369,6 +352,14 @@ is the full list of synonyms.
 - Fancy constants for [undolevels](https://vimhelp.org/options.txt.html#%27undolevels%27):
   > The local value is set to -123456 when the global value is to be used.
 
+- Vi (not Vim) is a POSIX standard, and [has a spec](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/vi.html)! Vim is mostly POSIX compliant when Vi compatibility is selected with the `'compatible'` option, but there are still some differences that can be changed with `'copoptions'`. The spec is interesting because it documents the behaviour of different commands in a stricter style than the user documentation, describing the current line and column after the command, for example. [More details can be found by reading `:help posix`](https://vimhelp.org/vi_diff.txt.html#posix).
+
+- The Vim documentation contains many easter eggs. We encounter them occasionally, but GitHub user mikesmithgh has compiled a substantial collection [here](https://github.com/mikesmithgh/vimpromptu).
+  - In addition to `:call err_teapot()`, which returns `E418: I'm a teapot`, there is also `:call err_teapot(1)`, which returns `E503: Coffee is currently not available`. Naturally, this is also supported in IdeaVim.
+
+- Insert mode has all `Ctrl` keys mapped, except `Ctrl-B`. In the documentation, it is marked as **"CTRL-B in Insert
+  mode gone"**. Call `:h i_CTRL-B-gone` in Vim to read why `Ctrl-B` was removed.
+
 License
 -------
 

annotation-processors/build.gradle.kts

@@ -8,7 +8,7 @@
 
 plugins {
   kotlin("jvm")
-  kotlin("plugin.serialization") version "1.9.22"
+  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.0.0-1.0.22")
+  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,13 +31,17 @@ 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 fileContent = json.encodeToString(commands)
+    val filePath = generatedDirPath.resolve(commandsFile)
+    val sortedCommands = commands.sortedWith(compareBy({ it.keys }, { it.`class` }))
+    val fileContent = json.encodeToString(sortedCommands)
     filePath.writeText(fileContent)
 
     return emptyList()

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

@@ -31,13 +31,17 @@ 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 fileContent = json.encodeToString(commandToClass)
+    val filePath = generatedDirPath.resolve(exCommandsFile)
+    val sortedCommandToClass = commandToClass.toList().sortedWith(compareBy({ it.first }, { it.second })).toMap()
+    val fileContent = json.encodeToString(sortedCommandToClass)
     filePath.writeText(fileContent)
 
     return emptyList()

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,13 +31,17 @@ 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 fileContent = json.encodeToString(nameToClass)
+    val filePath = generatedDirPath.resolve(vimscriptFunctionsFile)
+    val sortedNameToClass = nameToClass.toList().sortedWith(compareBy({ it.first }, { it.second })).toMap()
+    val fileContent = json.encodeToString(sortedNameToClass)
     filePath.writeText(fileContent)
 
     return emptyList()

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:1.9.22")
+    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:6.10.0.202406032230-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:2.3.12")
-    classpath("io.ktor:ktor-client-cio:2.3.10")
-    classpath("io.ktor:ktor-client-auth:2.3.12")
-    classpath("io.ktor:ktor-client-content-negotiation:2.3.10")
-    classpath("io.ktor:ktor-serialization-kotlinx-json:2.3.12")
+    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 "1.9.22"
+  kotlin("jvm") version "2.2.0"
   application
   id("java-test-fixtures")
-  id("org.jetbrains.intellij.platform") version "2.0.0-beta8"
-  id("org.jetbrains.changelog") version "2.2.0"
+
+  // NOTE: Unignore "test block comment falls back to line comment when not available" test
+  //   After changing this version. It supposed to work on the next version of the gradle plugin
+  //   Or go report to the devs that this test still fails.
+  id("org.jetbrains.intellij.platform") version "2.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.0"
-  id("com.google.devtools.ksp") version "1.9.22-1.0.17"
+  id("com.dorongold.task-tree") version "4.0.1"
+  id("com.google.devtools.ksp") version "2.2.0-2.0.2"
 }
 
 val moduleSources by configurations.registering
@@ -85,7 +91,6 @@ val ideaVersion: String by project
 val ideaType: String by project
 val instrumentPluginCode: String by project
 val remoteRobotVersion: String by project
-val splitModeVersion: String by project
 
 val publishChannels: String by project
 val publishToken: String by project
@@ -104,34 +109,56 @@ 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:24.1.0")
+  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
+    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)
+    create(ideaType, ideaVersion) { this.useInstaller = useInstaller }
 
     pluginVerifier()
     zipSigner()
-    instrumentationTools()
 
     testFramework(TestFrameworkType.Platform)
     testFramework(TestFrameworkType.JUnit5)
 
     // AceJump is an optional dependency. We use their SessionManager class to check if it's active
-    plugin("AceJump", "3.8.11")
+    plugin("AceJump", "3.8.19")
+    plugin("com.intellij.classic.ui", "251.23774.318")
+
+    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")
@@ -144,14 +171,20 @@ dependencies {
   testFixturesImplementation("org.jetbrains.kotlin:kotlin-test:$kotlinVersion")
 
   // https://mvnrepository.com/artifact/org.mockito.kotlin/mockito-kotlin
-  testImplementation("org.mockito.kotlin:mockito-kotlin:5.3.1")
+  testImplementation("org.mockito.kotlin:mockito-kotlin:6.1.0")
 
-  testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.3")
-  testImplementation("org.junit.jupiter:junit-jupiter-engine:5.10.3")
-  testImplementation("org.junit.jupiter:junit-jupiter-params:5.10.3")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-api:5.10.3")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-engine:5.10.3")
-  testFixturesImplementation("org.junit.jupiter:junit-jupiter-params:5.10.3")
+  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:6.0.0")
+//  testFixturesImplementation("org.junit.vintage:junit-vintage-engine:5.10.3")
 }
 
 configurations {
@@ -160,19 +193,34 @@ configurations {
   }
 }
 
+val currentJavaVersion = javaToolchains.launcherFor {}.get().metadata.languageVersion.toString()
+if (currentJavaVersion != javaVersion) {
+  // NOTE: I made this exception because the default Gradle error message is horrible, noone can understand it.
+  throw RuntimeException(
+    """
+    Incorrect java version used for building.
+    IdeaVim uses java version $javaVersion, but the current java version is $currentJavaVersion.
+    If IntelliJ IDEA is used, change the setting in "Settings | Build, Execution, Deployment | Build Tools | Gradle"
+    If build is run from the terminal, set JAVA_HOME environment variable to the correct java version.
+  """.trimIndent()
+  )
+}
+
 tasks {
   test {
     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)
+
+    // This removes all localization plugins from the test version of IJ.
+    // There is a bug that IJ for tests may be loaded with a different locale and some keys may be missing there,
+    //   what breaks the tests. This usually happens in EAP versions of IJ.
+    classpath -= classpath.filter { it.name.startsWith("localization-") && it.name.endsWith(".jar") }
   }
 
   compileJava {
@@ -185,33 +233,16 @@ 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 = "1.9"
-      freeCompilerArgs = listOf("-Xjvm-default=all-compatibility")
-//            allWarningsAsErrors = true
-    }
-  }
-
-  compileTestKotlin {
-    kotlinOptions {
-      jvmTarget = javaVersion
-      apiVersion = "1.9"
-//            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
   // Note that the version must be greater than the plugin's target version, for obvious reasons
+  // You can also set splitMode and splitModeTarget here to test split mode in a custom IDE
 //  val runIdeCustom by intellijPlatformTesting.runIde.registering {
 //    type = IntelliJPlatformType.Rider
 //    version = "2024.1.2"
@@ -222,26 +253,28 @@ tasks {
 //    localPath = file("/Users/{user}/Applications/WebStorm.app")
 //  }
 
+  val runIdeForUiTests by intellijPlatformTesting.runIde.registering {
+    task {
+      jvmArgumentProviders += CommandLineArgumentProvider {
+        listOf(
+          "-Drobot-server.port=8082",
+          "-Dide.mac.message.dialogs.as.sheets=false",
+          "-Djb.privacy.policy.text=<!--999.999-->",
+          "-Djb.consents.confirmation.enabled=false",
+          "-Dide.show.tips.on.startup.default.value=false",
+          "-Doctopus.handler=" + (System.getProperty("octopus.handler") ?: true),
+        )
+      }
+    }
+
+    plugins {
+      robotServerPlugin(remoteRobotVersion)
+    }
+  }
+
   val runIdeSplitMode by intellijPlatformTesting.runIde.registering {
     splitMode = true
     splitModeTarget = SplitModeAware.SplitModeTarget.FRONTEND
-
-    // Frontend split mode support requires 242+
-    // TODO: Remove this once IdeaVim targets 242, as the task will naturally use the target version to run
-    version.set(splitModeVersion)
-  }
-
-  // Start the default IDE with both IdeaVim and the robot server plugin installed, ready to run a UI test task. The
-  // robot server plugin is automatically added as a dependency to this task, and Gradle will take care of downloading.
-  // Note that the CustomTestIdeUiTask can be used to run tests against a different IDE
-  testIdeUi {
-    systemProperty("robot-server.port", "8082")
-    systemProperty("ide.mac.message.dialogs.as.sheets", "false")
-    systemProperty("jb.privacy.policy.text", "<!--999.999-->")
-    systemProperty("jb.consents.confirmation.enabled", "false")
-    systemProperty("ide.show.tips.on.startup.default.value", "false")
-
-    systemProperty("octopus.handler", System.getProperty("octopus.handler") ?: true)
   }
 
   // Add plugin open API sources to the plugin ZIP
@@ -273,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 {
@@ -288,7 +338,12 @@ intellijPlatform {
   pluginConfiguration {
     name = "IdeaVim"
     changeNotes.set(
-      """<a href="https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20Fix%20versions:%20${version.get()}">Changelog</a>"""
+      """
+        We’ve launched a program to reward quality contributions with a one-year All Products Pack subscription. Learn more at: <a href="https://github.com/JetBrains/ideavim/blob/master/CONTRIBUTING.md">CONTRIBUTING.md</a> .
+        <br/>
+        <br/>
+        <a href="https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20Fix%20versions:%20${version.get()}">Changelog</a>
+        """.trimIndent()
     )
 
     ideaVersion {
@@ -314,7 +369,7 @@ intellijPlatform {
     password.set(providers.environmentVariable("PRIVATE_KEY_PASSWORD"))
   }
 
-  verifyPlugin {
+  pluginVerification {
     teamCityOutputFormat = true
     ides {
       recommended()
@@ -329,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 {
@@ -359,7 +415,7 @@ koverMerged {
 
 // --- Slack notification
 
-tasks.register("slackNotification") {
+tasks.register<Task>("slackNotification") {
   doLast {
     if (version.toString().last() != '0') return@doLast
     if (slackUrl.isBlank()) {
@@ -387,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()
       }
     }
   }
@@ -415,7 +476,7 @@ tasks.register("slackNotification") {
 // }
 
 // --- Update authors
-tasks.register("updateAuthors") {
+tasks.register<Task>("updateAuthors") {
   doLast {
     val uncheckedEmails = setOf(
       "aleksei.plate@jetbrains.com",
@@ -431,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")
@@ -444,13 +505,13 @@ tasks.register("updateMergedPr") {
   }
 }
 
-tasks.register("updateChangelog") {
+tasks.register<Task>("updateChangelog") {
   doLast {
     updateChangelog()
   }
 }
 
-tasks.register("updateYoutrackOnCommit") {
+tasks.register<Task>("updateYoutrackOnCommit") {
   doLast {
     updateYoutrackOnCommit()
   }
@@ -461,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")
@@ -484,7 +546,7 @@ tasks.register("releaseActions") {
   }
 }
 
-tasks.register("integrationsTest") {
+tasks.register<Task>("integrationsTest") {
   group = "other"
   doLast {
     val testTicketId = "VIM-2784"
@@ -533,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 {
@@ -772,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) {
@@ -795,7 +859,7 @@ fun updateAuthors(uncheckedEmails: Set<String>) {
 }
 
 fun List<Author>.toMdString(): String {
-  return this.joinToString {
+  return this.joinToString(separator = "") {
     """
           |
           |* [![icon][mail]](mailto:${it.mail})

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,137 +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)"`
-   
-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>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`

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).

doc/marketplace-plugin-example.md

@@ -5,9 +5,9 @@ Using actions from external plugins is the same, as tracking and reusing any IDE
 1. Install the plugin via Marketplace
 2. Enable action tracking. You can enable it by one of the following ways:
     * Execute `:set trackactionids` ex command or just `:set tai`
-    * Open the "Find actions" window by pressing `Ctrl-Shift-A` and search for "Track Action Ids" to find the toggle that enables and disables action tracking
+    * Open the "Find actions" window by pressing `Ctrl-Shift-A` and search for "Track Action IDs" to find the toggle that enables and disables action tracking
 3. Execute the plugin action the way intended by plugin author "See Edit menu or use ⇧ + ⌥ + U / Shift + Alt + U" or just find the `Toggle Camel Case` action in the "Find actions" window (`Ctrl-Shift-A`). If you action tracking is on, you will see this notification in your right bottom corner:
    
    <img alt="Notification" src="images/action-id-notification.png"/>
 4. Copy the action id from the notification to create the following mapping in your .ideavimrc
-```map <leader>t <Action>(de.netnexus.CamelCasePlugin.ToggleCamelCase)```
+```map <leader>t <Action>(de.netnexus.CamelCasePlugin.ToggleCamelCase)```

doc/posts/Some-Facts-About-Vim.md

@@ -0,0 +1,44 @@
+# Some facts about Vim
+
+Let’s relax and have some fun now! Here are a few things we've found interesting during development
+and would like to share with you.
+
+- There are no such commands as `dd`, `yy`, or `cc`. For example, `dd` is not a separate command for deleting the line,
+  but a `d` command with a `d` motion.  
+  Wait, but there isn't a `d` motion in Vim! That’s right, and that’s why Vim has a dedicated set of commands
+  for which it checks whether the
+  [command equals to motion](https://github.com/vim/vim/blob/759d81549c1340185f0d92524c563bb37697ea88/src/normal.c#L6468)
+  and if so, it executes `_` motion instead.  
+  `_` is an interesting motion that isn't even documented in vi, and it refers to the current line.
+  So, commands like `dd`, `yy`, and similar ones are simply translated to `d_`, `y_`, etc.
+  [Here](https://github.com/vim/vim/blob/759d81549c1340185f0d92524c563bb37697ea88/src/normal.c#L6502)
+  is the source of this knowledge.
+
+- `x`, `D`, and `&` are not separate commands either. They are synonyms of `dl`, `d$`, and `:s\r`, respectively.
+  [Here](https://github.com/vim/vim/blob/759d81549c1340185f0d92524c563bb37697ea88/src/normal.c#L5365)
+  is the full list of synonyms.
+
+- You can read a [post](https://github.com/JetBrains/ideavim/wiki/how-many-modes-does-vim-have) about how modes work in Vim and IdeaVim.
+
+- Have you ever used `U` after `dd`? [Don't even try](https://github.com/vim/vim/blob/759d81549c1340185f0d92524c563bb37697ea88/src/ops.c#L874).
+
+- A lot of variables that refer to visual mode start with two uppercase letters, e.g. `VIsual_active`. [Some examples](https://github.com/vim/vim/blob/master/src/normal.c#L17).
+  As mentioned [here](https://vi.stackexchange.com/a/42885/12441), this was done this way to avoid the clash with X11.
+
+- Other [strange things](https://github.com/vim/vim/blob/759d81549c1340185f0d92524c563bb37697ea88/src/ex_docmd.c#L1845) from vi:
+    * ":3"       jumps to line 3
+    * ":3|..."   prints line 3
+    * ":|"       prints current line
+
+- Vim script doesn't skip white space before comma. `F(a ,b)` => E475.
+
+- Fancy constants for [undolevels](https://vimhelp.org/options.txt.html#%27undolevels%27):
+  > The local value is set to -123456 when the global value is to be used.
+
+- Vi (not Vim) is a POSIX standard, and [has a spec](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/vi.html)! Vim is mostly POSIX compliant when Vi compatibility is selected with the `'compatible'` option, but there are still some differences that can be changed with `'copoptions'`. The spec is interesting because it documents the behaviour of different commands in a stricter style than the user documentation, describing the current line and column after the command, for example. [More details can be found by reading `:help posix`](https://vimhelp.org/vi_diff.txt.html#posix).
+
+- The Vim documentation contains many easter eggs. We encounter them occasionally, but GitHub user mikesmithgh has compiled a substantial collection [here](https://github.com/mikesmithgh/vimpromptu).
+    - In addition to `:call err_teapot()`, which returns `E418: I'm a teapot`, there is also `:call err_teapot(1)`, which returns `E503: Coffee is currently not available`. Naturally, this is also supported in IdeaVim.
+
+- Insert mode has all `Ctrl` keys mapped, except `Ctrl-B`. In the documentation, it is marked as **"CTRL-B in Insert
+  mode gone"**. Call `:h i_CTRL-B-gone` in Vim to read why `Ctrl-B` was removed.

doc/set-commands.md

@@ -8,7 +8,7 @@ Every effort is made to make these options compatible with Vim behaviour.
 However, some differences are inevitable.
 
 ```
-'clipboard'     'cb'    Defines clipboard behavioue
+'clipboard'     'cb'    Defines clipboard behavior
         A comma-separated list of words to control clipboard behaviour:
            unnamed      The clipboard register '*' is used instead of the
                         unnamed register

doc/support-guide.md

@@ -1,7 +1,7 @@
 # Support Guide
 
 This document is created to help our support team.
-It's not intended to be read by the users as it brings to value to them.
+It's not intended to be read by the users as it brings no value to them.
 
 ## Support channels
 
@@ -25,7 +25,7 @@ It's not intended to be read by the users as it brings to value to them.
 IdeaVim has multiple YouTrack statuses, main are:
 
 - Submitted: issue is created by user, but not processed by our team. This is the default status for new tickets.
-- Open: issues is processed by out team, what means that the issues is reproduced and accepted
+- Open: issues is processed by our team, what means that the issues is reproduced and accepted
 - Waiting For Reply: Waiting for further information from the user. These issues are automatically closed if the
      user doesn't reply in 30 days.
 - Ready To Release: Bug is fixed, but not yet released
@@ -35,4 +35,4 @@ IdeaVim has multiple YouTrack statuses, main are:
 # ~.ideavimrc file
 
 `~/.ideavimrc` is the file that is used for IdeaVim configuration. It may affect behaviour of the program,
-so it makes sense to additionally request this file in case the issues can't be reproduced.
+so it makes sense to additionally request this file in case the issues can't be reproduced.

gradle.properties

@@ -16,25 +16,19 @@
 # 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.1.1
+ideaVersion=2025.1
 # Values for type: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#intellij-extension-type
 ideaType=IC
 instrumentPluginCode=true
-version=SNAPSHOT
-javaVersion=17
-remoteRobotVersion=0.11.22
+version=chylex-52
+javaVersion=21
+remoteRobotVersion=0.11.23
 antlrVersion=4.10.1
 
-# [VERSION UPDATE] 2024.2 - remove when IdeaVim targets 2024.2
-# Running IdeaVim in split mode requires 242. Update this version once 242 has been released, and remove it completely
-# when IdeaVim targets 242, at which point runIdeSplitMode will run correctly with the target version.
-# See also runIdeSplitMode
-splitModeVersion=242-EAP-SNAPSHOT
-
 
 # Please don't forget to update kotlin version in buildscript section
 # Also update kotlinxSerializationVersion version
-kotlinVersion=1.9.22
+kotlinVersion=2.2.0
 publishToken=token
 publishChannels=eap
 
@@ -47,7 +41,6 @@ youtrackToken=
 
 # Gradle settings
 org.gradle.jvmargs='-Dfile.encoding=UTF-8'
-org.gradle.configuration-cache=true
 org.gradle.caching=true
 
 # Disable warning from gradle-intellij-plugin. Kotlin stdlib is included as compileOnly, so the warning is unnecessary
@@ -55,3 +48,5 @@ kotlin.stdlib.default.dependency=false
 
 # Disable incremental annotation processing
 ksp.incremental=false
+# KSP2 is used with java 21: https://github.com/google/ksp/issues/740#issuecomment-2313498615
+ksp.useKSP2=true