chore(main): release 11.17.1 (#1927)

🤖 I have created a release *beep* *boop*
---


##
[11.17.1](https://github.com/folke/lazy.nvim/compare/v11.17.0...v11.17.1)
(2025-02-25)


### Bug Fixes

* **bootstrap:** support for older Neovim versions
([1c9ba37](1c9ba37045))
* **meta:** rebuild dirty right after disable. See
[#1889](https://github.com/folke/lazy.nvim/issues/1889)
([d51cf69](d51cf69783))

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.busted

@@ -0,0 +1,11 @@
+return {
+  _all = {
+    coverage = false,
+  },
+  default = {
+    verbose = true,
+  },
+  tests = {
+    verbose = true,
+  },
+}

.editorconfig

@@ -0,0 +1,7 @@
+root = true
+
+[*]
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+charset = utf-8

.github/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "11.17.1"
+}

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -6,7 +6,10 @@ body:
   - type: markdown
     attributes:
       value: |
-        **Before** reporting an issue, make sure to read the [documentation](https://github.com/folke/lazy.nvim) and search [existing issues](https://github.com/folke/lazy.nvim/issues). Usage questions such as ***"How do I...?"*** belong in [Discussions](https://github.com/folke/lazy.nvim/discussions) and will be closed.
+        **Before** reporting an issue, make sure to read the [documentation](https://github.com/folke/lazy.nvim)
+        and search [existing issues](https://github.com/folke/lazy.nvim/issues).
+
+        Usage questions such as ***"How do I...?"*** belong in [Discussions](https://github.com/folke/lazy.nvim/discussions) and will be closed.
   - type: checkboxes
     attributes:
       label: Did you check docs and existing issues?
@@ -14,6 +17,8 @@ body:
       options:
         - label: I have read all the lazy.nvim docs
           required: true
+        - label: I have updated the plugin to the latest version before submitting this issue
+          required: true
         - label: I have searched the existing issues of lazy.nvim
           required: true
         - label: I have searched the existing issues of plugins related to this issue
@@ -57,32 +62,14 @@ body:
       label: Repro
       description: Minimal `init.lua` to reproduce this issue. Save as `repro.lua` and run with `nvim -u repro.lua`
       value: |
-        -- DO NOT change the paths and don't remove the colorscheme
-        local root = vim.fn.fnamemodify("./.repro", ":p")
+        vim.env.LAZY_STDPATH = ".repro"
+        load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))()
 
-        -- set stdpaths to use .repro
-        for _, name in ipairs({ "config", "data", "state", "cache" }) do
-          vim.env[("XDG_%s_HOME"):format(name:upper())] = root .. "/" .. name
-        end
-
-        -- bootstrap lazy
-        local lazypath = root .. "/plugins/lazy.nvim"
-        if not vim.loop.fs_stat(lazypath) then
-          vim.fn.system({ "git", "clone", "--filter=blob:none", "https://github.com/folke/lazy.nvim.git", lazypath, })
-        end
-        vim.opt.runtimepath:prepend(lazypath)
-
-        -- install plugins
-        local plugins = {
-          "folke/tokyonight.nvim",
-          -- add any other plugins here
-        }
-        require("lazy").setup(plugins, {
-          root = root .. "/plugins",
+        require("lazy.minit").repro({
+          spec = {
+            -- add any other plugins here
+          },
         })
-
-        vim.cmd.colorscheme("tokyonight")
-        -- add anything else here
-      render: Lua
+      render: lua
     validations:
       required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Ask a question
+    url: https://github.com/folke/lazy.nvim/discussions
+    about: Use Github discussions instead

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,16 @@
+## Description
+
+<!-- Describe the big picture of your changes to communicate to the maintainers
+  why we should accept this pull request. -->
+
+## Related Issue(s)
+
+<!--
+  If this PR fixes any issues, please link to the issue here.
+  - Fixes #<issue_number>
+-->
+
+## Screenshots
+
+<!-- Add screenshots of the changes if applicable. -->
+

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/release-please-config.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "packages": {
+    ".": {
+      "release-type": "simple",
+      "extra-files": ["lua/lazy/core/config.lua"]
+    }
+  }
+}

.github/workflows/ci.yml

@@ -1,74 +1,15 @@
 name: CI
+
 on:
   push:
+    branches: [main, master]
   pull_request:
 
 jobs:
-  tests:
-    strategy:
-      matrix:
-        # os: [ubuntu-latest, windows-latest]
-        os: [ubuntu-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Neovim
-        shell: bash
-        run: |
-          mkdir -p /tmp/nvim
-          wget -q https://github.com/neovim/neovim/releases/download/nightly/nvim.appimage -O /tmp/nvim/nvim.appimage
-          cd /tmp/nvim
-          chmod a+x ./nvim.appimage
-          ./nvim.appimage --appimage-extract
-          echo "/tmp/nvim/squashfs-root/usr/bin/" >> $GITHUB_PATH
-      - name: Run Tests
-        run: |
-          nvim --version
-          [ ! -d tests ] && exit 0
-          nvim --headless -u tests/init.lua -c "PlenaryBustedDirectory tests/ {minimal_init = 'tests/init.lua', sequential = true}"
-  docs:
-    runs-on: ubuntu-latest
-    needs: tests
-    if: ${{ github.ref == 'refs/heads/main' }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: panvimdoc
-        uses: kdheepak/panvimdoc@main
-        with:
-          vimdoc: lazy.nvim
-          version: "Neovim >= 0.8.0"
-          demojify: true
-          treesitter: true
-      - name: Push changes
-        uses: stefanzweifel/git-auto-commit-action@v4
-        with:
-          commit_message: "chore(build): auto-generate vimdoc"
-          commit_user_name: "github-actions[bot]"
-          commit_user_email: "github-actions[bot]@users.noreply.github.com"
-          commit_author: "github-actions[bot] <github-actions[bot]@users.noreply.github.com>"
-  release:
-    name: release
-    if: ${{ github.ref == 'refs/heads/main' }}
-    needs:
-      - docs
-      - tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: google-github-actions/release-please-action@v3
-        id: release
-        with:
-          release-type: simple
-          package-name: lazy.nvim
-          extra-files: |
-            lua/lazy/core/config.lua
-      - uses: actions/checkout@v3
-      - name: tag stable versions
-        if: ${{ steps.release.outputs.release_created }}
-        run: |
-          git config user.name github-actions[bot]
-          git config user.email github-actions[bot]@users.noreply.github.com
-          git remote add gh-token "https://${{ secrets.GITHUB_TOKEN }}@github.com/google-github-actions/release-please-action.git"
-          git tag -d stable || true
-          git push origin :stable || true
-          git tag -a stable -m "Last Stable Release"
-          git push origin stable
+  ci:
+    uses: folke/github/.github/workflows/ci.yml@main
+    secrets: inherit
+    with:
+      plugin: lazy.nvim
+      repo: folke/lazy.nvim
+      docs: false

.github/workflows/community.yml

@@ -0,0 +1,30 @@
+name: Community
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  community:
+    runs-on: ubuntu-latest
+    if: ${{ github.ref == 'refs/heads/main' && github.repository_owner == 'folke' }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: folke/github/neovim@main
+      - name: Rockspec Build
+        id: rockspec-build
+        uses: actions/cache@v4
+        with:
+          path: build
+          key: rockspec-build
+      - name: Generate Rockspec
+        if: steps.rockspec-build.cache-hit != 'true'
+        run: |
+          nvim -l lua/lazy/build.lua
+      - name: Push changes
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "chore(build): auto-generate rockspec mappings"
+          commit_user_name: "github-actions[bot]"
+          commit_user_email: "github-actions[bot]@users.noreply.github.com"
+          commit_author: "github-actions[bot] <github-actions[bot]@users.noreply.github.com>"

.github/workflows/docs.yml

@@ -0,0 +1,19 @@
+name: Docs
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    if: ${{ github.ref == 'refs/heads/main' && github.repository_owner == 'folke' }}
+    env:
+      GH_TOKEN: ${{ github.token }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: docs
+      - name: Generate Docs
+        shell: bash
+        run: gh workflow run "Deploy to Github Pages" --ref docs

.github/workflows/labeler.yml

@@ -0,0 +1,8 @@
+name: "PR Labeler"
+on:
+  - pull_request_target
+
+jobs:
+  labeler:
+    uses: folke/github/.github/workflows/labeler.yml@main
+    secrets: inherit

.github/workflows/pr.yml

@@ -0,0 +1,18 @@
+name: PR Title
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - edited
+      - synchronize
+      - reopened
+      - ready_for_review
+
+permissions:
+  pull-requests: read
+
+jobs:
+  pr-title:
+    uses: folke/github/.github/workflows/pr.yml@main
+    secrets: inherit

.github/workflows/stale.yml

@@ -0,0 +1,11 @@
+name: Stale Issues & PRs
+
+on:
+  schedule:
+    - cron: "30 1 * * *"
+
+jobs:
+  stale:
+    if: contains(fromJSON('["folke", "LazyVim"]'), github.repository_owner)
+    uses: folke/github/.github/workflows/stale.yml@main
+    secrets: inherit

.github/workflows/update.yml

@@ -0,0 +1,13 @@
+name: Update Repo
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Run every hour
+    - cron: "0 * * * *"
+
+jobs:
+  update:
+    if: contains(fromJSON('["folke", "LazyVim"]'), github.repository_owner)
+    uses: folke/github/.github/workflows/update.yml@main
+    secrets: inherit

.gitignore

@@ -1,8 +1,9 @@
-tt.*
-.tests
-doc/tags
-debug
-.repro
-foo.*
 *.log
-data
+/.repro
+/.tests
+/build
+/debug
+/doc/tags
+foo.*
+node_modules
+tt.*

.styluaignore

@@ -0,0 +1 @@
+lua/lazy/community/_generated.lua

CHANGELOG.md

@@ -1,5 +1,849 @@
 # Changelog
 
+## [11.17.1](https://github.com/folke/lazy.nvim/compare/v11.17.0...v11.17.1) (2025-02-25)
+
+
+### Bug Fixes
+
+* **bootstrap:** support for older Neovim versions ([1c9ba37](https://github.com/folke/lazy.nvim/commit/1c9ba3704564a2e34a22191bb89678680ffeb245))
+* **meta:** rebuild dirty right after disable. See [#1889](https://github.com/folke/lazy.nvim/issues/1889) ([d51cf69](https://github.com/folke/lazy.nvim/commit/d51cf6978321d659e68a8bc38ee806bd2517a196))
+
+## [11.17.0](https://github.com/folke/lazy.nvim/compare/v11.16.2...v11.17.0) (2025-02-24)
+
+
+### Features
+
+* **config,render:** allow customizing the debug icon ([#1863](https://github.com/folke/lazy.nvim/issues/1863)) ([a9c660d](https://github.com/folke/lazy.nvim/commit/a9c660d6ef1b396869d3d951760aa7a3dbfe575f))
+* **util:** pass lang to `vim.notify` so that snacks notifier can render the ft. Closes [#1919](https://github.com/folke/lazy.nvim/issues/1919) ([c6a57a3](https://github.com/folke/lazy.nvim/commit/c6a57a3534d3494bcc5ff9b0586e141bdb0280eb))
+
+
+### Bug Fixes
+
+* **config:** add missing space on the default debug icon ([#1879](https://github.com/folke/lazy.nvim/issues/1879)) ([4df5c4d](https://github.com/folke/lazy.nvim/commit/4df5c4d65a3bbf801edd9ec55fb1ae55cfa72dd0))
+* **meta:** disable top-level specs before the rest. Closes [#1889](https://github.com/folke/lazy.nvim/issues/1889) ([f81a3fb](https://github.com/folke/lazy.nvim/commit/f81a3fb7feaf460ec7c8c983682b4a693b18fdd4))
+* **ui:** do not show virt_lines for messages ([#1904](https://github.com/folke/lazy.nvim/issues/1904)) ([f15a939](https://github.com/folke/lazy.nvim/commit/f15a93907ddad3d9139aea465ae18336d87f5ce6))
+
+## [11.16.2](https://github.com/folke/lazy.nvim/compare/v11.16.1...v11.16.2) (2024-12-13)
+
+
+### Bug Fixes
+
+* **meta:** when a plugin is both optional and disabled, then just delete it from the list ([805b85c](https://github.com/folke/lazy.nvim/commit/805b85c2ea3bd6f9506ef22cbd6e3a39172b5b08))
+
+## [11.16.1](https://github.com/folke/lazy.nvim/compare/v11.16.0...v11.16.1) (2024-12-09)
+
+
+### Bug Fixes
+
+* **types:** ensure all fields for `LazyPluginSpec` are optional ([#1843](https://github.com/folke/lazy.nvim/issues/1843)) ([703be1d](https://github.com/folke/lazy.nvim/commit/703be1dda35e142e76e94e7503cf67d6b98a1d35)), closes [#1842](https://github.com/folke/lazy.nvim/issues/1842)
+
+## [11.16.0](https://github.com/folke/lazy.nvim/compare/v11.15.0...v11.16.0) (2024-12-07)
+
+
+### Features
+
+* **plugin:** added support for virtual plugins. Closes [#1836](https://github.com/folke/lazy.nvim/issues/1836) ([ee64abc](https://github.com/folke/lazy.nvim/commit/ee64abc76be2b237b95d241a924b0323005b868a))
+
+
+### Bug Fixes
+
+* **plugin:** don't check if dir exists for virtual plugins ([656cf43](https://github.com/folke/lazy.nvim/commit/656cf4309396b7b8b62984e923bf8d8a0013f7d7))
+* **render:** show correct key for home. Fixes [#1796](https://github.com/folke/lazy.nvim/issues/1796) ([b08dba8](https://github.com/folke/lazy.nvim/commit/b08dba8107b5bdaaa007f18cf6c0cc0e0fd576aa))
+
+## [11.15.0](https://github.com/folke/lazy.nvim/compare/v11.14.2...v11.15.0) (2024-12-05)
+
+
+### Features
+
+* **plugin:** show error for local plugins that don't exist. Fixes [#1773](https://github.com/folke/lazy.nvim/issues/1773) ([9570a5a](https://github.com/folke/lazy.nvim/commit/9570a5ae7b17dcde4718c7458fd986c10f015a99))
+
+## [11.14.2](https://github.com/folke/lazy.nvim/compare/v11.14.1...v11.14.2) (2024-11-10)
+
+
+### Bug Fixes
+
+* **bootstrap:** single forward slash. Fixes [#1747](https://github.com/folke/lazy.nvim/issues/1747) ([aca30f6](https://github.com/folke/lazy.nvim/commit/aca30f63619a7492ecdea8833a065cf83c80f764))
+* **completion:** check if command string is a prefix of Lazy ([#1760](https://github.com/folke/lazy.nvim/issues/1760)) ([e9fd76e](https://github.com/folke/lazy.nvim/commit/e9fd76e239cc18da289f9a3f80f35fa16b003175)), closes [#1758](https://github.com/folke/lazy.nvim/issues/1758)
+* **docs:** always update helptags for local plugins ([60cf258](https://github.com/folke/lazy.nvim/commit/60cf258a9ae7fffe04bb31141141a91845158dcc))
+* **luarocks:** try to install from root manifest ([#1687](https://github.com/folke/lazy.nvim/issues/1687)) ([591ef40](https://github.com/folke/lazy.nvim/commit/591ef40f2da3a26fbcc0466988cd6fe45ca68cae))
+* **rocks:** add lib64 plugin directory to package.cpath ([#1717](https://github.com/folke/lazy.nvim/issues/1717)) ([80da254](https://github.com/folke/lazy.nvim/commit/80da254e645f579c28394ee0f08f75a9c9481744))
+* **rockspec:** allow binary lua files. Fixes [#1800](https://github.com/folke/lazy.nvim/issues/1800) ([408449a](https://github.com/folke/lazy.nvim/commit/408449a59adb8c2a31c32fff606676b32ce4552a))
+
+## [11.14.1](https://github.com/folke/lazy.nvim/compare/v11.14.0...v11.14.1) (2024-07-25)
+
+
+### Bug Fixes
+
+* **plugins:** "Vim:E150: Not a directory" on plugin update ([#1679](https://github.com/folke/lazy.nvim/issues/1679)) ([7108809](https://github.com/folke/lazy.nvim/commit/7108809ab18dc1b1e6f402b29e2e1d35a5d311d5))
+
+## [11.14.0](https://github.com/folke/lazy.nvim/compare/v11.13.5...v11.14.0) (2024-07-24)
+
+
+### Features
+
+* added `opts.git.cooldown` to allow updating plugins on slow connections. Fixes [#1656](https://github.com/folke/lazy.nvim/issues/1656) ([d5686ef](https://github.com/folke/lazy.nvim/commit/d5686efbd00942b3e38de7c08b8df69d961b02f0))
+* **plugin:** improve error handling and show better error message ([c02268a](https://github.com/folke/lazy.nvim/commit/c02268ac6e6aab92249d020d75efc588bd9d24fa))
+
+
+### Bug Fixes
+
+* **plugin:** make .lazy.lua work again ([b4a5a12](https://github.com/folke/lazy.nvim/commit/b4a5a1209e4c64fa67aedf721a383541a64056d1))
+
+## [11.13.5](https://github.com/folke/lazy.nvim/compare/v11.13.4...v11.13.5) (2024-07-22)
+
+
+### Bug Fixes
+
+* **health:** dont use vim.fn.system to get cmd versions ([7d29719](https://github.com/folke/lazy.nvim/commit/7d29719ade6f5a269e3b7d08b246641b5b079aaa))
+
+## [11.13.4](https://github.com/folke/lazy.nvim/compare/v11.13.3...v11.13.4) (2024-07-22)
+
+
+### Bug Fixes
+
+* **loader:** add plugins whose rtp got loaded early to start plugins ([34b0126](https://github.com/folke/lazy.nvim/commit/34b0126e5b3966f1dbe148d6f8450213115e76b2))
+* **loader:** explicitely set package.loaded.modname to nil to prevent recursive loading errors ([12f2c74](https://github.com/folke/lazy.nvim/commit/12f2c74244cc768d97c83972aa63722389b5d96d))
+
+## [11.13.3](https://github.com/folke/lazy.nvim/compare/v11.13.2...v11.13.3) (2024-07-21)
+
+
+### Reverts
+
+* fix(loader): add auto loaded module to package.loaded early to prevent require loops ([a692bf8](https://github.com/folke/lazy.nvim/commit/a692bf86883457f45fe3f773bfc8bc4d9e4b070c))
+
+## [11.13.2](https://github.com/folke/lazy.nvim/compare/v11.13.1...v11.13.2) (2024-07-21)
+
+
+### Bug Fixes
+
+* **loader:** add auto loaded module to package.loaded early to prevent require loops ([18d1c1b](https://github.com/folke/lazy.nvim/commit/18d1c1b47e175cd58dc12bf4792ef4e9a50505fa))
+
+## [11.13.1](https://github.com/folke/lazy.nvim/compare/v11.13.0...v11.13.1) (2024-07-19)
+
+
+### Bug Fixes
+
+* **build:** only load the plugin before build for `:` build commands ([5bdb12a](https://github.com/folke/lazy.nvim/commit/5bdb12a038e5a72cc793f38893f1a9c9fb741759))
+
+## [11.13.0](https://github.com/folke/lazy.nvim/compare/v11.12.0...v11.13.0) (2024-07-17)
+
+
+### Features
+
+* **ui:** added mapping descriptions ([6ca90a2](https://github.com/folke/lazy.nvim/commit/6ca90a21202808796418e46d3cebfbb5a44e54a2))
+
+## [11.12.0](https://github.com/folke/lazy.nvim/compare/v11.11.1...v11.12.0) (2024-07-16)
+
+
+### Features
+
+* **git:** added git network throttle to limit network related git ops per interval. Closes [#1635](https://github.com/folke/lazy.nvim/issues/1635) ([d731a6b](https://github.com/folke/lazy.nvim/commit/d731a6b005fd239e85e555bd57362382f6c1e461))
+
+## [11.11.1](https://github.com/folke/lazy.nvim/compare/v11.11.0...v11.11.1) (2024-07-13)
+
+
+### Bug Fixes
+
+* **config:** check for lib64. Fixes [#1343](https://github.com/folke/lazy.nvim/issues/1343) ([93499c5](https://github.com/folke/lazy.nvim/commit/93499c5deb37641c6cf71528a93f101d186b409f))
+* **lockfile:** ensure newline at EOF for lockfile ([#1639](https://github.com/folke/lazy.nvim/issues/1639)) ([7ed9f71](https://github.com/folke/lazy.nvim/commit/7ed9f7173cdec71a057053d7e6efc20c2c230b95))
+
+## [11.11.0](https://github.com/folke/lazy.nvim/compare/v11.10.4...v11.11.0) (2024-07-11)
+
+
+### Features
+
+* add plugin name to handlers.managed ([17473db](https://github.com/folke/lazy.nvim/commit/17473db1d79ea30e06126834be7fd95ca511557b))
+
+
+### Bug Fixes
+
+* **minit:** add tests to package.path when running busted (helpers.lua etc) ([fadebdc](https://github.com/folke/lazy.nvim/commit/fadebdc76b71a1d3658a88a025c6c8fb4749e0f8))
+* **util:** strip `-lua` in normname ([54b003c](https://github.com/folke/lazy.nvim/commit/54b003c650f07b771e61566f7be2629beb2b781f))
+
+## [11.10.4](https://github.com/folke/lazy.nvim/compare/v11.10.3...v11.10.4) (2024-07-08)
+
+
+### Bug Fixes
+
+* **rocks:** try building anyway even when prerequisits have not been met. (will likely fail) ([f0324de](https://github.com/folke/lazy.nvim/commit/f0324defdd43be8aa14aaf3a794ff3d5581f36ba))
+* **ui:** don't treat suspended as headless. Closes [#1626](https://github.com/folke/lazy.nvim/issues/1626) ([2dfccd7](https://github.com/folke/lazy.nvim/commit/2dfccd7b948beb26d8bcff7f9113a3a5c85cbc4a))
+
+## [11.10.3](https://github.com/folke/lazy.nvim/compare/v11.10.2...v11.10.3) (2024-07-07)
+
+
+### Bug Fixes
+
+* **git:** local plugin fixes ([#1624](https://github.com/folke/lazy.nvim/issues/1624)) ([72c0dc9](https://github.com/folke/lazy.nvim/commit/72c0dc9462ab3bf1a68198afabc1eb4e2940d299))
+
+## [11.10.2](https://github.com/folke/lazy.nvim/compare/v11.10.1...v11.10.2) (2024-07-07)
+
+
+### Bug Fixes
+
+* **git:** only check for new commits for local plugins. Closes [#1512](https://github.com/folke/lazy.nvim/issues/1512) ([81d2bff](https://github.com/folke/lazy.nvim/commit/81d2bfffdc8c84a40d25cae7fd4800178c19a138))
+
+## [11.10.1](https://github.com/folke/lazy.nvim/compare/v11.10.0...v11.10.1) (2024-07-05)
+
+
+### Bug Fixes
+
+* **lockfile:** keep cond=false and enabed=false in lockfile. Fixes [#1535](https://github.com/folke/lazy.nvim/issues/1535). Fixes [#1606](https://github.com/folke/lazy.nvim/issues/1606) ([baac551](https://github.com/folke/lazy.nvim/commit/baac5517770abd6eee63d11cf4791ef5bf5702e8))
+
+## [11.10.0](https://github.com/folke/lazy.nvim/compare/v11.9.2...v11.10.0) (2024-07-04)
+
+
+### Features
+
+* **profiling:** merge VeryLazy stats and show startuptime in profile view ([0f2786b](https://github.com/folke/lazy.nvim/commit/0f2786bcc91347188627534471ee75c3f6f16b2d))
+
+
+### Bug Fixes
+
+* **config:** determine headless only during startup. Fixes [#1608](https://github.com/folke/lazy.nvim/issues/1608) ([6fdd904](https://github.com/folke/lazy.nvim/commit/6fdd904ee45b66d933c5d2f72bcec337e13744f8))
+* **plugin:** local spec name ([923e1aa](https://github.com/folke/lazy.nvim/commit/923e1aa7a49d945afa4c03da4f8ff052cd6d14a6))
+
+## [11.9.2](https://github.com/folke/lazy.nvim/compare/v11.9.1...v11.9.2) (2024-07-02)
+
+
+### Bug Fixes
+
+* **async:** make asyncs abortable ([1fad617](https://github.com/folke/lazy.nvim/commit/1fad61712bd3937dda925775a7736b8efbcbf1a7))
+* **health:** check for errors when executing commands. Closes [#1599](https://github.com/folke/lazy.nvim/issues/1599) ([d0921f5](https://github.com/folke/lazy.nvim/commit/d0921f5b9b3d2c5e09618da55a018228edcc4d16))
+
+
+### Performance Improvements
+
+* **plugin:** minor optim to resolve imports a bit faster ([a9d7ade](https://github.com/folke/lazy.nvim/commit/a9d7ade203b3f3ee3058c082c62afdf8e4bcb416))
+
+## [11.9.1](https://github.com/folke/lazy.nvim/compare/v11.9.0...v11.9.1) (2024-06-30)
+
+
+### Performance Improvements
+
+* automatically suspend the scheduler when all threads are waiting ([#1591](https://github.com/folke/lazy.nvim/issues/1591)) ([c7ed87f](https://github.com/folke/lazy.nvim/commit/c7ed87f9ca03ea412134d6a6ea55b43232eb6b0c))
+* suspend when tasks are active ([2f4ac03](https://github.com/folke/lazy.nvim/commit/2f4ac035bcc66292250de7134d73007b147f64e8))
+
+## [11.9.0](https://github.com/folke/lazy.nvim/compare/v11.8.2...v11.9.0) (2024-06-29)
+
+
+### Features
+
+* **ui:** use [[ & ]] to navigate between plugins. Fixes [#1463](https://github.com/folke/lazy.nvim/issues/1463) ([5e3c112](https://github.com/folke/lazy.nvim/commit/5e3c112cb32c9cb6e8622aab4446358e039def7c))
+
+
+### Bug Fixes
+
+* **ui:** when closing details, jump to plugin header. Closes [#1338](https://github.com/folke/lazy.nvim/issues/1338) ([3772914](https://github.com/folke/lazy.nvim/commit/37729140751577e87318c137d90d0e6bb00ceff1))
+
+## [11.8.2](https://github.com/folke/lazy.nvim/compare/v11.8.1...v11.8.2) (2024-06-29)
+
+
+### Bug Fixes
+
+* **process:** deal with process errors ([a75d950](https://github.com/folke/lazy.nvim/commit/a75d950b8f356733ad2d20c4bdb794179e6d4ff1))
+* **ui:** save/restore view right before/after rendering ([5d334b9](https://github.com/folke/lazy.nvim/commit/5d334b9f579aacd09603dd9e19b6730fbfcf4c72))
+
+
+### Performance Improvements
+
+* **rocks:** `vim.fn.executable` is slow on WSL2, so only check for `luarocks` when needed. Closes [#1585](https://github.com/folke/lazy.nvim/issues/1585) ([9ab3061](https://github.com/folke/lazy.nvim/commit/9ab306169060eeab7ebca00653318683e72ab62d))
+
+## [11.8.1](https://github.com/folke/lazy.nvim/compare/v11.8.0...v11.8.1) (2024-06-29)
+
+
+### Bug Fixes
+
+* **async:** remove debug assert ([3513227](https://github.com/folke/lazy.nvim/commit/3513227a9a41c8e6366e1719f4cefbe891ca73d2))
+
+## [11.8.0](https://github.com/folke/lazy.nvim/compare/v11.7.0...v11.8.0) (2024-06-29)
+
+
+### Features
+
+* **plugin:** allow loading specs without pkg ([695a058](https://github.com/folke/lazy.nvim/commit/695a05872a5b44e366e5532eb2fe38a64fae8357))
+
+## [11.7.0](https://github.com/folke/lazy.nvim/compare/v11.6.0...v11.7.0) (2024-06-29)
+
+
+### Features
+
+* **minit:** fallback to habamax when no colorscheme set ([88f4d13](https://github.com/folke/lazy.nvim/commit/88f4d13e5f489eb30959db03a94ebfa10a78b47f))
+
+## [11.6.0](https://github.com/folke/lazy.nvim/compare/v11.5.2...v11.6.0) (2024-06-29)
+
+
+### Features
+
+* **task:** build procs can now yield a LazyMsg for more control ([9cf7459](https://github.com/folke/lazy.nvim/commit/9cf745939d792204a18d7ad10a54d22386ececf3))
+
+## [11.5.2](https://github.com/folke/lazy.nvim/compare/v11.5.1...v11.5.2) (2024-06-28)
+
+
+### Bug Fixes
+
+* **git:** tagrefs ([2a6a2dc](https://github.com/folke/lazy.nvim/commit/2a6a2dce1b14f35e7eb7cbe8f25202ed83cba697))
+
+## [11.5.1](https://github.com/folke/lazy.nvim/compare/v11.5.0...v11.5.1) (2024-06-28)
+
+
+### Bug Fixes
+
+* **rocks:** lua-5.1. Closes [#1575](https://github.com/folke/lazy.nvim/issues/1575) ([4319846](https://github.com/folke/lazy.nvim/commit/4319846b8c8a05975c4139b0bc9f7e6e7a9e6e21))
+* **task:** run on_exit async. See [#1569](https://github.com/folke/lazy.nvim/issues/1569) ([60fe75c](https://github.com/folke/lazy.nvim/commit/60fe75c88db22025989600bb53dba247654d9ed5))
+
+
+### Performance Improvements
+
+* async render ([ab46edb](https://github.com/folke/lazy.nvim/commit/ab46edbd47fa9f380db65dbf0a7c35d18d810b19))
+* use timer instead of check for async executor ([f85575a](https://github.com/folke/lazy.nvim/commit/f85575ab23c81eb897fb2cb1240a0fa1cb41f7f4))
+
+## [11.5.0](https://github.com/folke/lazy.nvim/compare/v11.4.2...v11.5.0) (2024-06-27)
+
+
+### Features
+
+* added `opts.headless` to control ansi output when running headless ([a0a51c0](https://github.com/folke/lazy.nvim/commit/a0a51c06c2fcddda925667142516c89777eb0c8e))
+* added localleader-i to inspect a plugin ([2e1167d](https://github.com/folke/lazy.nvim/commit/2e1167df4ab055e8327317ac38210b111cbaec83))
+* **health:** show steps to get luarocks working. See [#1570](https://github.com/folke/lazy.nvim/issues/1570) ([c0fd59b](https://github.com/folke/lazy.nvim/commit/c0fd59b020dc4efb91b226b0bbc4a22f28c12321))
+* **health:** show user's lazy.nvim version in checkhealth ([9c8e7a4](https://github.com/folke/lazy.nvim/commit/9c8e7a48406109458370f3b52f6f058943db40f4))
+* **ui:** keep cursor position when rendering view ([591ded8](https://github.com/folke/lazy.nvim/commit/591ded8309e45806ae3fb58b7b68fe58785a3ada))
+* **ui:** remap gx -> K. Fixes [#1561](https://github.com/folke/lazy.nvim/issues/1561) ([e3e4314](https://github.com/folke/lazy.nvim/commit/e3e431480d6c9ab460cf08b1e35311c2ab2c05c4))
+* **ui:** show indication of plugins that need build. See [#1563](https://github.com/folke/lazy.nvim/issues/1563) ([53f314d](https://github.com/folke/lazy.nvim/commit/53f314d9e6ef594677acdf5f038a4a042a7f3e38))
+
+
+### Bug Fixes
+
+* **manage:** dont skip install for plugins that need a build, but dont have an url (like local plugins). Fixes [#1563](https://github.com/folke/lazy.nvim/issues/1563) ([a0391c3](https://github.com/folke/lazy.nvim/commit/a0391c3e21e063df9dee70f17ae7891497cdcec9))
+* **meta:** resolve deps from meta instead of fragments. Fixes [#1566](https://github.com/folke/lazy.nvim/issues/1566) ([6a42327](https://github.com/folke/lazy.nvim/commit/6a423278a10ff7b1a76795275111d01632851c48))
+* **pkg:** only show pkg changed when effectively changing a pkg file. Fixes [#1567](https://github.com/folke/lazy.nvim/issues/1567) ([24a86d5](https://github.com/folke/lazy.nvim/commit/24a86d5ca4652a77f0f2c78dd7c693a3c369ab68))
+* **rocks:** if installing with luarocks (binaries) fails, then build from source. Fixes [#1563](https://github.com/folke/lazy.nvim/issues/1563) ([8227632](https://github.com/folke/lazy.nvim/commit/82276321f5132c680a852bec0bb9b55694ab2a21))
+* **runner:** only check for errors when a task is no longer running ([e02c5b1](https://github.com/folke/lazy.nvim/commit/e02c5b1b5787210dfbf89681d94e7861b30aa139))
+* **runner:** only use Config.plugins when updated. Fixes [#1560](https://github.com/folke/lazy.nvim/issues/1560) ([97f4df0](https://github.com/folke/lazy.nvim/commit/97f4df0824da13b2b0d065f0dc43c49862581a01))
+* **runner:** properly do concurrency ([66a4170](https://github.com/folke/lazy.nvim/commit/66a4170f0e9ab238972f73a268582cf65026a017))
+* **runner:** wait_step ([93b3a77](https://github.com/folke/lazy.nvim/commit/93b3a77286c4212850e21a6b3e31d328b5a86df4))
+* **ui:** diagnostics without status ([249902a](https://github.com/folke/lazy.nvim/commit/249902ab3194226efec0dbc3e000e758c43b4714))
+
+
+### Performance Improvements
+
+* prevent active waiting in coroutines. suspend/resume instead ([68cee30](https://github.com/folke/lazy.nvim/commit/68cee30cdb1f7a29d10b44b00506aafa092b6cee))
+
+## [11.4.2](https://github.com/folke/lazy.nvim/compare/v11.4.1...v11.4.2) (2024-06-26)
+
+
+### Bug Fixes
+
+* **config:** dont start checker/change_detection when running headless ([2aa8e06](https://github.com/folke/lazy.nvim/commit/2aa8e061f22579b0cabc74f05a90f7344d92195c))
+* **git:** fetch commit from origin or local to check if branch was changed. See [#1549](https://github.com/folke/lazy.nvim/issues/1549) ([28e435b](https://github.com/folke/lazy.nvim/commit/28e435b7f34eecd8b90bc87ac71c70b79fcb03b3))
+* **rocks:** build.type instead of build.build_type ([aa1c957](https://github.com/folke/lazy.nvim/commit/aa1c9572aa1916e582f9b9c3d43e272b4f23b326))
+* **rockspec:** dont lazy-load rock deps ([4733611](https://github.com/folke/lazy.nvim/commit/473361139cc05936cd5afb08ab68e5bee1ebb5b3))
+* **runner:** bring concurrency back ([56075b5](https://github.com/folke/lazy.nvim/commit/56075b57c421fc5e751c1da7a7f1bf18ec1499a7))
+* **ui:** don't show output when it's the same as error ([e79805d](https://github.com/folke/lazy.nvim/commit/e79805d706f815a62467260cb307844c368c3dba))
+
+
+### Performance Improvements
+
+* tasks are now fully async ([0614ca6](https://github.com/folke/lazy.nvim/commit/0614ca6ca629704cb1846c0d6f9a250b526900b9))
+* **util:** improve impl of throttle ([3695215](https://github.com/folke/lazy.nvim/commit/36952153ecb5b196c74e2d9a28eb0e01a9eb02fe))
+
+## [11.4.1](https://github.com/folke/lazy.nvim/compare/v11.4.0...v11.4.1) (2024-06-25)
+
+
+### Bug Fixes
+
+* **health:** show what plugins need luarocks and if none, use warnings instead of errors. See [#1551](https://github.com/folke/lazy.nvim/issues/1551) ([0d9fd63](https://github.com/folke/lazy.nvim/commit/0d9fd636beb9e3783edcdba2b31932280bdc05f7))
+
+## [11.4.0](https://github.com/folke/lazy.nvim/compare/v11.3.0...v11.4.0) (2024-06-25)
+
+
+### Features
+
+* **pkg:** utils to get rock to url mappings ([be74a8a](https://github.com/folke/lazy.nvim/commit/be74a8a535fea6a480143fb52b4d6958d9e2da94))
+* **rocks:** simple rockspecs are now fully resolved by lazy without luarocks. See [#1548](https://github.com/folke/lazy.nvim/issues/1548) ([6b8bf58](https://github.com/folke/lazy.nvim/commit/6b8bf58ebf9114f8f31fb78cbf057e452cb0e540))
+
+
+### Bug Fixes
+
+* **meta:** only tag new top-level pkg fragment as optional ([25981e1](https://github.com/folke/lazy.nvim/commit/25981e1f3927ee0b22aefea122ebac1cddafdca6))
+
+## [11.3.0](https://github.com/folke/lazy.nvim/compare/v11.2.1...v11.3.0) (2024-06-25)
+
+
+### Features
+
+* **rocks:** use hererocks to install luarocks when luarocks is not found ([d87da76](https://github.com/folke/lazy.nvim/commit/d87da7667939deff2ed8b5a3c198d9ea2e03fee4))
+
+
+### Bug Fixes
+
+* **fragments:** check for empty plugin names ([dea1f68](https://github.com/folke/lazy.nvim/commit/dea1f687fe6e15eb3098557a69d44231ebcb6cf5))
+* **meta:** no need to check for old_dir when frags were not built yet. Fixes [#1550](https://github.com/folke/lazy.nvim/issues/1550) ([24c8322](https://github.com/folke/lazy.nvim/commit/24c832213c505a0d7ca021c0e14bba43e0fef75c))
+* **rocks:** better errors / warnings when something goes wrong with luarocks ([7d3f691](https://github.com/folke/lazy.nvim/commit/7d3f69104fb39d3e6e12f808204b3a7b38f86916))
+* **rocks:** hererocks paths on windows ([45cd8d3](https://github.com/folke/lazy.nvim/commit/45cd8d3f0fab197e6e0391cffa38879bdda4c2cd))
+* **rocks:** windows ([4ca3e9a](https://github.com/folke/lazy.nvim/commit/4ca3e9aa51c03dda73b40ec9901deac5d4f11c69))
+
+## [11.2.1](https://github.com/folke/lazy.nvim/compare/v11.2.0...v11.2.1) (2024-06-24)
+
+
+### Bug Fixes
+
+* **loader:** no need to check plugin.dir in auto_load ([62a47b9](https://github.com/folke/lazy.nvim/commit/62a47b921fbffb3c1c8088a731029ae234f98851))
+
+## [11.2.0](https://github.com/folke/lazy.nvim/compare/v11.1.0...v11.2.0) (2024-06-24)
+
+
+### Features
+
+* rewrite some known plugins to lazy specs instead of luarocks (plenary.nvim). Closes [#1540](https://github.com/folke/lazy.nvim/issues/1540) ([a089d43](https://github.com/folke/lazy.nvim/commit/a089d43dba7438532c56e1c582c5974713bd48f8))
+
+
+### Performance Improvements
+
+* minimize meta rebuild when loading specs ([1446f6c](https://github.com/folke/lazy.nvim/commit/1446f6cfbb4ca0a7ee0baf3acc86ab5e4be5ab22))
+
+## [11.1.0](https://github.com/folke/lazy.nvim/compare/v11.0.1...v11.1.0) (2024-06-24)
+
+
+### Features
+
+* make it easier to disable luarocks ([07c067a](https://github.com/folke/lazy.nvim/commit/07c067a1a82bb0988179e1887bba9df4721b3ea7))
+* show rockspec deps in plugin details ([656d3d1](https://github.com/folke/lazy.nvim/commit/656d3d1f5b5910e50af3d67286999ff7088ebfb6))
+
+
+### Bug Fixes
+
+* **health:** added luarocks check to health ([0f45c0d](https://github.com/folke/lazy.nvim/commit/0f45c0d0623b4850716898a5e399c844466690f6))
+* **health:** only check for luarocks when luarocks is enabled. ([ae4881d](https://github.com/folke/lazy.nvim/commit/ae4881d36e7f589124f8eb7febfc6a8b58f8e027))
+* **health:** show missing luarocks as warning ([e3ee51b](https://github.com/folke/lazy.nvim/commit/e3ee51b6680a116649da56f6c651d53c3e47be4e))
+* **runner:** sync package specs after installing and before building ([105d480](https://github.com/folke/lazy.nvim/commit/105d4805ad58875d0b0fafe1185679539b8bc69a))
+
+## [11.0.1](https://github.com/folke/lazy.nvim/compare/v11.0.0...v11.0.1) (2024-06-24)
+
+
+### Bug Fixes
+
+* **rocks:** dont trigger rebuild for luarocks when build is overriden ([146de4e](https://github.com/folke/lazy.nvim/commit/146de4e801f9169e79052a51365eaae789094611))
+
+## [11.0.0](https://github.com/folke/lazy.nvim/compare/v10.24.3...v11.0.0) (2024-06-24)
+
+
+### ⚠ BREAKING CHANGES
+
+* new docs for v11.0
+
+### Features
+
+* added support for plugin packages by lazy, rockspec and packspec ([3be55a4](https://github.com/folke/lazy.nvim/commit/3be55a46158cde17e2b853e531d260f3738a5346))
+* **build:** build files and functions are now async. use coroutine.yield to interrupt and report progress ([368747b](https://github.com/folke/lazy.nvim/commit/368747bc9a314b4f0745547ebdcc3fbc4d100c0a))
+* luarocks support ([f1ba2e3](https://github.com/folke/lazy.nvim/commit/f1ba2e3d057ae5c03d04134a9d538d0b2251f13b))
+* **meta:** check for dir changes for plugins already added to the rtp ([ee2ca39](https://github.com/folke/lazy.nvim/commit/ee2ca39f672a2d6f4cbb683b525e6b3d91f3fc0c))
+* new docs for v11.0 ([183f59e](https://github.com/folke/lazy.nvim/commit/183f59e2e85dea0c38ed7d16c7c7e543c0b739c7))
+* packspec ([8eba74c](https://github.com/folke/lazy.nvim/commit/8eba74c3fc41e1a364225f744022f8b3ff11d796))
+* **pkg:** import package specs in the scope of the plugin ([c1912e2](https://github.com/folke/lazy.nvim/commit/c1912e23481ba72a8d8f7a5c736f5e2547e6853e))
+* rewrite of spec resolving ([75ffe56](https://github.com/folke/lazy.nvim/commit/75ffe56f70faac43f077796b91178d2f1419f8ce))
+* spec.rocks is no longer needed & added support for installing any luarock ([fcfd548](https://github.com/folke/lazy.nvim/commit/fcfd54835da5af64c6046060f4db62c4626d209c))
+
+
+### Bug Fixes
+
+* **fragments:** prevent adding the same spec instance more than once ([dbffad6](https://github.com/folke/lazy.nvim/commit/dbffad6f44674a3c1b23c649a0abab299d7349d8))
+* **luarocks:** cleanup luarocks when deleting a plugin ([b73c57e](https://github.com/folke/lazy.nvim/commit/b73c57ed9ec8e63bbb867d21a3f3a865224b25d4))
+* **pkg:** automatically update pkgs when editing a pkg file ([7b6ddbf](https://github.com/folke/lazy.nvim/commit/7b6ddbfc137ad5d8b178a3bbf5a1338630f30625))
+* **pkg:** correctly pre-load package specs and remove them when needed during resolve ([4326d4b](https://github.com/folke/lazy.nvim/commit/4326d4b487d4facc19b375ca30cd633cf56d88ed))
+* **pkg:** make sure state dir exists ([3515cb5](https://github.com/folke/lazy.nvim/commit/3515cb518f61c02b41cd3a8d8135c9a5862a982f))
+* **pkg:** versioning and reload specs when pkg-cache is dirty ([fd8229d](https://github.com/folke/lazy.nvim/commit/fd8229d6e312e83d6bafda256adf0e650b13ca01))
+* **rocks:** only build rockspec when it has deps or an advanced build step ([9a6c219](https://github.com/folke/lazy.nvim/commit/9a6c21982638b6e2ea498514baee9186c0e60d82))
+
+## [10.24.3](https://github.com/folke/lazy.nvim/compare/v10.24.2...v10.24.3) (2024-06-23)
+
+
+### Bug Fixes
+
+* **util:** dump ([025520d](https://github.com/folke/lazy.nvim/commit/025520d083c61baa7cd1f45807f5fe1ac9fbb50d))
+
+## [10.24.2](https://github.com/folke/lazy.nvim/compare/v10.24.1...v10.24.2) (2024-06-16)
+
+
+### Bug Fixes
+
+* **plugin:** rebuild optional when needed and remove frags from parent deps. Fixes [#1402](https://github.com/folke/lazy.nvim/issues/1402) ([b4316da](https://github.com/folke/lazy.nvim/commit/b4316da7310682144c279c5f0451e59ee5f6c9d1))
+
+## [10.24.1](https://github.com/folke/lazy.nvim/compare/v10.24.0...v10.24.1) (2024-06-16)
+
+
+### Bug Fixes
+
+* **plugin:** better way of dealing with local specs. Fixes [#1524](https://github.com/folke/lazy.nvim/issues/1524) ([be5dfba](https://github.com/folke/lazy.nvim/commit/be5dfba54216ccb80959df24d48540f07ee127a3))
+
+## [10.24.0](https://github.com/folke/lazy.nvim/compare/v10.23.0...v10.24.0) (2024-06-15)
+
+
+### Features
+
+* find local_spec in parent directories as well. Closes [#1519](https://github.com/folke/lazy.nvim/issues/1519) ([e2e10d9](https://github.com/folke/lazy.nvim/commit/e2e10d9cbe133265ccdcc44cafa7c10773d96837))
+
+
+### Bug Fixes
+
+* **plugin:** check optional plugins again after resolving enabled. Fixes [#1402](https://github.com/folke/lazy.nvim/issues/1402) ([067fd41](https://github.com/folke/lazy.nvim/commit/067fd41933c9f59eb3445eb942052c651a4c9a62))
+
+## [10.23.0](https://github.com/folke/lazy.nvim/compare/v10.22.2...v10.23.0) (2024-06-07)
+
+
+### Features
+
+* **plugin:** `opts_extend` can be a list of dotted keys that will be extended instead of merged ([1f7b720](https://github.com/folke/lazy.nvim/commit/1f7b720cffa6d8f00ebb040bc60e8e056e0a6002))
+* **util:** opts merging now supports lists extending by tagging a table with __extend = true. Use with care ([74fd361](https://github.com/folke/lazy.nvim/commit/74fd3611f291a2506c5534109689bb7b028f0566))
+
+## [10.22.2](https://github.com/folke/lazy.nvim/compare/v10.22.1...v10.22.2) (2024-06-06)
+
+
+### Bug Fixes
+
+* **keys:** buffer-local nop mappings ([ff90417](https://github.com/folke/lazy.nvim/commit/ff904178089582f90fdc625493f3d3bddbefd6ea))
+* **keys:** never lazy-load `<nop>` or empty rhs keymaps ([3e4c795](https://github.com/folke/lazy.nvim/commit/3e4c795cec32481bc6d0b30c05125fdf7ef2d412))
+
+## [10.22.1](https://github.com/folke/lazy.nvim/compare/v10.22.0...v10.22.1) (2024-06-02)
+
+
+### Bug Fixes
+
+* force new release ([9242edb](https://github.com/folke/lazy.nvim/commit/9242edb73939e7508dbd827e9c013579391f0668))
+
+## [10.22.0](https://github.com/folke/lazy.nvim/compare/v10.21.2...v10.22.0) (2024-06-01)
+
+
+### Features
+
+* set `vim.env.LAZY` to lazy root ([6a141a6](https://github.com/folke/lazy.nvim/commit/6a141a6dbb6f6b5495ef6716c0dce898546d7b2c))
+
+## [10.21.2](https://github.com/folke/lazy.nvim/compare/v10.21.1...v10.21.2) (2024-05-31)
+
+
+### Bug Fixes
+
+* **ui:** deduplicate plugins when selecting multiple ([#1491](https://github.com/folke/lazy.nvim/issues/1491)) ([b77aaa0](https://github.com/folke/lazy.nvim/commit/b77aaa08cb5b178ed8662765caa41c70ff254a4c))
+
+## [10.21.1](https://github.com/folke/lazy.nvim/compare/v10.21.0...v10.21.1) (2024-05-31)
+
+
+### Bug Fixes
+
+* **view:** backward compat for older Neovim versions. Fixes [#1489](https://github.com/folke/lazy.nvim/issues/1489) ([917dfbe](https://github.com/folke/lazy.nvim/commit/917dfbe2a9b606443639d1e809f2e4561a6dd654))
+
+## [10.21.0](https://github.com/folke/lazy.nvim/compare/v10.20.5...v10.21.0) (2024-05-26)
+
+
+### Features
+
+* added support for local spec files `.lazy.lua` ([9dde1f1](https://github.com/folke/lazy.nvim/commit/9dde1f1bce44a8fd8cb885b5a8e8d47d8fd7b8c1))
+* single-plugin keys in the lazy view in visual mode ([#1476](https://github.com/folke/lazy.nvim/issues/1476)) ([7667a73](https://github.com/folke/lazy.nvim/commit/7667a73dee381c5fb7d538f6152aeb591e3f0372))
+
+
+### Bug Fixes
+
+* **render:** disable underline for diagnostics ([#1478](https://github.com/folke/lazy.nvim/issues/1478)) ([ea7b9c3](https://github.com/folke/lazy.nvim/commit/ea7b9c3c3fd9026e1a5ae27950585df9a42ccd5b))
+
+## [10.20.5](https://github.com/folke/lazy.nvim/compare/v10.20.4...v10.20.5) (2024-05-21)
+
+
+### Bug Fixes
+
+* **checker:** ignore dev plugins ([#1384](https://github.com/folke/lazy.nvim/issues/1384)) ([2e04a0c](https://github.com/folke/lazy.nvim/commit/2e04a0c02c17facd3772c382099215acbe72535b))
+* **git:** force `autocrlf=false`. Fixes [#1055](https://github.com/folke/lazy.nvim/issues/1055) ([d2a4ce2](https://github.com/folke/lazy.nvim/commit/d2a4ce22dc02aa08c176cd7692b5b0ed74e4722b))
+* **help:** get rid of any tbl_flatten or iter flatten code ([56a34a8](https://github.com/folke/lazy.nvim/commit/56a34a825b55e0e30cd9df0e055e428a13afd4aa))
+* **keys:** properly deal with ft list for keys. Fixes [#1448](https://github.com/folke/lazy.nvim/issues/1448) ([82cf974](https://github.com/folke/lazy.nvim/commit/82cf974e0939b3440c4470cbcd8e7869abfe480b))
+* **keys:** properly re-create buffer-local mappings. Fixes [#1448](https://github.com/folke/lazy.nvim/issues/1448) ([39de11a](https://github.com/folke/lazy.nvim/commit/39de11a2fa7f4b91556631c49a673bf3e48bcc16))
+* use vim.iter():flatten():totable() over vim.tbl_flatten ([#1454](https://github.com/folke/lazy.nvim/issues/1454)) ([d039aec](https://github.com/folke/lazy.nvim/commit/d039aecddb414c2df9d295e9182ed217196a2c1c))
+
+## [10.20.4](https://github.com/folke/lazy.nvim/compare/v10.20.3...v10.20.4) (2024-05-12)
+
+
+### Bug Fixes
+
+* **heath:** vim.uv. Fixes [#1412](https://github.com/folke/lazy.nvim/issues/1412) ([481aed7](https://github.com/folke/lazy.nvim/commit/481aed70cc4d8e8a38463fd16edf81a23c153247))
+* **reload:** strings in lua reload ([#1439](https://github.com/folke/lazy.nvim/issues/1439)) ([2fcbcaf](https://github.com/folke/lazy.nvim/commit/2fcbcaf07ab79594f2ba25ebf6f4c47e250c33be))
+* **ui:** add conditional `nvim_get_hl_by_name` for Neovim 0.8.0 ([#1429](https://github.com/folke/lazy.nvim/issues/1429)) ([24234f4](https://github.com/folke/lazy.nvim/commit/24234f47a21ca690de829ea1159b553a733f3968))
+* **ui:** hover now opens repo url when no diff with main. Fixes [#1430](https://github.com/folke/lazy.nvim/issues/1430) ([4084506](https://github.com/folke/lazy.nvim/commit/40845063a2586b725d84d44e41fe2c8737751a30))
+* **ui:** set backdrop filetype to `lazy_backdrop`. Fixes [#1399](https://github.com/folke/lazy.nvim/issues/1399) ([31ddbea](https://github.com/folke/lazy.nvim/commit/31ddbea7c10b6920c9077b66c97951ca8682d5c8))
+
+## [10.20.3](https://github.com/folke/lazy.nvim/compare/v10.20.2...v10.20.3) (2024-03-28)
+
+
+### Bug Fixes
+
+* **ui:** disable backdrop when Neovim is transparent ([0ccf031](https://github.com/folke/lazy.nvim/commit/0ccf0312270d2d976ec551a9034bf05720f2486b))
+
+## [10.20.2](https://github.com/folke/lazy.nvim/compare/v10.20.1...v10.20.2) (2024-03-27)
+
+
+### Bug Fixes
+
+* **ui:** only enable backdrop when guicolors is set. Fixes [#1387](https://github.com/folke/lazy.nvim/issues/1387) ([d37a76b](https://github.com/folke/lazy.nvim/commit/d37a76b87137c777f3d778ed03729d7f332a85f0))
+* **ui:** special handling for floats closed before VimEnter. Seems that WinClosed events dont execute before that. Fixes [#1390](https://github.com/folke/lazy.nvim/issues/1390) ([eefb897](https://github.com/folke/lazy.nvim/commit/eefb8974d6a092da6e1631855e4288499b651fdd))
+
+## [10.20.1](https://github.com/folke/lazy.nvim/compare/v10.20.0...v10.20.1) (2024-03-26)
+
+
+### Bug Fixes
+
+* **ui:** properly cleanup on `:quit`. Fixes [#1385](https://github.com/folke/lazy.nvim/issues/1385) ([79e2e85](https://github.com/folke/lazy.nvim/commit/79e2e8593410f199b85f5d61a83704a16169282f))
+
+## [10.20.0](https://github.com/folke/lazy.nvim/compare/v10.19.0...v10.20.0) (2024-03-26)
+
+
+### Features
+
+* **ui:** backdrop for the lazy floating window. Can be disabled with `opts.ui.backdrop` ([a6b74f3](https://github.com/folke/lazy.nvim/commit/a6b74f30d5aab79a40d932f449c0aa5d4a0c6934))
+
+
+### Bug Fixes
+
+* **types:** fixed type for `version`. Fixes [#1381](https://github.com/folke/lazy.nvim/issues/1381) ([eade87f](https://github.com/folke/lazy.nvim/commit/eade87fb837d6cdeef94587ce5e8c8dfb9f88920))
+
+## [10.19.0](https://github.com/folke/lazy.nvim/compare/v10.18.3...v10.19.0) (2024-03-22)
+
+
+### Features
+
+* **util:** option to force system app for util.open ([66466a2](https://github.com/folke/lazy.nvim/commit/66466a2594ab0c446193772a68c236c7e4e02ade))
+
+## [10.18.3](https://github.com/folke/lazy.nvim/compare/v10.18.2...v10.18.3) (2024-03-22)
+
+
+### Bug Fixes
+
+* **cache:** vim.loop fallback ([#1375](https://github.com/folke/lazy.nvim/issues/1375)) ([9131ea4](https://github.com/folke/lazy.nvim/commit/9131ea4c4ae59e347716659088a76d9b9ce3b2f5))
+
+## [10.18.2](https://github.com/folke/lazy.nvim/compare/v10.18.1...v10.18.2) (2024-03-22)
+
+
+### Bug Fixes
+
+* **ui:** Add "bot" to dimmed commands list ([#1367](https://github.com/folke/lazy.nvim/issues/1367)) ([b6f7ef8](https://github.com/folke/lazy.nvim/commit/b6f7ef856b36c5edbe9f03e3a8554b97c458c953))
+
+## [10.18.1](https://github.com/folke/lazy.nvim/compare/v10.18.0...v10.18.1) (2024-03-22)
+
+
+### Bug Fixes
+
+* uv shim was not falling back to vim.loop ([#1370](https://github.com/folke/lazy.nvim/issues/1370)) ([61dddae](https://github.com/folke/lazy.nvim/commit/61dddaec58f8594e40e95a8d5069ce7e493089df))
+
+## [10.18.0](https://github.com/folke/lazy.nvim/compare/v10.17.0...v10.18.0) (2024-03-22)
+
+
+### Features
+
+* refactor all vim.loop -> vim.uv and add a shim when needed ([9e157df](https://github.com/folke/lazy.nvim/commit/9e157df077d24654d0cdefe08158cd4f76e85fe8))
+
+## [10.17.0](https://github.com/folke/lazy.nvim/compare/v10.16.0...v10.17.0) (2024-03-07)
+
+
+### Features
+
+* **loader:** warn when maplocalleader is changed after init ([#1326](https://github.com/folke/lazy.nvim/issues/1326)) ([0694651](https://github.com/folke/lazy.nvim/commit/0694651fd37c3645e1683b4f392d4e38e7d2991b))
+
+
+### Bug Fixes
+
+* **manage:** better support for using the default colorscheme during install. See [#1277](https://github.com/folke/lazy.nvim/issues/1277) ([670a6fe](https://github.com/folke/lazy.nvim/commit/670a6fec7f9b03134849e308d87f4dc316875c46))
+* **types:** fix incorrect LuaLS types ([#1339](https://github.com/folke/lazy.nvim/issues/1339)) ([5aea4e7](https://github.com/folke/lazy.nvim/commit/5aea4e7021287d7bcda6f31d7ad234580940be32))
+* **ui:** remove a single space character from home title ([#1309](https://github.com/folke/lazy.nvim/issues/1309)) ([d5c58bb](https://github.com/folke/lazy.nvim/commit/d5c58bb1937f8aee390f206e724ef23b0cc95eb3))
+* update to new treesitter capture groups ([#1294](https://github.com/folke/lazy.nvim/issues/1294)) ([298bed1](https://github.com/folke/lazy.nvim/commit/298bed190e40b67bb1c20c4d5845c2c0c7da450f))
+
+## [10.16.0](https://github.com/folke/lazy.nvim/compare/v10.15.1...v10.16.0) (2024-01-21)
+
+
+### Features
+
+* **plugin:** dev.path can now be a function ([#1157](https://github.com/folke/lazy.nvim/issues/1157)) ([a6f782a](https://github.com/folke/lazy.nvim/commit/a6f782adc1ace840a7e671c731daab7851cba6af))
+* **ui:** add style to dimmed commits ([#1210](https://github.com/folke/lazy.nvim/issues/1210)) ([7ded44c](https://github.com/folke/lazy.nvim/commit/7ded44ce2a442aa32b90488b8f1f9c8ca6899f3b))
+
+
+### Bug Fixes
+
+* **fs:** error when plugin directory to delete is not a valid directory ([47d4baa](https://github.com/folke/lazy.nvim/commit/47d4baafcc370f16c195fd718f37f8fb1e0aa9a1))
+* **git:** comment sign detection in get_config function ([#1281](https://github.com/folke/lazy.nvim/issues/1281)) ([d0d410b](https://github.com/folke/lazy.nvim/commit/d0d410bc222a475202d9c2b55d1c5fbd12c26ffe))
+* **health:** dont warn on submodules. Fixes [#1174](https://github.com/folke/lazy.nvim/issues/1174) ([1b3df6c](https://github.com/folke/lazy.nvim/commit/1b3df6c00797e1b12f7c16148261e9dd841a33dd))
+* **keys:** allow global/local ft keymaps to exist at the same time. Fixes [#1241](https://github.com/folke/lazy.nvim/issues/1241) ([5757b55](https://github.com/folke/lazy.nvim/commit/5757b551fc6066d836b9e45f70b41561ca619272))
+* **keys:** fix abbreviation expansion on lazy load ([#1219](https://github.com/folke/lazy.nvim/issues/1219)) ([d09084c](https://github.com/folke/lazy.nvim/commit/d09084c4b1f5c58724152a4acad7c880117a95ea))
+* **keys:** make sure we don't delete the global mapping when executing an ft keymap. See [#1241](https://github.com/folke/lazy.nvim/issues/1241) ([a9b9a4b](https://github.com/folke/lazy.nvim/commit/a9b9a4b3a2dcc1e81828cfd74bfb61193b014b67))
+
+## [10.15.1](https://github.com/folke/lazy.nvim/compare/v10.15.0...v10.15.1) (2023-11-04)
+
+
+### Bug Fixes
+
+* **build:** allow build=false to skip building ([314193a](https://github.com/folke/lazy.nvim/commit/314193af1d63181bff65e8b24db416e34c5fae86))
+* **ui:** properly highlight breaking change commit scope ([#1160](https://github.com/folke/lazy.nvim/issues/1160)) ([3674036](https://github.com/folke/lazy.nvim/commit/3674036a59a6a4a65559343d606a92145a782533))
+
+## [10.15.0](https://github.com/folke/lazy.nvim/compare/v10.14.6...v10.15.0) (2023-10-25)
+
+
+### Features
+
+* **ui:** check pinned packages that can't be updated ([#1139](https://github.com/folke/lazy.nvim/issues/1139)) ([4446fdb](https://github.com/folke/lazy.nvim/commit/4446fdb9af1b1c41560f6cc41452eee826a8bce0))
+
+
+### Bug Fixes
+
+* **loader:** when reloading, clear plugin properties cache ([#1153](https://github.com/folke/lazy.nvim/issues/1153)) ([312e424](https://github.com/folke/lazy.nvim/commit/312e424a084a43b8b786f786b884be60043c23dc)), closes [#445](https://github.com/folke/lazy.nvim/issues/445)
+
+## [10.14.6](https://github.com/folke/lazy.nvim/compare/v10.14.5...v10.14.6) (2023-10-17)
+
+
+### Bug Fixes
+
+* **cmd:** schedule error message instead of showing directly ([03419f3](https://github.com/folke/lazy.nvim/commit/03419f3e5f7590194d599aa8a1a7a7841409d141))
+* **loader:** dont autoload when lazy handlers have not been setup yet. Fixes [#1132](https://github.com/folke/lazy.nvim/issues/1132) ([daab5fe](https://github.com/folke/lazy.nvim/commit/daab5fe2807c55867d5f7cfb6ef0944783361be2))
+* **ui:** running tasks are now less twitchy ([7613ab2](https://github.com/folke/lazy.nvim/commit/7613ab2abb1bd99e039ae02030bc2c48b7626925))
+
+## [10.14.5](https://github.com/folke/lazy.nvim/compare/v10.14.4...v10.14.5) (2023-10-17)
+
+
+### Bug Fixes
+
+* **loader:** fixed event check in reload. Fixes [#1124](https://github.com/folke/lazy.nvim/issues/1124) ([cdfa788](https://github.com/folke/lazy.nvim/commit/cdfa78888159323abc931db26f3301360393fbb7))
+
+## [10.14.4](https://github.com/folke/lazy.nvim/compare/v10.14.3...v10.14.4) (2023-10-16)
+
+
+### Bug Fixes
+
+* **ui:** fixed keymaps in debug view ([fb9795e](https://github.com/folke/lazy.nvim/commit/fb9795e49fcd45e99bf386c675fbca28d98bf0a6))
+
+## [10.14.3](https://github.com/folke/lazy.nvim/compare/v10.14.2...v10.14.3) (2023-10-16)
+
+
+### Performance Improvements
+
+* **plugin:** cache lazy handler values ([c1b9887](https://github.com/folke/lazy.nvim/commit/c1b98873730d7121fec6a2f732b2083cd2cd62bf))
+
+## [10.14.2](https://github.com/folke/lazy.nvim/compare/v10.14.1...v10.14.2) (2023-10-16)
+
+
+### Bug Fixes
+
+* **plugin:** work-around for Plugin.values error. Will add proper fix later. Fixes [#1124](https://github.com/folke/lazy.nvim/issues/1124) ([2270bbb](https://github.com/folke/lazy.nvim/commit/2270bbbc48503f468633cc5c2065321001c4f0ac))
+
+## [10.14.1](https://github.com/folke/lazy.nvim/compare/v10.14.0...v10.14.1) (2023-10-16)
+
+
+### Bug Fixes
+
+* **loader:** don't load handlers before installing plugins ([1cfd6d1](https://github.com/folke/lazy.nvim/commit/1cfd6d1f368ab72690e31cf4d8e15c36d8b60202))
+
+## [10.14.0](https://github.com/folke/lazy.nvim/compare/v10.13.4...v10.14.0) (2023-10-15)
+
+
+### Features
+
+* **plugin:** treat url changes as warnings. They will only be shown with checkhealth ([0c53d46](https://github.com/folke/lazy.nvim/commit/0c53d4673ff02c57a192558325b394cfd9adde0f))
+
+
+### Bug Fixes
+
+* **plugin:** dont allow `dir` changes when we already loaded files from the plugin's old dir. Show an error in this case. Fixes [#993](https://github.com/folke/lazy.nvim/issues/993) ([c8e2091](https://github.com/folke/lazy.nvim/commit/c8e2091e6d2836b587b9892e0fb64afaec36926a))
+* **plugin:** improved dir/dev merging. Fixes [#993](https://github.com/folke/lazy.nvim/issues/993) ([3dc413d](https://github.com/folke/lazy.nvim/commit/3dc413d6fd279dfff777a9f9a964697a16c5aabc))
+
+## [10.13.4](https://github.com/folke/lazy.nvim/compare/v10.13.3...v10.13.4) (2023-10-14)
+
+
+### Bug Fixes
+
+* **cmd:** lazy-cmds no longer show an error for buffer-local commands ([3b31897](https://github.com/folke/lazy.nvim/commit/3b31897275d5c09e2654db1c163b87eb383ca25e))
+
+## [10.13.3](https://github.com/folke/lazy.nvim/compare/v10.13.2...v10.13.3) (2023-10-14)
+
+
+### Bug Fixes
+
+* **ui:** sort lazy plugin handlers ([ad5da0a](https://github.com/folke/lazy.nvim/commit/ad5da0ae20beca5dd89cb17c515c237c46c37b1e))
+
+## [10.13.2](https://github.com/folke/lazy.nvim/compare/v10.13.1...v10.13.2) (2023-10-13)
+
+
+### Bug Fixes
+
+* **float:** disable swapfile for files shown in Float ([3769461](https://github.com/folke/lazy.nvim/commit/37694611946387dc79d546bdc193bc8611ac1c6d))
+* **util:** Util.merge now skips nil args ([70f764b](https://github.com/folke/lazy.nvim/commit/70f764bf735f74aed795188aeb8e57ccae0ae94e))
+
+## [10.13.1](https://github.com/folke/lazy.nvim/compare/v10.13.0...v10.13.1) (2023-10-12)
+
+
+### Bug Fixes
+
+* **git:** unset GIT_INDEX_FILE so we dont accidentally overwrite a different git repo. Fixes [#1107](https://github.com/folke/lazy.nvim/issues/1107) ([7f70dd1](https://github.com/folke/lazy.nvim/commit/7f70dd17497973f2a83e7e46aa7479111174e765))
+
+## [10.13.0](https://github.com/folke/lazy.nvim/compare/v10.12.0...v10.13.0) (2023-10-12)
+
+
+### Features
+
+* **keys:** include custom keys in help menu ([#1105](https://github.com/folke/lazy.nvim/issues/1105)) ([43c284a](https://github.com/folke/lazy.nvim/commit/43c284a57870e1a7ed42782eacf444a6a752f81e))
+
+## [10.12.0](https://github.com/folke/lazy.nvim/compare/v10.11.0...v10.12.0) (2023-10-11)
+
+
+### Features
+
+* **event:** added support for structured events (see readme on event) ([303a3ed](https://github.com/folke/lazy.nvim/commit/303a3ed6a874bb5bdebf11ecdf99e1dfa3eed2c3))
+* **event:** custom lazy event hook for distros ([b65d308](https://github.com/folke/lazy.nvim/commit/b65d3086623448b93bf02055f73819b76ca1dd78))
+
+
+### Bug Fixes
+
+* **ui:** use actual handler values for rendering plugin handlers ([99ee284](https://github.com/folke/lazy.nvim/commit/99ee28473962d9ab8aa11db2d2cc201e38f0f432))
+
+## [10.11.0](https://github.com/folke/lazy.nvim/compare/v10.10.0...v10.11.0) (2023-10-10)
+
+
+### Features
+
+* **util:** expose pretty stacktraces for notify ([7b84609](https://github.com/folke/lazy.nvim/commit/7b84609a06bd11869370bc20a9255bb469e35a50))
+
+## [10.10.0](https://github.com/folke/lazy.nvim/compare/v10.9.1...v10.10.0) (2023-10-10)
+
+
+### Features
+
+* **git:** show error for local changes during check/update ([43e9165](https://github.com/folke/lazy.nvim/commit/43e9165994d76038bd6ebd2d06830a7204ae74e0))
+* **git:** show help on how to remove local changes ([58e5726](https://github.com/folke/lazy.nvim/commit/58e5726592a3f4a83735edfea996911d8daea002))
+
+
+### Bug Fixes
+
+* **docs:** broken table in readme ([#1097](https://github.com/folke/lazy.nvim/issues/1097)) ([89581ce](https://github.com/folke/lazy.nvim/commit/89581ce37e1252133725cb583b5ba4fa0a827270))
+* **git:** automatically restore doc/tags when modified ([736529d](https://github.com/folke/lazy.nvim/commit/736529d097979b3585cbc8e2728543fde9b314ed))
+* **process:** make sure cwd is a valid directory ([92869d0](https://github.com/folke/lazy.nvim/commit/92869d0928ad3bb1aa61cf61897a78f3faa17835))
+
+## [10.9.1](https://github.com/folke/lazy.nvim/compare/v10.9.0...v10.9.1) (2023-10-09)
+
+
+### Bug Fixes
+
+* **manage:** prevent auto conversion 'CRLF' to 'LF' in update lazy-lock.json on Windows. Fixes [#1093](https://github.com/folke/lazy.nvim/issues/1093) ([#1094](https://github.com/folke/lazy.nvim/issues/1094)) ([5579d72](https://github.com/folke/lazy.nvim/commit/5579d72576b21b9c8c2d01838598aece5dc2be6d))
+* **profiling:** ensure proper traces in case of require errors ([2782f81](https://github.com/folke/lazy.nvim/commit/2782f8125e793940f5bf942af1a1df0bbc989d11))
+
+## [10.9.0](https://github.com/folke/lazy.nvim/compare/v10.8.2...v10.9.0) (2023-10-09)
+
+
+### Features
+
+* **profiling:** added options to enable additional profiling ([423a152](https://github.com/folke/lazy.nvim/commit/423a152e94db37dd535d56e6cb6f06b282c5f081))
+
+
+### Performance Improvements
+
+* lazy require commands ([f0cfbf9](https://github.com/folke/lazy.nvim/commit/f0cfbf995238a42064e119bd1daa694fd1683ea3))
+
+## [10.8.2](https://github.com/folke/lazy.nvim/compare/v10.8.1...v10.8.2) (2023-10-08)
+
+
+### Bug Fixes
+
+* **keys:** fixed adding managed keys ([9d92e65](https://github.com/folke/lazy.nvim/commit/9d92e65fd17d35f97bed43dc92810576a57376fc))
+
 ## [10.8.1](https://github.com/folke/lazy.nvim/compare/v10.8.0...v10.8.1) (2023-10-08)
 
 
@@ -304,7 +1148,7 @@
 
 ### Features
 
-* **plugin:** added support for `weak` specs. They will not be included in the final spec if not specified somwhere else ([8564f6d](https://github.com/folke/lazy.nvim/commit/8564f6d22b78a4a0fba9811faa556159b6c90a49))
+* **plugin:** added support for `weak` specs. They will not be included in the final spec if not specified somewhere else ([8564f6d](https://github.com/folke/lazy.nvim/commit/8564f6d22b78a4a0fba9811faa556159b6c90a49))
 
 
 ### Bug Fixes
@@ -325,7 +1169,7 @@
 
 ### Bug Fixes
 
-* **loader:** dont clear tasks when istalling missing plugins ([80c4dec](https://github.com/folke/lazy.nvim/commit/80c4decc3226551b433dfea5e459998a96f17822))
+* **loader:** dont clear tasks when installing missing plugins ([80c4dec](https://github.com/folke/lazy.nvim/commit/80c4decc3226551b433dfea5e459998a96f17822))
 * **loader:** reset cache before installing plugins during startup. Fixes [#803](https://github.com/folke/lazy.nvim/issues/803) ([aecdaab](https://github.com/folke/lazy.nvim/commit/aecdaab6a6ce8c9fdf9f983d5f943c6cfb11bf61))
 
 ## [9.16.0](https://github.com/folke/lazy.nvim/compare/v9.15.0...v9.16.0) (2023-05-13)
@@ -603,7 +1447,7 @@
 ### Features
 
 * deactivate WIP ([57a3960](https://github.com/folke/lazy.nvim/commit/57a3960fafc210f240a07439d1adfaba09d6ff59))
-* use "wslview" instead of "xsl-open" if it exsits ([#509](https://github.com/folke/lazy.nvim/issues/509)) ([2451ea4](https://github.com/folke/lazy.nvim/commit/2451ea4e655bc60ef639ad284e69c6fca15da352))
+* use "wslview" instead of "xsl-open" if it exists ([#509](https://github.com/folke/lazy.nvim/issues/509)) ([2451ea4](https://github.com/folke/lazy.nvim/commit/2451ea4e655bc60ef639ad284e69c6fca15da352))
 
 
 ### Bug Fixes
@@ -945,7 +1789,7 @@
 ### Features
 
 * **git:** added support for packed-refs. Fixes [#260](https://github.com/folke/lazy.nvim/issues/260) ([865ff41](https://github.com/folke/lazy.nvim/commit/865ff414c70d20648000d1b9d754dba64dbf4a62))
-* **ui:** make brower configurable. Fixes [#248](https://github.com/folke/lazy.nvim/issues/248) ([679d85c](https://github.com/folke/lazy.nvim/commit/679d85c9ffb6bd49d27267b3a282eeb73e063cde))
+* **ui:** make browser configurable. Fixes [#248](https://github.com/folke/lazy.nvim/issues/248) ([679d85c](https://github.com/folke/lazy.nvim/commit/679d85c9ffb6bd49d27267b3a282eeb73e063cde))
 * **ui:** show when plugin would be loaded for unloaded plugins. Fixes [#261](https://github.com/folke/lazy.nvim/issues/261) ([5575d2b](https://github.com/folke/lazy.nvim/commit/5575d2b2a9eb7e104d85f4f68754ef3734c7a4a1))
 
 
@@ -1012,7 +1856,7 @@
 
 ### Bug Fixes
 
-* **cache:** ad jit.verion to cache version string. Fixes [#225](https://github.com/folke/lazy.nvim/issues/225) ([e3ffcff](https://github.com/folke/lazy.nvim/commit/e3ffcff7cce1206a2e41b413b0923a3aafeb9306))
+* **cache:** ad jit.version to cache version string. Fixes [#225](https://github.com/folke/lazy.nvim/issues/225) ([e3ffcff](https://github.com/folke/lazy.nvim/commit/e3ffcff7cce1206a2e41b413b0923a3aafeb9306))
 * **cache:** added support for top level lua linked directories. Fixes [#233](https://github.com/folke/lazy.nvim/issues/233) ([853d4d5](https://github.com/folke/lazy.nvim/commit/853d4d58381870a4804ee7d822d3331d3cc5924d))
 * **cache:** always normalize modname separators ([8544c38](https://github.com/folke/lazy.nvim/commit/8544c389ab54dd21c562b2763829670c71266caa))
 * **cache:** check package.loaded after auto-load and return existing module if present. Fixes [#224](https://github.com/folke/lazy.nvim/issues/224) ([044e28b](https://github.com/folke/lazy.nvim/commit/044e28bf8bb454335c63998ef6f21bc34b3e6124))
@@ -1032,7 +1876,7 @@
 * **loader:** show proper error message when trying to load a plugin that is not installed. Fixes [#201](https://github.com/folke/lazy.nvim/issues/201). Fixes [#202](https://github.com/folke/lazy.nvim/issues/202) ([956164d](https://github.com/folke/lazy.nvim/commit/956164d27dc02b8d3c21c9ef7cc9028d854b0978))
 * **loader:** temporary fix for Vimtex and others. See [#230](https://github.com/folke/lazy.nvim/issues/230) ([c7122d6](https://github.com/folke/lazy.nvim/commit/c7122d64cdf16766433588486adcee67571de6d0))
 * **loader:** when `config=true`, pass `nil` to `setup()`. Fixes [#208](https://github.com/folke/lazy.nvim/issues/208) ([5f423b2](https://github.com/folke/lazy.nvim/commit/5f423b29c65f536a9c41a34a8328372baa444da5))
-* only show fired ft events in debug obvioulsy. Fixes [#232](https://github.com/folke/lazy.nvim/issues/232) ([c7c1295](https://github.com/folke/lazy.nvim/commit/c7c1295c3e429d4a95e36b5c5b2dfcbeca61f42d))
+* only show fired ft events in debug obviously. Fixes [#232](https://github.com/folke/lazy.nvim/issues/232) ([c7c1295](https://github.com/folke/lazy.nvim/commit/c7c1295c3e429d4a95e36b5c5b2dfcbeca61f42d))
 * **rtp:** correct order of adding to rtp. Fixes [#226](https://github.com/folke/lazy.nvim/issues/226) ([4e3a973](https://github.com/folke/lazy.nvim/commit/4e3a973f85bd2393009d495ecfd6c058345309d4))
 
 

README.md

@@ -1,4 +1,36 @@
-# 💤 lazy.nvim
+<h4 align="center">
+  <a href="https://lazy.folke.io/installation">Install</a>
+  ·
+  <a href="https://lazy.folke.io/configuration">Configure</a>
+  ·
+  <a href="https://lazy.folke.io">Docs</a>
+</h4>
+
+<div align="center"><p>
+    <a href="https://github.com/folke/lazy.nvim/releases/latest">
+      <img alt="Latest release" src="https://img.shields.io/github/v/release/folke/lazy.nvim?style=for-the-badge&logo=starship&color=C9CBFF&logoColor=D9E0EE&labelColor=302D41&include_prerelease&sort=semver" />
+    </a>
+    <a href="https://github.com/folke/lazy.nvim/pulse">
+      <img alt="Last commit" src="https://img.shields.io/github/last-commit/folke/lazy.nvim?style=for-the-badge&logo=starship&color=8bd5ca&logoColor=D9E0EE&labelColor=302D41"/>
+    </a>
+    <a href="https://github.com/folke/lazy.nvim/blob/main/LICENSE">
+      <img alt="License" src="https://img.shields.io/github/license/folke/lazy.nvim?style=for-the-badge&logo=starship&color=ee999f&logoColor=D9E0EE&labelColor=302D41" />
+    </a>
+    <a href="https://github.com/folke/lazy.nvim/stargazers">
+      <img alt="Stars" src="https://img.shields.io/github/stars/folke/lazy.nvim?style=for-the-badge&logo=starship&color=c69ff5&logoColor=D9E0EE&labelColor=302D41" />
+    </a>
+    <a href="https://github.com/folke/lazy.nvim/issues">
+      <img alt="Issues" src="https://img.shields.io/github/issues/folke/lazy.nvim?style=for-the-badge&logo=bilibili&color=F5E0DC&logoColor=D9E0EE&labelColor=302D41" />
+    </a>
+    <a href="https://github.com/folke/lazy.nvim">
+      <img alt="Repo Size" src="https://img.shields.io/github/repo-size/folke/lazy.nvim?color=%23DDB6F2&label=SIZE&logo=codesandbox&style=for-the-badge&logoColor=D9E0EE&labelColor=302D41" />
+    </a>
+    <a href="https://twitter.com/intent/follow?screen_name=folke">
+      <img alt="follow on Twitter" src="https://img.shields.io/twitter/follow/folke?style=for-the-badge&logo=twitter&color=8aadf3&logoColor=D9E0EE&labelColor=302D41" />
+    </a>
+</div>
+
+
 
 **lazy.nvim** is a modern plugin manager for Neovim.
 
@@ -29,791 +61,9 @@
 - Neovim >= **0.8.0** (needs to be built with **LuaJIT**)
 - Git >= **2.19.0** (for partial clones support)
 - a [Nerd Font](https://www.nerdfonts.com/) **_(optional)_**
+- [luarocks](https://luarocks.org/) to install rockspecs.
+  You can remove `rockspec` from `opts.pkg.sources` to disable this feature.
 
-## 📦 Installation
+## 🚀 Getting Started
 
-You can add the following Lua code to your `init.lua` to bootstrap **lazy.nvim**:
-
-<!-- bootstrap:start -->
-
-```lua
-local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
-if not vim.loop.fs_stat(lazypath) then
-  vim.fn.system({
-    "git",
-    "clone",
-    "--filter=blob:none",
-    "https://github.com/folke/lazy.nvim.git",
-    "--branch=stable", -- latest stable release
-    lazypath,
-  })
-end
-vim.opt.rtp:prepend(lazypath)
-```
-
-<!-- bootstrap:end -->
-
-Next step is to add **lazy.nvim** below the code added in the prior step in `init.lua`:
-
-```lua
-require("lazy").setup(plugins, opts)
-```
-
-- **plugins**: this should be a `table` or a `string`
-  - `table`: a list with your [Plugin Spec](#-plugin-spec)
-  - `string`: a Lua module name that contains your [Plugin Spec](#-plugin-spec). See [Structuring Your Plugins](#-structuring-your-plugins)
-- **opts**: see [Configuration](#%EF%B8%8F-configuration) **_(optional)_**
-
-```lua
--- Example using a list of specs with the default options
-vim.g.mapleader = " " -- Make sure to set `mapleader` before lazy so your mappings are correct
-
-require("lazy").setup({
-  "folke/which-key.nvim",
-  { "folke/neoconf.nvim", cmd = "Neoconf" },
-  "folke/neodev.nvim",
-})
-```
-
-ℹ️ It is recommended to run `:checkhealth lazy` after installation.
-
-## 🔌 Plugin Spec
-
-| Property         | Type                                                                                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                            |
-| ---------------- | ------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **[1]**          | `string?`                                                                                               | Short plugin url. Will be expanded using `config.git.url_format`                                                                                                                                                                                                                                                                                                                                                       |
-| **dir**          | `string?`                                                                                               | A directory pointing to a local plugin                                                                                                                                                                                                                                                                                                                                                                                 |
-| **url**          | `string?`                                                                                               | A custom git url where the plugin is hosted                                                                                                                                                                                                                                                                                                                                                                            |
-| **name**         | `string?`                                                                                               | A custom name for the plugin used for the local plugin directory and as the display name                                                                                                                                                                                                                                                                                                                               |
-| **dev**          | `boolean?`                                                                                              | When `true`, a local plugin directory will be used instead. See `config.dev`                                                                                                                                                                                                                                                                                                                                           |
-| **lazy**         | `boolean?`                                                                                              | When `true`, the plugin will only be loaded when needed. Lazy-loaded plugins are automatically loaded when their Lua modules are `required`, or when one of the lazy-loading handlers triggers                                                                                                                                                                                                                         |
-| **enabled**      | `boolean?` or `fun():boolean`                                                                           | When `false`, or if the `function` returns false, then this plugin will not be included in the spec                                                                                                                                                                                                                                                                                                                    |
-| **cond**         | `boolean?` or `fun(LazyPlugin):boolean`                                                                 | When `false`, or if the `function` returns false, then this plugin will not be loaded. Useful to disable some plugins in vscode, or firenvim for example.                                                                                                                                                                                                                                                              |
-| **dependencies** | `LazySpec[]`                                                                                            | A list of plugin names or plugin specs that should be loaded when the plugin loads. Dependencies are always lazy-loaded unless specified otherwise. When specifying a name, make sure the plugin spec has been defined somewhere else.                                                                                                                                                                                 |
-| **init**         | `fun(LazyPlugin)`                                                                                       | `init` functions are always executed during startup                                                                                                                                                                                                                                                                                                                                                                    |
-| **opts**         | `table` or `fun(LazyPlugin, opts:table)`                                                                | `opts` should be a table (will be merged with parent specs), return a table (replaces parent specs) or should change a table. The table will be passed to the `Plugin.config()` function. Setting this value will imply `Plugin.config()`                                                                                                                                                                              |
-| **config**       | `fun(LazyPlugin, opts:table)` or `true`                                                                 | `config` is executed when the plugin loads. The default implementation will automatically run `require(MAIN).setup(opts)`. Lazy uses several heuristics to determine the plugin's `MAIN` module automatically based on the plugin's **name**. See also `opts`. To use the default implementation without `opts` set `config` to `true`.                                                                                |
-| **main**         | `string?`                                                                                               | You can specify the `main` module to use for `config()` and `opts()`, in case it can not be determined automatically. See `config()`                                                                                                                                                                                                                                                                                   |
-| **build**        | `fun(LazyPlugin)` or `string` or a list of build commands                                               | `build` is executed when a plugin is installed or updated. Before running `build`, a plugin is first loaded. If it's a string it will be ran as a shell command. When prefixed with `:` it is a Neovim command. You can also specify a list to executed multiple build commands. Some plugins provide their own `build.lua` which is automatically used by lazy. So no need to specify a build step for those plugins. |
-| **branch**       | `string?`                                                                                               | Branch of the repository                                                                                                                                                                                                                                                                                                                                                                                               |
-| **tag**          | `string?`                                                                                               | Tag of the repository                                                                                                                                                                                                                                                                                                                                                                                                  |
-| **commit**       | `string?`                                                                                               | Commit of the repository                                                                                                                                                                                                                                                                                                                                                                                               |
-| **version**      | `string?` or `false` to override the default                                                            | Version to use from the repository. Full [Semver](https://devhints.io/semver) ranges are supported                                                                                                                                                                                                                                                                                                                     |
-| **pin**          | `boolean?`                                                                                              | When `true`, this plugin will not be included in updates                                                                                                                                                                                                                                                                                                                                                               |
-| **submodules**   | `boolean?`                                                                                              | When false, git submodules will not be fetched. Defaults to `true`                                                                                                                                                                                                                                                                                                                                                     |
-| **event**        | `string?` or `string[]` or `fun(self:LazyPlugin, event:string[]):string[]`                              | Lazy-load on event. Events can be specified as `BufEnter` or with a pattern like `BufEnter *.lua`                                                                                                                                                                                                                                                                                                                      |
-| **cmd**          | `string?` or `string[]` or `fun(self:LazyPlugin, cmd:string[]):string[]`                                | Lazy-load on command                                                                                                                                                                                                                                                                                                                                                                                                   |
-| **ft**           | `string?` or `string[]` or `fun(self:LazyPlugin, ft:string[]):string[]`                                 | Lazy-load on filetype                                                                                                                                                                                                                                                                                                                                                                                                  |
-| **keys**         | `string?` or `string[]` or `LazyKeys[]` or `fun(self:LazyPlugin, keys:string[]):(string \| LazyKeys)[]` | Lazy-load on key mapping                                                                                                                                                                                                                                                                                                                                                                                               |
-| **module**       | `false?`                                                                                                | Do not automatically load this Lua module when it's required somewhere                                                                                                                                                                                                                                                                                                                                                 |
-| **priority**     | `number?`                                                                                               | Only useful for **start** plugins (`lazy=false`) to force loading certain plugins first. Default priority is `50`. It's recommended to set this to a high number for colorschemes.                                                                                                                                                                                                                                     |
-| **optional**     | `boolean?`                                                                                              | When a spec is tagged optional, it will only be included in the final spec, when the same plugin has been specified at least once somewhere else without `optional`. This is mainly useful for Neovim distros, to allow setting options on plugins that may/may not be part of the user's plugins                                                                                                                      |
-
-### Lazy Loading
-
-**lazy.nvim** automagically lazy-loads Lua modules, so it is not needed to
-specify `module=...` everywhere in your plugin specification. This means that if
-you have a plugin `A` that is lazy-loaded and a plugin `B` that requires a
-module of plugin `A`, then plugin `A` will be loaded on demand as expected.
-
-If you don't want this behavior for a certain plugin, you can specify that with `module=false`.
-You can then manually load the plugin with `:Lazy load foobar.nvim`.
-
-You can configure **lazy.nvim** to lazy-load all plugins by default with `config.defaults.lazy = true`.
-
-Additionally, you can also lazy-load on **events**, **commands**,
-**file types** and **key mappings**.
-
-Plugins will be lazy-loaded when one of the following is `true`:
-
-- The plugin only exists as a dependency in your spec
-- It has an `event`, `cmd`, `ft` or `keys` key
-- `config.defaults.lazy == true`
-
-#### 🌈 Colorschemes
-
-Colorscheme plugins can be configured with `lazy=true`. The plugin will automagically load
-when doing `colorscheme foobar`.
-
-> **NOTE:** since **start** plugins can possibly change existing highlight groups,
-> it's important to make sure that your main **colorscheme** is loaded first.
-> To ensure this you can use the `priority=1000` field. **_(see the examples)_**
-
-#### ⌨️ Lazy Key Mappings
-
-The `keys` property can be a `string` or `string[]` for simple normal-mode mappings, or it
-can be a `LazyKeys` table with the following key-value pairs:
-
-- **[1]**: (`string`) lhs **_(required)_**
-- **[2]**: (`string|fun()`) rhs **_(optional)_**
-- **mode**: (`string|string[]`) mode **_(optional, defaults to `"n"`)_**
-- **ft**: (`string|string[]`) `filetype` for buffer-local keymaps **_(optional)_**
-- any other option valid for `vim.keymap.set`
-
-Key mappings will load the plugin the first time they get executed.
-
-When `[2]` is `nil`, then the real mapping has to be created by the `config()` function.
-
-```lua
--- Example for neo-tree.nvim
-{
-  "nvim-neo-tree/neo-tree.nvim",
-    keys = {
-      { "<leader>ft", "<cmd>Neotree toggle<cr>", desc = "NeoTree" },
-    },
-    config = function()
-      require("neo-tree").setup()
-    end,
-}
-```
-
-### Versioning
-
-If you want to install a specific revision of a plugin, you can use `commit`,
-`tag`, `branch`, `version`.
-
-The `version` property supports [Semver](https://semver.org/) ranges.
-
-<details>
-<summary>Click to see some examples</summary>
-
-- `*`: latest stable version (this excludes pre-release versions)
-- `1.2.x`: any version that starts with `1.2`, such as `1.2.0`, `1.2.3`, etc.
-- `^1.2.3`: any version that is compatible with `1.2.3`, such as `1.3.0`, `1.4.5`, etc., but not `2.0.0`.
-- `~1.2.3`: any version that is compatible with `1.2.3`, such as `1.2.4`, `1.2.5`, but not `1.3.0`.
-- `>1.2.3`: any version that is greater than `1.2.3`, such as `1.3.0`, `1.4.5`, etc.
-- `>=1.2.3`: any version that is greater than or equal to `1.2.3`, such as `1.2.3`, `1.3.0`, `1.4.5`, etc.
-- `<1.2.3`: any version that is less than `1.2.3`, such as `1.1.0`, `1.0.5`, etc.
-- `<=1.2.3`: any version that is less than or equal to `1.2.3`, such as `1.2.3`, `1.1.0`, `1.0.5`, etc
-
-</details>
-
-You can set `config.defaults.version = "*"` to install the latest stable
-version of plugins that support Semver.
-
-### Examples
-
-<!-- spec:start -->
-
-```lua
-return {
-  -- the colorscheme should be available when starting Neovim
-  {
-    "folke/tokyonight.nvim",
-    lazy = false, -- make sure we load this during startup if it is your main colorscheme
-    priority = 1000, -- make sure to load this before all the other start plugins
-    config = function()
-      -- load the colorscheme here
-      vim.cmd([[colorscheme tokyonight]])
-    end,
-  },
-
-  -- I have a separate config.mappings file where I require which-key.
-  -- With lazy the plugin will be automatically loaded when it is required somewhere
-  { "folke/which-key.nvim", lazy = true },
-
-  {
-    "nvim-neorg/neorg",
-    -- lazy-load on filetype
-    ft = "norg",
-    -- options for neorg. This will automatically call `require("neorg").setup(opts)`
-    opts = {
-      load = {
-        ["core.defaults"] = {},
-      },
-    },
-  },
-
-  {
-    "dstein64/vim-startuptime",
-    -- lazy-load on a command
-    cmd = "StartupTime",
-    -- init is called during startup. Configuration for vim plugins typically should be set in an init function
-    init = function()
-      vim.g.startuptime_tries = 10
-    end,
-  },
-
-  {
-    "hrsh7th/nvim-cmp",
-    -- load cmp on InsertEnter
-    event = "InsertEnter",
-    -- these dependencies will only be loaded when cmp loads
-    -- dependencies are always lazy-loaded unless specified otherwise
-    dependencies = {
-      "hrsh7th/cmp-nvim-lsp",
-      "hrsh7th/cmp-buffer",
-    },
-    config = function()
-      -- ...
-    end,
-  },
-
-  -- if some code requires a module from an unloaded plugin, it will be automatically loaded.
-  -- So for api plugins like devicons, we can always set lazy=true
-  { "nvim-tree/nvim-web-devicons", lazy = true },
-
-  -- you can use the VeryLazy event for things that can
-  -- load later and are not important for the initial UI
-  { "stevearc/dressing.nvim", event = "VeryLazy" },
-
-  {
-    "Wansmer/treesj",
-    keys = {
-      { "J", "<cmd>TSJToggle<cr>", desc = "Join Toggle" },
-    },
-    opts = { use_default_keymaps = false, max_join_length = 150 },
-  },
-
-  {
-    "monaqa/dial.nvim",
-    -- lazy-load on keys
-    -- mode is `n` by default. For more advanced options, check the section on key mappings
-    keys = { "<C-a>", { "<C-x>", mode = "n" } },
-  },
-
-  -- local plugins need to be explicitly configured with dir
-  { dir = "~/projects/secret.nvim" },
-
-  -- you can use a custom url to fetch a plugin
-  { url = "git@github.com:folke/noice.nvim.git" },
-
-  -- local plugins can also be configure with the dev option.
-  -- This will use {config.dev.path}/noice.nvim/ instead of fetching it from Github
-  -- With the dev option, you can easily switch between the local and installed version of a plugin
-  { "folke/noice.nvim", dev = true },
-}
-```
-
-<!-- spec:end -->
-
-## ⚙️ Configuration
-
-**lazy.nvim** comes with the following defaults:
-
-<!-- config:start -->
-
-```lua
-{
-  root = vim.fn.stdpath("data") .. "/lazy", -- directory where plugins will be installed
-  defaults = {
-    lazy = false, -- should plugins be lazy-loaded?
-    version = nil,
-    -- default `cond` you can use to globally disable a lot of plugins
-    -- when running inside vscode for example
-    cond = nil, ---@type boolean|fun(self:LazyPlugin):boolean|nil
-    -- version = "*", -- enable this to try installing the latest stable versions of plugins
-  },
-  -- leave nil when passing the spec as the first argument to setup()
-  spec = nil, ---@type LazySpec
-  lockfile = vim.fn.stdpath("config") .. "/lazy-lock.json", -- lockfile generated after running update.
-  concurrency = jit.os:find("Windows") and (vim.loop.available_parallelism() * 2) or nil, ---@type number limit the maximum amount of concurrent tasks
-  git = {
-    -- defaults for the `Lazy log` command
-    -- log = { "-10" }, -- show the last 10 commits
-    log = { "-8" }, -- show commits from the last 3 days
-    timeout = 120, -- kill processes that take more than 2 minutes
-    url_format = "https://github.com/%s.git",
-    -- lazy.nvim requires git >=2.19.0. If you really want to use lazy with an older version,
-    -- then set the below to false. This should work, but is NOT supported and will
-    -- increase downloads a lot.
-    filter = true,
-  },
-  dev = {
-    -- directory where you store your local plugin projects
-    path = "~/projects",
-    ---@type string[] plugins that match these patterns will use your local versions instead of being fetched from GitHub
-    patterns = {}, -- For example {"folke"}
-    fallback = false, -- Fallback to git when local plugin doesn't exist
-  },
-  install = {
-    -- install missing plugins on startup. This doesn't increase startup time.
-    missing = true,
-    -- try to load one of these colorschemes when starting an installation during startup
-    colorscheme = { "habamax" },
-  },
-  ui = {
-    -- a number <1 is a percentage., >1 is a fixed size
-    size = { width = 0.8, height = 0.8 },
-    wrap = true, -- wrap the lines in the ui
-    -- The border to use for the UI window. Accepts same border values as |nvim_open_win()|.
-    border = "none",
-    title = nil, ---@type string only works when border is not "none"
-    title_pos = "center", ---@type "center" | "left" | "right"
-    -- Show pills on top of the Lazy window
-    pills = true, ---@type boolean
-    icons = {
-      cmd = " ",
-      config = "",
-      event = "",
-      ft = " ",
-      init = " ",
-      import = " ",
-      keys = " ",
-      lazy = "󰒲 ",
-      loaded = "●",
-      not_loaded = "○",
-      plugin = " ",
-      runtime = " ",
-      source = " ",
-      start = "",
-      task = "✔ ",
-      list = {
-        "●",
-        "➜",
-        "★",
-        "‒",
-      },
-    },
-    -- leave nil, to automatically select a browser depending on your OS.
-    -- If you want to use a specific browser, you can define it here
-    browser = nil, ---@type string?
-    throttle = 20, -- how frequently should the ui process render events
-    custom_keys = {
-      -- you can define custom key maps here.
-      -- To disable one of the defaults, set it to false
-
-      -- open lazygit log
-      ["<localleader>l"] = function(plugin)
-        require("lazy.util").float_term({ "lazygit", "log" }, {
-          cwd = plugin.dir,
-        })
-      end,
-
-      -- open a terminal for the plugin dir
-      ["<localleader>t"] = function(plugin)
-        require("lazy.util").float_term(nil, {
-          cwd = plugin.dir,
-        })
-      end,
-    },
-  },
-  diff = {
-    -- diff command <d> can be one of:
-    -- * browser: opens the github compare view. Note that this is always mapped to <K> as well,
-    --   so you can have a different command for diff <d>
-    -- * git: will run git diff and open a buffer with filetype git
-    -- * terminal_git: will open a pseudo terminal with git diff
-    -- * diffview.nvim: will open Diffview to show the diff
-    cmd = "git",
-  },
-  checker = {
-    -- automatically check for plugin updates
-    enabled = false,
-    concurrency = nil, ---@type number? set to 1 to check for updates very slowly
-    notify = true, -- get a notification when new updates are found
-    frequency = 3600, -- check for updates every hour
-  },
-  change_detection = {
-    -- automatically check for config file changes and reload the ui
-    enabled = true,
-    notify = true, -- get a notification when changes are found
-  },
-  performance = {
-    cache = {
-      enabled = true,
-    },
-    reset_packpath = true, -- reset the package path to improve startup time
-    rtp = {
-      reset = true, -- reset the runtime path to $VIMRUNTIME and your config directory
-      ---@type string[]
-      paths = {}, -- add any custom paths here that you want to includes in the rtp
-      ---@type string[] list any plugins you want to disable here
-      disabled_plugins = {
-        -- "gzip",
-        -- "matchit",
-        -- "matchparen",
-        -- "netrwPlugin",
-        -- "tarPlugin",
-        -- "tohtml",
-        -- "tutor",
-        -- "zipPlugin",
-      },
-    },
-  },
-  -- lazy can generate helptags from the headings in markdown readme files,
-  -- so :help works even for plugins that don't have vim docs.
-  -- when the readme opens with :help it will be correctly displayed as markdown
-  readme = {
-    enabled = true,
-    root = vim.fn.stdpath("state") .. "/lazy/readme",
-    files = { "README.md", "lua/**/README.md" },
-    -- only generate markdown helptags for plugins that dont have docs
-    skip_if_doc_exists = true,
-  },
-  state = vim.fn.stdpath("state") .. "/lazy/state.json", -- state info for checker and other things
-  build = {
-    -- Plugins can provide a `build.lua` file that will be executed when the plugin is installed
-    -- or updated. When the plugin spec also has a `build` command, the plugin's `build.lua` not be
-    -- executed. In this case, a warning message will be shown.
-    warn_on_override = true,
-  },
-}
-```
-
-<!-- config:end -->
-
-<details>
-<summary>If you don't want to use a Nerd Font, you can replace the icons with Unicode symbols.</summary>
-
-```lua
-{
-  ui = {
-    icons = {
-      cmd = "⌘",
-      config = "🛠",
-      event = "📅",
-      ft = "📂",
-      init = "⚙",
-      keys = "🗝",
-      plugin = "🔌",
-      runtime = "💻",
-      source = "📄",
-      start = "🚀",
-      task = "📌",
-      lazy = "💤 ",
-    },
-  },
-}
-```
-
-</details>
-
-## 🚀 Usage
-
-Plugins are managed with the `:Lazy` command.
-Open the help with `<?>` to see all the key mappings.
-
-You can press `<CR>` on a plugin to show its details. Most properties
-can be hovered with `<K>` to open links, help files, readmes,
-git commits and git issues.
-
-Lazy can automatically check for updates in the background. This feature
-can be enabled with `config.checker.enabled = true`.
-
-Any operation can be started from the UI, with a sub command or an API function:
-
-<!-- commands:start -->
-
-| Command                   | Lua                              | Description                                                                                                                                          |
-| ------------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `:Lazy build {plugins}`   | `require("lazy").build(opts)`    | Rebuild a plugin                                                                                                                                     |
-| `:Lazy check [plugins]`   | `require("lazy").check(opts?)`   | Check for updates and show the log (git fetch)                                                                                                       |
-| `:Lazy clean [plugins]`   | `require("lazy").clean(opts?)`   | Clean plugins that are no longer needed                                                                                                              |
-| `:Lazy clear`             | `require("lazy").clear()`        | Clear finished tasks                                                                                                                                 |
-| `:Lazy debug`             | `require("lazy").debug()`        | Show debug information                                                                                                                               |
-| `:Lazy health`            | `require("lazy").health()`       | Run `:checkhealth lazy`                                                                                                                              |
-| `:Lazy help`              | `require("lazy").help()`         | Toggle this help page                                                                                                                                |
-| `:Lazy home`              | `require("lazy").home()`         | Go back to plugin list                                                                                                                               |
-| `:Lazy install [plugins]` | `require("lazy").install(opts?)` | Install missing plugins                                                                                                                              |
-| `:Lazy load {plugins}`    | `require("lazy").load(opts)`     | Load a plugin that has not been loaded yet. Similar to `:packadd`. Like `:Lazy load foo.nvim`. Use `:Lazy! load` to skip `cond` checks.              |
-| `:Lazy log [plugins]`     | `require("lazy").log(opts?)`     | Show recent updates                                                                                                                                  |
-| `:Lazy profile`           | `require("lazy").profile()`      | Show detailed profiling                                                                                                                              |
-| `:Lazy reload {plugins}`  | `require("lazy").reload(opts)`   | Reload a plugin (experimental!!)                                                                                                                     |
-| `:Lazy restore [plugins]` | `require("lazy").restore(opts?)` | Updates all plugins to the state in the lockfile. For a single plugin: restore it to the state in the lockfile or to a given commit under the cursor |
-| `:Lazy sync [plugins]`    | `require("lazy").sync(opts?)`    | Run install, clean and update                                                                                                                        |
-| `:Lazy update [plugins]`  | `require("lazy").update(opts?)`  | Update plugins. This will also update the lockfile                                                                                                   |
-
-<!-- commands:end -->
-
-Any command can have a **bang** to make the command wait till it finished. For example,
-if you want to sync lazy from the cmdline, you can use:
-
-```shell
-$ nvim --headless "+Lazy! sync" +qa
-```
-
-`opts` is a table with the following key-values:
-
-- **wait**: when true, then the call will wait till the operation completed
-- **show**: when false, the UI will not be shown
-- **plugins**: a list of plugin names to run the operation on
-- **concurrency**: limit the `number` of concurrently running tasks
-
-Stats API (`require("lazy").stats()`):
-
-<!-- stats:start -->
-
-```lua
-{
-  -- startuptime in milliseconds till UIEnter
-  startuptime = 0,
-  -- when true, startuptime is the accurate cputime for the Neovim process. (Linux & Macos)
-  -- this is more accurate than `nvim --startuptime`, and as such will be slightly higher
-  -- when false, startuptime is calculated based on a delta with a timestamp when lazy started.
-  real_cputime = false,
-  count = 0, -- total number of plugins
-  loaded = 0, -- number of loaded plugins
-  ---@type table<string, number>
-  times = {},
-}
-```
-
-<!-- stats:end -->
-
-**lazy.nvim** provides a statusline component that you can use to show the number of pending updates.
-Make sure to enable `config.checker.enabled = true` to make this work.
-
-<details>
-<summary>Example of configuring <a href="https://github.com/nvim-lualine/lualine.nvim">lualine.nvim</a></summary>
-
-```lua
-require("lualine").setup({
-  sections = {
-    lualine_x = {
-      {
-        require("lazy.status").updates,
-        cond = require("lazy.status").has_updates,
-        color = { fg = "#ff9e64" },
-      },
-    },
-  },
-})
-
-```
-
-</details>
-
-### 📆 User Events
-
-The following user events will be triggered:
-
-- **LazyDone**: when lazy has finished starting up and loaded your config
-- **LazySync**: after running sync
-- **LazyInstall**: after an install
-- **LazyUpdate**: after an update
-- **LazyClean**: after a clean
-- **LazyCheck**: after checking for updates
-- **LazyLog**: after running log
-- **LazyLoad**: after loading a plugin. The `data` attribute will contain the plugin name.
-- **LazySyncPre**: before running sync
-- **LazyInstallPre**: before an install
-- **LazyUpdatePre**: before an update
-- **LazyCleanPre**: before a clean
-- **LazyCheckPre**: before checking for updates
-- **LazyLogPre**: before running log
-- **LazyReload**: triggered by change detection after reloading plugin specs
-- **VeryLazy**: triggered after `LazyDone` and processing `VimEnter` auto commands
-- **LazyVimStarted**: triggered after `UIEnter` when `require("lazy").stats().startuptime` has been calculated.
-  Useful to update the startuptime on your dashboard.
-
-## 🔒 Lockfile `lazy-lock.json`
-
-After every **update**, the local lockfile is updated with the installed revisions.
-It is recommended to have this file under version control.
-
-If you use your Neovim config on multiple machines, using the lockfile, you can
-ensure that the same version of every plugin is installed.
-
-If you are on another machine, you can do `:Lazy restore`, to update all your plugins to
-the version from the lockfile.
-
-## ⚡ Performance
-
-Great care has been taken to make the startup code (`lazy.core`) as efficient as possible.
-During startup, all Lua files used before `VimEnter` or `BufReadPre` are byte-compiled and cached,
-similar to what [impatient.nvim](https://github.com/lewis6991/impatient.nvim) does.
-
-My config for example loads in about `11ms` with `93` plugins. I do a lot of lazy-loading though :)
-
-**lazy.nvim** comes with an advanced profiler `:Lazy profile` to help you improve performance.
-The profiling view shows you why and how long it took to load your plugins.
-
-![image](https://user-images.githubusercontent.com/292349/208301766-5c400561-83c3-4811-9667-1ec4bb3c43b8.png)
-
-## 🐛 Debug
-
-See an overview of active lazy-loading handlers and what's in the module cache.
-
-![image](https://user-images.githubusercontent.com/292349/208301790-7eedbfa5-d202-4e70-852e-de68aa47233b.png)
-
-## ▶️ Startup Sequence
-
-**lazy.nvim** does **NOT** use Neovim packages and even disables plugin loading
-completely (`vim.go.loadplugins = false`). It takes over the complete
-startup sequence for more flexibility and better performance.
-
-In practice this means that step 10 of [Neovim Initialization](https://neovim.io/doc/user/starting.html#initialization) is done by Lazy:
-
-1. All the plugins' `init()` functions are executed
-2. All plugins with `lazy=false` are loaded. This includes sourcing `/plugin` and `/ftdetect` files. (`/after` will not be sourced yet)
-3. All files from `/plugin` and `/ftdetect` directories in you rtp are sourced (excluding `/after`)
-4. All `/after/plugin` files are sourced (this includes `/after` from plugins)
-
-Files from runtime directories are always sourced in alphabetical order.
-
-## 📂 Structuring Your Plugins
-
-Some users may want to split their plugin specs in multiple files.
-Instead of passing a spec table to `setup()`, you can use a Lua module.
-The specs from the **module** and any top-level **sub-modules** will be merged together in the final spec,
-so it is not needed to add `require` calls in your main plugin file to the other files.
-
-The benefits of using this approach:
-
-- Simple to **add** new plugin specs. Just create a new file in your plugins module.
-- Allows for **caching** of all your plugin specs. This becomes important if you have a lot of smaller plugin specs.
-- Spec changes will automatically be **reloaded** when they're updated, so the `:Lazy` UI is always up to date.
-
-Example:
-
-- `~/.config/nvim/init.lua`
-
-```lua
-require("lazy").setup("plugins")
-```
-
-- `~/.config/nvim/lua/plugins.lua` or `~/.config/nvim/lua/plugins/init.lua` **_(this file is optional)_**
-
-```lua
-return {
-  "folke/neodev.nvim",
-  "folke/which-key.nvim",
-  { "folke/neoconf.nvim", cmd = "Neoconf" },
-}
-```
-
-- Any lua file in `~/.config/nvim/lua/plugins/*.lua` will be automatically merged in the main plugin spec
-
-For a real-life example, you can check [LazyVim](https://github.com/LazyVim/LazyVim) and more specifically:
-
-- [lazyvim.plugins](https://github.com/LazyVim/LazyVim/tree/main/lua/lazyvim/plugins) contains all the plugin specs that will be loaded
-
-### ↩️ Importing Specs, `config` & `opts`
-
-As part of a spec, you can add `import` statements to import additional plugin modules.
-Both of the `setup()` calls are equivalent:
-
-```lua
-require("lazy").setup("plugins")
-
--- Same as:
-require("lazy").setup({{import = "plugins"}})
-```
-
-To import multiple modules from a plugin, add additional specs for each import.
-For example, to import LazyVim core plugins and an optional plugin:
-
-```lua
-require("lazy").setup({
-  spec = {
-    { "LazyVim/LazyVim", import = "lazyvim.plugins" },
-    { import = "lazyvim.plugins.extras.coding.copilot" },
-  }
-})
-```
-
-When you import specs, you can override them by simply adding a spec for the same plugin to your local
-specs, adding any keys you want to override / merge.
-
-`opts`, `dependencies`, `cmd`, `event`, `ft` and `keys` are always merged with the parent spec.
-Any other property will override the property from the parent spec.
-
-## 📦 Migration Guide
-
-### [packer.nvim](https://github.com/wbthomason/packer.nvim)
-
-- `setup` ➡️ `init`
-- `requires` ➡️ `dependencies`
-- `as` ➡️ `name`
-- `opt` ➡️ `lazy`
-- `run` ➡️ `build`
-- `lock` ➡️ `pin`
-- `disable=true` ➡️ `enabled = false`
-- `tag='*'` ➡️ `version="*"`
-- `after` ℹ️ **_not needed_** for most use-cases. Use `dependencies` otherwise.
-- `wants` ℹ️ **_not needed_** for most use-cases. Use `dependencies` otherwise.
-- `config` don't support string type, use `fun(LazyPlugin)` instead.
-- `module` is auto-loaded. No need to specify
-- `keys` spec is [different](#%EF%B8%8F-lazy-key-mappings)
-- `rtp` can be accomplished with:
-
-```lua
-config = function(plugin)
-    vim.opt.rtp:append(plugin.dir .. "/custom-rtp")
-end
-```
-
-With packer `wants`, `requires` and `after` can be used to manage dependencies.
-With lazy, this isn't needed for most of the Lua dependencies. They can be installed just like normal plugins
-(even with `lazy=true`) and will be loaded when other plugins need them.
-The `dependencies` key can be used to group those required plugins with the one that requires them.
-The plugins which are added as `dependencies` will always be lazy-loaded and loaded when the plugin is loaded.
-
-### [paq-nvim](https://github.com/savq/paq-nvim)
-
-- `as` ➡️ `name`
-- `opt` ➡️ `lazy`
-- `run` ➡️ `build`
-
-## ❌ Uninstalling
-
-To uninstall **lazy.nvim**, you need to remove the following files and directories:
-
-- **data**: `~/.local/share/nvim/lazy`
-- **state**: `~/.local/state/nvim/lazy`
-- **lockfile**: `~/.config/nvim/lazy-lock.json`
-
-> Paths can differ if you changed `XDG` environment variables.
-
-## 🌈 Highlight Groups
-
-<details>
-<summary>Click to see all highlight groups</summary>
-
-<!-- colors:start -->
-
-| Highlight Group       | Default Group              | Description                                         |
-| --------------------- | -------------------------- | --------------------------------------------------- |
-| **LazyButton**        | **_CursorLine_**           |                                                     |
-| **LazyButtonActive**  | **_Visual_**               |                                                     |
-| **LazyComment**       | **_Comment_**              |                                                     |
-| **LazyCommit**        | **_@variable.builtin_**    | commit ref                                          |
-| **LazyCommitIssue**   | **_Number_**               |                                                     |
-| **LazyCommitScope**   | **_Italic_**               | conventional commit scope                           |
-| **LazyCommitType**    | **_Title_**                | conventional commit type                            |
-| **LazyDimmed**        | **_Conceal_**              | property                                            |
-| **LazyDir**           | **_@text.reference_**      | directory                                           |
-| **LazyH1**            | **_IncSearch_**            | home button                                         |
-| **LazyH2**            | **_Bold_**                 | titles                                              |
-| **LazyLocal**         | **_Constant_**             |                                                     |
-| **LazyNoCond**        | **_DiagnosticWarn_**       | unloaded icon for a plugin where `cond()` was false |
-| **LazyNormal**        | **_NormalFloat_**          |                                                     |
-| **LazyProgressDone**  | **_Constant_**             | progress bar done                                   |
-| **LazyProgressTodo**  | **_LineNr_**               | progress bar todo                                   |
-| **LazyProp**          | **_Conceal_**              | property                                            |
-| **LazyReasonCmd**     | **_Operator_**             |                                                     |
-| **LazyReasonEvent**   | **_Constant_**             |                                                     |
-| **LazyReasonFt**      | **_Character_**            |                                                     |
-| **LazyReasonImport**  | **_Identifier_**           |                                                     |
-| **LazyReasonKeys**    | **_Statement_**            |                                                     |
-| **LazyReasonPlugin**  | **_Special_**              |                                                     |
-| **LazyReasonRuntime** | **_@macro_**               |                                                     |
-| **LazyReasonSource**  | **_Character_**            |                                                     |
-| **LazyReasonStart**   | **_@field_**               |                                                     |
-| **LazySpecial**       | **_@punctuation.special_** |                                                     |
-| **LazyTaskError**     | **_ErrorMsg_**             | task errors                                         |
-| **LazyTaskOutput**    | **_MsgArea_**              | task output                                         |
-| **LazyUrl**           | **_@text.reference_**      | url                                                 |
-| **LazyValue**         | **_@string_**              | value of a property                                 |
-
-<!-- colors:end -->
-
-</details>
-
-## 📚 Plugin Authors
-
-If your plugin needs a build step, you can create a file `build.lua` or `build/init.lua`
-in the root of your repo. This file will be loaded when the plugin is installed or updated.
-
-This makes it easier for users, so they no longer need to specify a `build` command.
-
-## 📦 Other Neovim Plugin Managers in Lua
-
-- [pckr.nvim](https://github.com/lewis6991/pckr.nvim)
-- [packer.nvim](https://github.com/wbthomason/packer.nvim)
-- [paq-nvim](https://github.com/savq/paq-nvim)
-- [neopm](https://github.com/ii14/neopm)
-- [dep](https://github.com/chiyadev/dep)
-- [optpack.nvim](https://github.com/notomo/optpack.nvim)
-- [pact.nvim](https://github.com/rktjmp/pact.nvim)
+Check the [documentation website](https://lazy.folke.io/) for more information.

TODO.md

@@ -51,7 +51,7 @@
 
   - [ ] add support to specify `engines`, `os` and `cpu` like in `package.json`
   - [ ] semver merging. Should check if two or more semver ranges are compatible and calculate the union range
-    - default semver merging strategy: if no version matches all, then use highest version?
+    - default semver merging strategy: if no version matches all, then use the highest version?
   - [ ] package meta index (package.lua cache for all packages)
 
 - [x] document highlight groups
@@ -65,7 +65,7 @@
       Maybe a quick, "for example, if you have a lua file
       `~/.config/nvim/lua/config/plugins.lua` that returns a table" or something it'd
       remove most question marks I think.
-- [x] When autoinstalling the plugins the cursor isn't focused on the floating
+- [x] When auto-installing the plugins the cursor isn't focused on the floating
       window, but on the non-floating window in the background.
 - [x] Doing `:Lazy clean` doesn't show which plugins were removed.
 - [x] Shouldn't the "Versioning" section be in the "Lockfile" chapter?

bootstrap.lua

@@ -0,0 +1,51 @@
+-- Lazy Bootstrapper
+-- Usage:
+-- ```lua
+-- load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))()
+-- ```
+local M = {}
+
+function M.setup()
+  local uv = vim.uv or vim.loop
+  if vim.env.LAZY_STDPATH then
+    local root = vim.fn.fnamemodify(vim.env.LAZY_STDPATH, ":p"):gsub("[\\/]$", "")
+    for _, name in ipairs({ "config", "data", "state", "cache" }) do
+      vim.env[("XDG_%s_HOME"):format(name:upper())] = root .. "/" .. name
+    end
+  end
+
+  if vim.env.LAZY_PATH and not uv.fs_stat(vim.env.LAZY_PATH) then
+    vim.env.LAZY_PATH = nil
+  end
+
+  local lazypath = vim.env.LAZY_PATH or vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
+  if not vim.env.LAZY_PATH and not uv.fs_stat(lazypath) then
+    vim.api.nvim_echo({
+      {
+        "Cloning lazy.nvim\n\n",
+        "DiagnosticInfo",
+      },
+    }, true, {})
+    local lazyrepo = "https://github.com/folke/lazy.nvim.git"
+    local ok, out = pcall(vim.fn.system, {
+      "git",
+      "clone",
+      "--filter=blob:none",
+      lazyrepo,
+      lazypath,
+    })
+    if not ok or vim.v.shell_error ~= 0 then
+      vim.api.nvim_echo({
+        { "Failed to clone lazy.nvim\n", "ErrorMsg" },
+        { vim.trim(out or ""), "WarningMsg" },
+        { "\nPress any key to exit...", "MoreMsg" },
+      }, true, {})
+      vim.fn.getchar()
+      os.exit(1)
+    end
+  end
+  vim.opt.rtp:prepend(lazypath)
+end
+M.setup()
+
+return M

lua/lazy/async.lua

@@ -0,0 +1,222 @@
+local Util = require("lazy.core.util")
+
+local M = {}
+
+---@type Async[]
+M._active = {}
+---@type Async[]
+M._suspended = {}
+M._executor = assert(vim.loop.new_check())
+
+M.BUDGET = 10
+
+---@type table<thread, Async>
+M._threads = setmetatable({}, { __mode = "k" })
+
+---@alias AsyncEvent "done" | "error" | "yield" | "ok"
+
+---@class Async
+---@field _co thread
+---@field _fn fun()
+---@field _suspended? boolean
+---@field _on table<AsyncEvent, fun(res:any, async:Async)[]>
+local Async = {}
+
+---@param fn async fun()
+---@return Async
+function Async.new(fn)
+  local self = setmetatable({}, { __index = Async })
+  return self:init(fn)
+end
+
+---@param fn async fun()
+---@return Async
+function Async:init(fn)
+  self._fn = fn
+  self._on = {}
+  self._co = coroutine.create(function()
+    local ok, err = pcall(self._fn)
+    if not ok then
+      self:_emit("error", err)
+    end
+    self:_emit("done")
+  end)
+  M._threads[self._co] = self
+  return M.add(self)
+end
+
+---@param event AsyncEvent
+---@param cb async fun(res:any, async:Async)
+function Async:on(event, cb)
+  self._on[event] = self._on[event] or {}
+  table.insert(self._on[event], cb)
+  return self
+end
+
+---@private
+---@param event AsyncEvent
+---@param res any
+function Async:_emit(event, res)
+  for _, cb in ipairs(self._on[event] or {}) do
+    cb(res, self)
+  end
+end
+
+function Async:running()
+  return coroutine.status(self._co) ~= "dead"
+end
+
+---@async
+function Async:sleep(ms)
+  vim.defer_fn(function()
+    self:resume()
+  end, ms)
+  self:suspend()
+end
+
+---@async
+---@param yield? boolean
+function Async:suspend(yield)
+  self._suspended = true
+  if coroutine.running() == self._co and yield ~= false then
+    M.yield()
+  end
+end
+
+function Async:resume()
+  self._suspended = false
+  M._run()
+end
+
+---@async
+---@param yield? boolean
+function Async:wake(yield)
+  local async = M.running()
+  assert(async, "Not in an async context")
+  self:on("done", function()
+    async:resume()
+  end)
+  async:suspend(yield)
+end
+
+---@async
+function Async:wait()
+  if coroutine.running() == self._co then
+    error("Cannot wait on self")
+  end
+
+  local async = M.running()
+  if async then
+    self:wake()
+  else
+    while self:running() do
+      vim.wait(10)
+    end
+  end
+  return self
+end
+
+function Async:step()
+  if self._suspended then
+    return true
+  end
+  local status = coroutine.status(self._co)
+  if status == "suspended" then
+    local ok, res = coroutine.resume(self._co)
+    if not ok then
+      error(res)
+    elseif res then
+      self:_emit("yield", res)
+    end
+  end
+  return self:running()
+end
+
+function M.abort()
+  for _, async in ipairs(M._active) do
+    coroutine.resume(async._co, "abort")
+  end
+end
+
+function M.yield()
+  if coroutine.yield() == "abort" then
+    error("aborted", 2)
+  end
+end
+
+function M.step()
+  local start = vim.uv.hrtime()
+  for _ = 1, #M._active do
+    if Util.exiting() or vim.uv.hrtime() - start > M.BUDGET * 1e6 then
+      break
+    end
+
+    local state = table.remove(M._active, 1)
+    if state:step() then
+      if state._suspended then
+        table.insert(M._suspended, state)
+      else
+        table.insert(M._active, state)
+      end
+    end
+  end
+  for _ = 1, #M._suspended do
+    local state = table.remove(M._suspended, 1)
+    table.insert(state._suspended and M._suspended or M._active, state)
+  end
+
+  -- M.debug()
+  if #M._active == 0 or Util.exiting() then
+    return M._executor:stop()
+  end
+end
+
+function M.debug()
+  local lines = {
+    "- active: " .. #M._active,
+    "- suspended: " .. #M._suspended,
+  }
+  for _, async in ipairs(M._active) do
+    local info = debug.getinfo(async._fn)
+    local file = vim.fn.fnamemodify(info.short_src:sub(1), ":~:.")
+    table.insert(lines, ("%s:%d"):format(file, info.linedefined))
+    if #lines > 10 then
+      break
+    end
+  end
+  local msg = table.concat(lines, "\n")
+  M._notif = vim.notify(msg, nil, { replace = M._notif })
+end
+
+---@param async Async
+function M.add(async)
+  table.insert(M._active, async)
+  M._run()
+  return async
+end
+
+function M._run()
+  if not Util.exiting() and not M._executor:is_active() then
+    M._executor:start(vim.schedule_wrap(M.step))
+  end
+end
+
+function M.running()
+  local co = coroutine.running()
+  if co then
+    return M._threads[co]
+  end
+end
+
+---@async
+---@param ms number
+function M.sleep(ms)
+  local async = M.running()
+  assert(async, "Not in an async context")
+  async:sleep(ms)
+end
+
+M.Async = Async
+M.new = Async.new
+
+return M

lua/lazy/build.lua

@@ -0,0 +1,100 @@
+vim.opt.rtp:append(".")
+local Rocks = require("lazy.pkg.rockspec")
+local Semver = require("lazy.manage.semver")
+local Util = require("lazy.util")
+
+local M = {}
+
+M.patterns = { "nvim", "treesitter", "tree-sitter", "cmp", "neo" }
+
+function M.fetch(url, file, prefix)
+  if not vim.uv.fs_stat(file) then
+    print((prefix or "") .. "Fetching " .. url .. " to " .. file .. "\n")
+    vim.cmd.redraw()
+    local out = vim.fn.system("wget " .. url .. " -O " .. file)
+    if vim.v.shell_error ~= 0 then
+      pcall(vim.uv.fs_unlink, file)
+      error("Failed to fetch " .. url .. ":\n" .. out)
+    end
+  end
+end
+
+---@return RockManifest?
+function M.fetch_manifest()
+  local manifest_file = "build/manifest.lua"
+  M.fetch("https://luarocks.org/manifest-5.1", manifest_file)
+  return Rocks.parse(manifest_file)
+end
+
+function M.fetch_rockspec(name, version, prefix)
+  version = version or "scm-1"
+  local url = "https://luarocks.org/" .. name .. "-" .. version .. ".rockspec"
+  M.fetch(url, "build/" .. name .. ".rockspec", prefix)
+end
+
+function M.build()
+  vim.fn.mkdir("build", "p")
+  local manifest = M.fetch_manifest() or {}
+  ---@type {name:string, version:string, url:string}[]
+  local nvim_rocks = {}
+  for rock, vv in pairs(manifest.repository or {}) do
+    local matches = false
+    for _, pattern in ipairs(M.patterns) do
+      if rock:find(pattern, 1, true) then
+        matches = true
+        break
+      end
+    end
+    if matches then
+      local versions = vim.tbl_map(Semver.version, vim.tbl_keys(vv))
+      versions = vim.tbl_filter(function(v)
+        return not not v
+      end, versions)
+      local last = Semver.last(versions) or next(vv)
+      last = type(last) == "table" and last.input or last
+      table.insert(nvim_rocks, { name = rock, version = last })
+    end
+  end
+  table.sort(nvim_rocks, function(a, b)
+    return a.name < b.name
+  end)
+
+  for r, rock in ipairs(nvim_rocks) do
+    local progress = string.format("[%d/%d] ", r, #nvim_rocks)
+    local ok, err = pcall(M.fetch_rockspec, rock.name, rock.version, progress)
+    if not ok then
+      err = vim.trim("Error: " .. err)
+      local lines = vim.split(err, "\n")
+      lines = vim.tbl_map(function(line)
+        return "    " .. line
+      end, lines)
+      print(table.concat(lines, "\n") .. "\n")
+    end
+  end
+
+  for _, rock in ipairs(nvim_rocks) do
+    local rockspec = Rocks.rockspec("build/" .. rock.name .. ".rockspec")
+    if rockspec then
+      local url = rockspec.source and rockspec.source.url
+      -- parse github short url
+      if url and url:find("://github.com/") then
+        url = url:gsub("^.*://github.com/", "")
+        local parts = vim.split(url, "/")
+        url = parts[1] .. "/" .. parts[2]
+        url = url:gsub("%.git$", "")
+      end
+      if url then
+        rock.url = url
+        print(rock.name .. " " .. url)
+      else
+        print("Error: " .. rock.name .. " missing source url\n\n")
+        print(vim.inspect(rockspec) .. "\n")
+      end
+    end
+  end
+  Util.write_file("lua/lazy/community/_generated.lua", "return \n" .. vim.inspect(nvim_rocks))
+end
+
+M.build()
+
+return M

lua/lazy/community/init.lua

@@ -0,0 +1,28 @@
+local M = {}
+
+---@type table<string, string>
+local mapping = nil
+
+local function load()
+  if not mapping then
+    mapping = {}
+    ---@type {name:string, url:string, version:string}[]
+    local gen = require("lazy.community._generated")
+    for _, rock in ipairs(gen) do
+      mapping[rock.name] = rock.url
+    end
+  end
+  return mapping
+end
+
+---@param rock string
+---@return string?
+function M.get_url(rock)
+  return load()[rock]
+end
+
+function M.get_spec(name)
+  return require("lazy.community.specs")[name]
+end
+
+return M

lua/lazy/community/specs.lua

@@ -0,0 +1,7 @@
+---@type table<string, LazySpec>
+return {
+  ["plenary.nvim"] = {
+    "nvim-lua/plenary.nvim",
+    lazy = true,
+  },
+}

lua/lazy/core/cache.lua

@@ -1,4 +1,4 @@
-local uv = vim.loop
+local uv = vim.uv or vim.loop
 
 local M = {}
 
@@ -8,7 +8,7 @@ local M = {}
 ---@class ModuleFindOpts
 ---@field all? boolean Search for all matches (defaults to `false`)
 ---@field rtp? boolean Search for modname in the runtime path (defaults to `true`)
----@field patterns? string[] Paterns to use (defaults to `{"/init.lua", ".lua"}`)
+---@field patterns? string[] Patterns to use (defaults to `{"/init.lua", ".lua"}`)
 ---@field paths? string[] Extra paths to search for modname
 
 ---@class ModuleInfo
@@ -51,7 +51,7 @@ end
 ---@private
 function Loader.normalize(path)
   if path:sub(1, 1) == "~" then
-    local home = vim.loop.os_homedir() or "~"
+    local home = uv.os_homedir() or "~"
     if home:sub(-1) == "\\" or home:sub(-1) == "/" then
       home = home:sub(1, -2)
     end
@@ -222,7 +222,7 @@ end
 --- Loads the given module path using the cache
 ---@param modpath string
 ---@param opts? {hash?: CacheHash, mode?: "b"|"t"|"bt", env?:table} (table|nil) Options for loading the module:
----    - hash: (table) the hash of the file to load if it is already known. (defaults to `vim.loop.fs_stat({modpath})`)
+---    - hash: (table) the hash of the file to load if it is already known. (defaults to `vim.uv.fs_stat({modpath})`)
 ---    - mode: (string) the mode to load the module with. "b"|"t"|"bt" (defaults to `nil`)
 ---    - env: (table) the environment to load the module in. (defaults to `nil`)
 ---@see |luaL_loadfile()|
@@ -442,9 +442,9 @@ function Loader.lsmod(path)
   if not Loader._indexed[path] then
     local start = uv.hrtime()
     Loader._indexed[path] = {}
-    local handle = vim.loop.fs_scandir(path .. "/lua")
+    local handle = uv.fs_scandir(path .. "/lua")
     while handle do
-      local name, t = vim.loop.fs_scandir_next(handle)
+      local name, t = uv.fs_scandir_next(handle)
       if not name then
         break
       end
@@ -474,13 +474,13 @@ function Loader.lsmod(path)
   return Loader._indexed[path]
 end
 
---- Debug function that wrapps all loaders and tracks stats
+--- Debug function that wraps all loaders and tracks stats
 ---@private
 function M._profile_loaders()
   for l, loader in pairs(package.loaders) do
     local loc = debug.getinfo(loader, "Sn").source:sub(2)
     package.loaders[l] = function(modname)
-      local start = vim.loop.hrtime()
+      local start = uv.hrtime()
       local ret = loader(modname)
       Loader.track("loader " .. l .. ": " .. loc, start)
       Loader.track("loader_all", start)

lua/lazy/core/config.lua

@@ -7,30 +7,69 @@ local M = {}
 M.defaults = {
   root = vim.fn.stdpath("data") .. "/lazy", -- directory where plugins will be installed
   defaults = {
+    -- Set this to `true` to have all your plugins lazy-loaded by default.
+    -- Only do this if you know what you are doing, as it can lead to unexpected behavior.
     lazy = false, -- should plugins be lazy-loaded?
-    version = nil,
+    -- It's recommended to leave version=false for now, since a lot the plugin that support versioning,
+    -- have outdated releases, which may break your Neovim install.
+    version = nil, -- always use the latest git commit
+    -- version = "*", -- try installing the latest stable version for plugins that support semver
     -- default `cond` you can use to globally disable a lot of plugins
     -- when running inside vscode for example
     cond = nil, ---@type boolean|fun(self:LazyPlugin):boolean|nil
-    -- version = "*", -- enable this to try installing the latest stable versions of plugins
   },
   -- leave nil when passing the spec as the first argument to setup()
   spec = nil, ---@type LazySpec
+  local_spec = true, -- load project specific .lazy.lua spec files. They will be added at the end of the spec.
   lockfile = vim.fn.stdpath("config") .. "/lazy-lock.json", -- lockfile generated after running update.
-  concurrency = jit.os:find("Windows") and (vim.loop.available_parallelism() * 2) or nil, ---@type number limit the maximum amount of concurrent tasks
+  ---@type number? limit the maximum amount of concurrent tasks
+  concurrency = jit.os:find("Windows") and (vim.uv.available_parallelism() * 2) or nil,
   git = {
     -- defaults for the `Lazy log` command
-    -- log = { "-10" }, -- show the last 10 commits
-    log = { "-8" }, -- show commits from the last 3 days
+    -- log = { "--since=3 days ago" }, -- show commits from the last 3 days
+    log = { "-8" }, -- show the last 8 commits
     timeout = 120, -- kill processes that take more than 2 minutes
     url_format = "https://github.com/%s.git",
     -- lazy.nvim requires git >=2.19.0. If you really want to use lazy with an older version,
     -- then set the below to false. This should work, but is NOT supported and will
     -- increase downloads a lot.
     filter = true,
+    -- rate of network related git operations (clone, fetch, checkout)
+    throttle = {
+      enabled = false, -- not enabled by default
+      -- max 2 ops every 5 seconds
+      rate = 2,
+      duration = 5 * 1000, -- in ms
+    },
+    -- Time in seconds to wait before running fetch again for a plugin.
+    -- Repeated update/check operations will not run again until this
+    -- cooldown period has passed.
+    cooldown = 0,
+  },
+  pkg = {
+    enabled = true,
+    cache = vim.fn.stdpath("state") .. "/lazy/pkg-cache.lua",
+    -- the first package source that is found for a plugin will be used.
+    sources = {
+      "lazy",
+      "rockspec", -- will only be used when rocks.enabled is true
+      "packspec",
+    },
+  },
+  rocks = {
+    enabled = true,
+    root = vim.fn.stdpath("data") .. "/lazy-rocks",
+    server = "https://nvim-neorocks.github.io/rocks-binaries/",
+    -- use hererocks to install luarocks?
+    -- set to `nil` to use hererocks when luarocks is not found
+    -- set to `true` to always use hererocks
+    -- set to `false` to always use luarocks
+    hererocks = nil,
   },
   dev = {
-    -- directory where you store your local plugin projects
+    -- Directory where you store your local plugin projects. If a function is used,
+    -- the plugin directory (e.g. `~/projects/plugin-name`) must be returned.
+    ---@type string | fun(plugin: LazyPlugin): string
     path = "~/projects",
     ---@type string[] plugins that match these patterns will use your local versions instead of being fetched from GitHub
     patterns = {}, -- For example {"folke"}
@@ -48,6 +87,8 @@ M.defaults = {
     wrap = true, -- wrap the lines in the ui
     -- The border to use for the UI window. Accepts same border values as |nvim_open_win()|.
     border = "none",
+    -- The backdrop opacity. 0 is fully opaque, 100 is fully transparent.
+    backdrop = 60,
     title = nil, ---@type string only works when border is not "none"
     title_pos = "center", ---@type "center" | "left" | "right"
     -- Show pills on top of the Lazy window
@@ -55,7 +96,9 @@ M.defaults = {
     icons = {
       cmd = " ",
       config = "",
-      event = "",
+      debug = "● ",
+      event = " ",
+      favorite = " ",
       ft = " ",
       init = " ",
       import = " ",
@@ -65,8 +108,9 @@ M.defaults = {
       not_loaded = "○",
       plugin = " ",
       runtime = " ",
+      require = "󰢱 ",
       source = " ",
-      start = "",
+      start = " ",
       task = "✔ ",
       list = {
         "●",
@@ -78,26 +122,52 @@ M.defaults = {
     -- leave nil, to automatically select a browser depending on your OS.
     -- If you want to use a specific browser, you can define it here
     browser = nil, ---@type string?
-    throttle = 20, -- how frequently should the ui process render events
+    throttle = 1000 / 30, -- how frequently should the ui process render events
     custom_keys = {
-      -- you can define custom key maps here.
-      -- To disable one of the defaults, set it to false
+      -- You can define custom key maps here. If present, the description will
+      -- be shown in the help menu.
+      -- To disable one of the defaults, set it to false.
 
-      -- open lazygit log
-      ["<localleader>l"] = function(plugin)
-        require("lazy.util").float_term({ "lazygit", "log" }, {
-          cwd = plugin.dir,
-        })
-      end,
+      ["<localleader>l"] = {
+        function(plugin)
+          require("lazy.util").float_term({ "lazygit", "log" }, {
+            cwd = plugin.dir,
+          })
+        end,
+        desc = "Open lazygit log",
+      },
 
-      -- open a terminal for the plugin dir
-      ["<localleader>t"] = function(plugin)
-        require("lazy.util").float_term(nil, {
-          cwd = plugin.dir,
-        })
-      end,
+      ["<localleader>i"] = {
+        function(plugin)
+          Util.notify(vim.inspect(plugin), {
+            title = "Inspect " .. plugin.name,
+            lang = "lua",
+          })
+        end,
+        desc = "Inspect Plugin",
+      },
+
+      ["<localleader>t"] = {
+        function(plugin)
+          require("lazy.util").float_term(nil, {
+            cwd = plugin.dir,
+          })
+        end,
+        desc = "Open terminal in plugin dir",
+      },
     },
   },
+  -- Output options for headless mode
+  headless = {
+    -- show the output from process commands like git
+    process = true,
+    -- show log messages
+    log = true,
+    -- show task start/end
+    task = true,
+    -- use ansi colors
+    colors = true,
+  },
   diff = {
     -- diff command <d> can be one of:
     -- * browser: opens the github compare view. Note that this is always mapped to <K> as well,
@@ -113,6 +183,7 @@ M.defaults = {
     concurrency = nil, ---@type number? set to 1 to check for updates very slowly
     notify = true, -- get a notification when new updates are found
     frequency = 3600, -- check for updates every hour
+    check_pinned = false, -- check for pinned packages that can't be updated
   },
   change_detection = {
     -- automatically check for config file changes and reload the ui
@@ -148,20 +219,30 @@ M.defaults = {
     enabled = true,
     root = vim.fn.stdpath("state") .. "/lazy/readme",
     files = { "README.md", "lua/**/README.md" },
-    -- only generate markdown helptags for plugins that dont have docs
+    -- only generate markdown helptags for plugins that don't have docs
     skip_if_doc_exists = true,
   },
   state = vim.fn.stdpath("state") .. "/lazy/state.json", -- state info for checker and other things
-  build = {
-    -- Plugins can provide a `build.lua` file that will be executed when the plugin is installed
-    -- or updated. When the plugin spec also has a `build` command, the plugin's `build.lua` not be
-    -- executed. In this case, a warning message will be shown.
-    warn_on_override = true,
+  -- Enable profiling of lazy.nvim. This will add some overhead,
+  -- so only enable this when you are debugging lazy.nvim
+  profiling = {
+    -- Enables extra stats on the debug tab related to the loader cache.
+    -- Additionally gathers stats about all package.loaders
+    loader = false,
+    -- Track each new require in the Lazy profiling tab
+    require = false,
   },
   debug = false,
 }
 
-M.version = "10.8.1" -- x-release-please-version
+function M.hererocks()
+  if M.options.rocks.hererocks == nil then
+    M.options.rocks.hererocks = vim.fn.executable("luarocks") == 0
+  end
+  return M.options.rocks.hererocks
+end
+
+M.version = "11.17.1" -- x-release-please-version
 
 M.ns = vim.api.nvim_create_namespace("lazy")
 
@@ -183,8 +264,13 @@ M.me = nil
 ---@type string
 M.mapleader = nil
 
+---@type string
+M.maplocalleader = nil
+
+M.suspended = false
+
 function M.headless()
-  return #vim.api.nvim_list_uis() == 0
+  return not M.suspended and #vim.api.nvim_list_uis() == 0
 end
 
 ---@param opts? LazyConfig
@@ -196,8 +282,11 @@ function M.setup(opts)
   end
   table.insert(M.options.install.colorscheme, "habamax")
 
+  -- root
   M.options.root = Util.norm(M.options.root)
-  M.options.dev.path = Util.norm(M.options.dev.path)
+  if type(M.options.dev.path) == "string" then
+    M.options.dev.path = Util.norm(M.options.dev.path)
+  end
   M.options.lockfile = Util.norm(M.options.lockfile)
   M.options.readme.root = Util.norm(M.options.readme.root)
 
@@ -209,13 +298,17 @@ function M.setup(opts)
 
   M.me = debug.getinfo(1, "S").source:sub(2)
   M.me = Util.norm(vim.fn.fnamemodify(M.me, ":p:h:h:h:h"))
+  local lib = vim.fn.fnamemodify(vim.v.progpath, ":p:h:h") .. "/lib"
+  lib = vim.uv.fs_stat(lib .. "64") and (lib .. "64") or lib
+  lib = lib .. "/nvim"
   if M.options.performance.rtp.reset then
+    ---@type vim.Option
     vim.opt.rtp = {
       vim.fn.stdpath("config"),
       vim.fn.stdpath("data") .. "/site",
       M.me,
       vim.env.VIMRUNTIME,
-      vim.fn.fnamemodify(vim.v.progpath, ":p:h:h") .. "/lib/nvim",
+      lib,
       vim.fn.stdpath("config") .. "/after",
     }
   end
@@ -227,10 +320,7 @@ function M.setup(opts)
   -- disable plugin loading since we do all of that ourselves
   vim.go.loadplugins = false
   M.mapleader = vim.g.mapleader
-
-  if M.headless() then
-    require("lazy.view.commands").setup()
-  end
+  M.maplocalleader = vim.g.maplocalleader
 
   vim.api.nvim_create_autocmd("UIEnter", {
     once = true,
@@ -239,21 +329,42 @@ function M.setup(opts)
     end,
   })
 
-  vim.api.nvim_create_autocmd("User", {
-    pattern = "VeryLazy",
-    once = true,
-    callback = function()
-      require("lazy.view.commands").setup()
-      if M.options.change_detection.enabled then
-        require("lazy.manage.reloader").enable()
-      end
-      if M.options.checker.enabled then
-        vim.defer_fn(function()
-          require("lazy.manage.checker").start()
-        end, 10)
-      end
-    end,
-  })
+  if M.headless() then
+    require("lazy.view.commands").setup()
+  else
+    vim.api.nvim_create_autocmd("User", {
+      pattern = "VeryLazy",
+      once = true,
+      callback = function()
+        require("lazy.view.commands").setup()
+        if M.options.change_detection.enabled then
+          require("lazy.manage.reloader").enable()
+        end
+        if M.options.checker.enabled then
+          vim.defer_fn(function()
+            require("lazy.manage.checker").start()
+          end, 10)
+        end
+
+        -- useful for plugin developers when making changes to a packspec file
+        vim.api.nvim_create_autocmd("BufWritePost", {
+          pattern = { "lazy.lua", "pkg.json", "*.rockspec" },
+          callback = function()
+            local plugin = require("lazy.core.plugin").find(vim.uv.cwd() .. "/lua/")
+            if plugin then
+              require("lazy").pkg({ plugins = { plugin } })
+            end
+          end,
+        })
+
+        vim.api.nvim_create_autocmd({ "VimSuspend", "VimResume" }, {
+          callback = function(ev)
+            M.suspended = ev.event == "VimSuspend"
+          end,
+        })
+      end,
+    })
+  end
 
   Util.very_lazy()
 end

lua/lazy/core/fragments.lua

@@ -0,0 +1,174 @@
+local Config = require("lazy.core.config")
+local Util = require("lazy.core.util")
+
+--- This class is used to manage the fragments of a plugin spec.
+--- It keeps track of the fragments and their relations to other fragments.
+--- A fragment can be a dependency (dependencies) or a child (specs) of another fragment.
+---@class LazyFragments
+---@field fragments table<number, LazyFragment>
+---@field frag_stack number[]
+---@field dep_stack number[]
+---@field dirty table<number, boolean>
+---@field plugins table<LazyPlugin, number>
+---@field spec LazySpecLoader
+local M = {}
+
+M._fid = 0
+
+local function next_id()
+  M._fid = M._fid + 1
+  return M._fid
+end
+
+---@param spec LazySpecLoader
+---@return LazyFragments
+function M.new(spec)
+  local self = setmetatable({}, { __index = M })
+  self.fragments = {}
+  self.frag_stack = {}
+  self.dep_stack = {}
+  self.spec = spec
+  self.dirty = {}
+  self.plugins = {}
+  return self
+end
+
+---@param id number
+function M:get(id)
+  return self.fragments[id]
+end
+
+--- Remove a fragment and all its children.
+--- This will also remove the fragment from its parent's children list.
+---@param id number
+function M:del(id)
+  -- del fragment
+  local fragment = self.fragments[id]
+  if not fragment then
+    return
+  end
+
+  self.dirty[id] = true
+
+  -- remove from parent
+  local pid = fragment.pid
+  if pid then
+    local parent = self.fragments[pid]
+    if parent.frags then
+      ---@param fid number
+      parent.frags = Util.filter(function(fid)
+        return fid ~= id
+      end, parent.frags)
+    end
+    if parent.deps then
+      ---@param fid number
+      parent.deps = Util.filter(function(fid)
+        return fid ~= id
+      end, parent.deps)
+    end
+    self.dirty[pid] = true
+  end
+
+  -- remove children
+  if fragment.frags then
+    for _, fid in ipairs(fragment.frags) do
+      self:del(fid)
+    end
+  end
+
+  self.fragments[id] = nil
+end
+
+--- Add a fragment to the fragments list.
+--- This also resolves its name, url, dir, dependencies and child specs.
+---@param plugin LazyPluginSpec
+function M:add(plugin)
+  if self.plugins[plugin] then
+    return self.fragments[self.plugins[plugin]]
+  end
+
+  local id = next_id()
+  setmetatable(plugin, nil)
+
+  self.plugins[plugin] = id
+
+  local pid = self.frag_stack[#self.frag_stack]
+
+  ---@type LazyFragment
+  local fragment = {
+    id = id,
+    pid = pid,
+    name = plugin.name,
+    url = plugin.url,
+    dir = plugin.dir,
+    spec = plugin --[[@as LazyPlugin]],
+  }
+
+  -- short url / ref
+  if plugin[1] then
+    local slash = plugin[1]:find("/", 1, true)
+    if slash then
+      local prefix = plugin[1]:sub(1, 4)
+      if prefix == "http" or prefix == "git@" then
+        fragment.url = fragment.url or plugin[1]
+      else
+        fragment.name = fragment.name or plugin[1]:sub(slash + 1)
+        fragment.url = fragment.url or Config.options.git.url_format:format(plugin[1])
+      end
+    else
+      fragment.name = fragment.name or plugin[1]
+    end
+  end
+
+  -- name
+  fragment.name = fragment.name
+    or fragment.url and self.spec.get_name(fragment.url)
+    or fragment.dir and self.spec.get_name(fragment.dir)
+  if not fragment.name or fragment.name == "" then
+    return self.spec:error("Invalid plugin spec " .. vim.inspect(plugin))
+  end
+
+  if type(plugin.config) == "table" then
+    self.spec:warn(
+      "{" .. fragment.name .. "}: setting a table to `Plugin.config` is deprecated. Please use `Plugin.opts` instead"
+    )
+    ---@diagnostic disable-next-line: assign-type-mismatch
+    plugin.opts = plugin.config
+    plugin.config = nil
+  end
+
+  self.fragments[id] = fragment
+
+  -- add to parent
+  if pid then
+    local parent = self.fragments[pid]
+    parent.frags = parent.frags or {}
+    table.insert(parent.frags, id)
+  end
+
+  -- add to parent's deps
+  local did = self.dep_stack[#self.dep_stack]
+  if did and did == pid then
+    fragment.dep = true
+    local parent = self.fragments[did]
+    parent.deps = parent.deps or {}
+    table.insert(parent.deps, id)
+  end
+
+  table.insert(self.frag_stack, id)
+  -- dependencies
+  if plugin.dependencies then
+    table.insert(self.dep_stack, id)
+    self.spec:normalize(plugin.dependencies)
+    table.remove(self.dep_stack)
+  end
+  -- child specs
+  if plugin.specs then
+    self.spec:normalize(plugin.specs)
+  end
+  table.remove(self.frag_stack)
+
+  return fragment
+end
+
+return M

lua/lazy/core/handler/cmd.lua

@@ -1,5 +1,5 @@
-local Util = require("lazy.core.util")
 local Loader = require("lazy.core.loader")
+local Util = require("lazy.core.util")
 
 ---@class LazyCmdHandler:LazyHandler
 local M = {}
@@ -33,9 +33,12 @@ function M:_add(cmd)
 
     self:_load(cmd)
 
-    local info = vim.api.nvim_get_commands({})[cmd]
+    local info = vim.api.nvim_get_commands({})[cmd] or vim.api.nvim_buf_get_commands(0, {})[cmd]
     if not info then
-      return Util.error("Command `" .. cmd .. "` not found after loading " .. plugins)
+      vim.schedule(function()
+        Util.error("Command `" .. cmd .. "` not found after loading " .. plugins)
+      end)
+      return
     end
 
     command.nargs = info.nargs

lua/lazy/core/handler/event.lua

@@ -1,15 +1,17 @@
-local Util = require("lazy.core.util")
 local Config = require("lazy.core.config")
 local Loader = require("lazy.core.loader")
+local Util = require("lazy.core.util")
 
 ---@class LazyEventOpts
 ---@field event string
----@field pattern? string
 ---@field group? string
 ---@field exclude? string[]
 ---@field data? any
 ---@field buffer? number
 
+---@alias LazyEvent {id:string, event:string[]|string, pattern?:string[]|string}
+---@alias LazyEventSpec string|{event?:string|string[], pattern?:string|string[]}|string[]
+
 ---@class LazyEventHandler:LazyHandler
 ---@field events table<string,true>
 ---@field group number
@@ -21,74 +23,97 @@ M.triggers = {
   BufReadPost = "BufReadPre",
 }
 
+-- A table of mappings for custom events
+-- Can be used by distros to add custom events (see usage in LazyVim)
+---@type table<string, LazyEvent>
+M.mappings = {
+  VeryLazy = { id = "VeryLazy", event = "User", pattern = "VeryLazy" },
+  -- Example:
+  -- LazyFile = { id = "LazyFile", event = { "BufReadPost", "BufNewFile", "BufWritePre" } },
+}
+M.mappings["User VeryLazy"] = M.mappings.VeryLazy
+
 M.group = vim.api.nvim_create_augroup("lazy_handler_event", { clear = true })
 
----@param value string
-function M:_add(value)
-  local event_spec = self:_event(value)
-  ---@type string?, string?
-  local event, pattern = event_spec:match("^(%w+)%s+(.*)$")
-  event = event or event_spec
+---@param spec LazyEventSpec
+---@return LazyEvent
+function M:_parse(spec)
+  local ret = M.mappings[spec] --[[@as LazyEvent?]]
+  if ret then
+    return ret
+  end
+  if type(spec) == "string" then
+    local event, pattern = spec:match("^(%w+)%s+(.*)$")
+    event = event or spec
+    return { id = spec, event = event, pattern = pattern }
+  elseif Util.is_list(spec) then
+    ret = { id = table.concat(spec, "|"), event = spec }
+  else
+    ret = spec --[[@as LazyEvent]]
+    if not ret.id then
+      ---@diagnostic disable-next-line: assign-type-mismatch, param-type-mismatch
+      ret.id = type(ret.event) == "string" and ret.event or table.concat(ret.event, "|")
+      if ret.pattern then
+        ---@diagnostic disable-next-line: assign-type-mismatch, param-type-mismatch
+        ret.id = ret.id .. " " .. (type(ret.pattern) == "string" and ret.pattern or table.concat(ret.pattern, ", "))
+      end
+    end
+  end
+  return ret
+end
+
+---@param event LazyEvent
+function M:_add(event)
   local done = false
-  vim.api.nvim_create_autocmd(event, {
+  vim.api.nvim_create_autocmd(event.event, {
     group = self.group,
     once = true,
-    pattern = pattern,
+    pattern = event.pattern,
     callback = function(ev)
-      if done or not self.active[value] then
+      if done or not self.active[event.id] then
         return
       end
+      -- HACK: work-around for https://github.com/neovim/neovim/issues/25526
       done = true
-      Util.track({ [self.type] = value })
+      if event.id ~= "VeryLazy" then
+        Util.track({ [self.type] = event.id })
+      end
 
-      local state = M.get_state(ev.event, pattern, ev.buf, ev.data)
+      local state = M.get_state(ev.event, ev.buf, ev.data)
 
       -- load the plugins
-      Loader.load(self.active[value], { [self.type] = value })
+      Loader.load(self.active[event.id], { [self.type] = event.id })
 
       -- check if any plugin created an event handler for this event and fire the group
       for _, s in ipairs(state) do
         M.trigger(s)
       end
-      Util.track()
+      if event.id ~= "VeryLazy" then
+        Util.track()
+      end
     end,
   })
 end
 
 -- Get the current state of the event and all the events that will be fired
 ---@param event string
----@param pattern? string
 ---@param buf number
 ---@param data any
-function M.get_state(event, pattern, buf, data)
+function M.get_state(event, buf, data)
   local state = {} ---@type LazyEventOpts[]
   while event do
     table.insert(state, 1, {
       event = event,
-      pattern = pattern,
       exclude = event ~= "FileType" and M.get_augroups(event) or nil,
       buffer = buf,
       data = data,
     })
     data = nil -- only pass the data to the first event
-    if event == "FileType" then
-      pattern = nil -- only use the pattern for the first event
-    end
     event = M.triggers[event]
   end
   return state
 end
 
----@param value string
-function M:_event(value)
-  if value == "VeryLazy" then
-    return "User VeryLazy"
-  elseif value == "BufRead" then
-    return "BufReadPost"
-  end
-  return value
-end
-
 -- Get all augroups for the events
 ---@param event string
 function M.get_augroups(event)
@@ -127,7 +152,6 @@ function M._trigger(opts)
     Util.info({
       "# Firing Events",
       "  - **event:** " .. opts.event,
-      opts.pattern and ("  - **pattern:** " .. opts.pattern),
       opts.group and ("  - **group:** " .. opts.group),
       opts.buffer and ("  - **buffer:** " .. opts.buffer),
     })
@@ -135,7 +159,6 @@ function M._trigger(opts)
   Util.track({ event = opts.group or opts.event })
   Util.try(function()
     vim.api.nvim_exec_autocmds(opts.event, {
-      -- pattern = opts.pattern,
       buffer = opts.buffer,
       group = opts.group,
       modeline = false,

lua/lazy/core/handler/ft.lua

@@ -5,11 +5,6 @@ local Loader = require("lazy.core.loader")
 local M = {}
 M.extends = Event
 
----@param value string
-function M:_event(value)
-  return "FileType " .. value
-end
-
 ---@param plugin LazyPlugin
 function M:add(plugin)
   self.super.add(self, plugin)
@@ -18,4 +13,13 @@ function M:add(plugin)
   end
 end
 
+---@return LazyEvent
+function M:_parse(value)
+  return {
+    id = value,
+    event = "FileType",
+    pattern = value,
+  }
+end
+
 return M

lua/lazy/core/handler/init.lua

@@ -1,11 +1,11 @@
-local Util = require("lazy.core.util")
 local Config = require("lazy.core.config")
+local Util = require("lazy.core.util")
 
 ---@class LazyHandler
 ---@field type LazyHandlerTypes
 ---@field extends? LazyHandler
 ---@field active table<string,table<string,string>>
----@field managed table<string,string>
+---@field managed table<string,string> mapping handler keys to plugin names
 ---@field super LazyHandler
 local M = {}
 
@@ -39,20 +39,19 @@ end
 
 ---@param plugin LazyPlugin
 function M.disable(plugin)
-  for type, handler in pairs(M.handlers) do
-    if plugin[type] then
-      handler:del(plugin)
-    end
+  for type in pairs(plugin._.handlers or {}) do
+    M.handlers[type]:del(plugin)
   end
 end
 
 ---@param plugin LazyPlugin
 function M.enable(plugin)
   if not plugin._.loaded then
-    for type, handler in pairs(M.handlers) do
-      if plugin[type] then
-        handler:add(plugin)
-      end
+    if not plugin._.handlers then
+      M.resolve(plugin)
+    end
+    for type in pairs(plugin._.handlers or {}) do
+      M.handlers[type]:add(plugin)
     end
   end
 end
@@ -78,32 +77,55 @@ function M:_add(_value) end
 ---@protected
 function M:_del(_value) end
 
+---@param value any
+---@param _plugin LazyPlugin
+---@return string|{id:string}
+function M:_parse(value, _plugin)
+  assert(type(value) == "string", "Expected string, got " .. vim.inspect(value))
+  return value
+end
+
+---@param values any[]
 ---@param plugin LazyPlugin
-function M:values(plugin)
+function M:_values(values, plugin)
   ---@type table<string,any>
-  local values = {}
-  ---@diagnostic disable-next-line: no-unknown
-  for _, value in ipairs(plugin[self.type] or {}) do
-    values[value] = value
+  local ret = {}
+  for _, value in ipairs(values) do
+    local parsed = self:_parse(value, plugin)
+    ret[type(parsed) == "string" and parsed or parsed.id] = parsed
+  end
+  return ret
+end
+
+---@param plugin LazyPlugin
+function M.resolve(plugin)
+  local Plugin = require("lazy.core.plugin")
+  plugin._.handlers = {}
+  for type, handler in pairs(M.handlers) do
+    if plugin[type] then
+      plugin._.handlers[type] = handler:_values(Plugin.values(plugin, type, true), plugin)
+    end
   end
-  return values
 end
 
 ---@param plugin LazyPlugin
 function M:add(plugin)
-  for key, value in pairs(self:values(plugin)) do
+  for key, value in pairs(plugin._.handlers[self.type] or {}) do
     if not self.active[key] then
       self.active[key] = {}
       self:_add(value)
+      self.managed[key] = plugin.name
     end
-    self.managed[key] = self.managed[key]
     self.active[key][plugin.name] = plugin.name
   end
 end
 
 ---@param plugin LazyPlugin
 function M:del(plugin)
-  for key, value in pairs(self:values(plugin)) do
+  if not plugin._.handlers then
+    return
+  end
+  for key, value in pairs(plugin._.handlers[self.type] or {}) do
     if self.active[key] and self.active[key][plugin.name] then
       self.active[key][plugin.name] = nil
       if vim.tbl_isempty(self.active[key]) then

lua/lazy/core/handler/keys.lua

@@ -1,5 +1,5 @@
-local Util = require("lazy.core.util")
 local Loader = require("lazy.core.loader")
+local Util = require("lazy.core.util")
 
 ---@class LazyKeysBase
 ---@field desc? string
@@ -11,7 +11,7 @@ local Loader = require("lazy.core.loader")
 
 ---@class LazyKeysSpec: LazyKeysBase
 ---@field [1] string lhs
----@field [2]? string|fun()|false rhs
+---@field [2]? string|fun():string?|false rhs
 ---@field mode? string|string[]
 
 ---@class LazyKeys: LazyKeysBase
@@ -19,10 +19,13 @@ local Loader = require("lazy.core.loader")
 ---@field rhs? string|fun() rhs
 ---@field mode? string
 ---@field id string
+---@field name string
 
 ---@class LazyKeysHandler:LazyHandler
 local M = {}
 
+local skip = { mode = true, id = true, ft = true, rhs = true, lhs = true }
+
 ---@param value string|LazyKeysSpec
 ---@param mode? string
 ---@return LazyKeys
@@ -37,22 +40,32 @@ function M.parse(value, mode)
   ret[2] = nil
   ret.mode = mode or "n"
   ret.id = vim.api.nvim_replace_termcodes(ret.lhs, true, true, true)
+
+  if ret.ft then
+    local ft = type(ret.ft) == "string" and { ret.ft } or ret.ft --[[@as string[] ]]
+    ret.id = ret.id .. " (" .. table.concat(ft, ", ") .. ")"
+  end
+
   if ret.mode ~= "n" then
     ret.id = ret.id .. " (" .. ret.mode .. ")"
   end
   return ret
 end
 
+---@param keys LazyKeys
+function M.to_string(keys)
+  return keys.lhs .. (keys.mode == "n" and "" or " (" .. keys.mode .. ")")
+end
+
 ---@param lhs string
 ---@param mode? string
 function M:have(lhs, mode)
   local keys = M.parse(lhs, mode)
-  return self.managed[keys.id]
+  return self.managed[keys.id] ~= nil
 end
 
----@param plugin LazyPlugin
-function M:values(plugin)
-  return M.resolve(plugin.keys)
+function M:_values(values)
+  return M.resolve(values)
 end
 
 ---@param spec? (string|LazyKeysSpec)[]
@@ -78,7 +91,6 @@ end
 
 ---@param keys LazyKeys
 function M.opts(keys)
-  local skip = { mode = true, id = true, ft = true, rhs = true, lhs = true }
   local opts = {} ---@type LazyKeysBase
   ---@diagnostic disable-next-line: no-unknown
   for k, v in pairs(keys) do
@@ -90,6 +102,11 @@ function M.opts(keys)
   return opts
 end
 
+---@param keys LazyKeys
+function M.is_nop(keys)
+  return type(keys.rhs) == "string" and (keys.rhs == "" or keys.rhs:lower() == "<nop>")
+end
+
 ---@param keys LazyKeys
 function M:_add(keys)
   local lhs = keys.lhs
@@ -97,6 +114,10 @@ function M:_add(keys)
 
   ---@param buf? number
   local function add(buf)
+    if M.is_nop(keys) then
+      return self:_set(keys, buf)
+    end
+
     vim.keymap.set(keys.mode, lhs, function()
       local plugins = self.active[keys.id]
 
@@ -105,16 +126,15 @@ function M:_add(keys)
       self.active[keys.id] = nil
 
       if plugins then
-        Util.track({ keys = lhs })
-        Loader.load(plugins, { keys = lhs })
+        local name = M.to_string(keys)
+        Util.track({ keys = name })
+        Loader.load(plugins, { keys = name })
         Util.track()
       end
 
-      -- Create the real buffer-local mapping
-      if keys.ft then
-        self:_set(keys, buf)
+      if keys.mode:sub(-1) == "a" then
+        lhs = lhs .. "<C-]>"
       end
-
       local feed = vim.api.nvim_replace_termcodes("<Ignore>" .. lhs, true, true, true)
       -- insert instead of append the lhs
       vim.api.nvim_feedkeys(feed, "i", false)
@@ -132,7 +152,7 @@ function M:_add(keys)
     vim.api.nvim_create_autocmd("FileType", {
       pattern = keys.ft,
       callback = function(event)
-        if self.active[keys.id] then
+        if self.active[keys.id] and not M.is_nop(keys) then
           add(event.buf)
         else
           -- Only create the mapping if its managed by lazy
@@ -146,15 +166,24 @@ function M:_add(keys)
   end
 end
 
--- Delete a mapping and create the real global
+-- Delete a mapping and create the real global/buffer-local
 -- mapping when needed
 ---@param keys LazyKeys
 function M:_del(keys)
-  pcall(vim.keymap.del, keys.mode, keys.lhs)
-  -- make sure to create global mappings when needed
-  -- buffer-local mappings are managed by lazy
-  if not keys.ft then
-    self:_set(keys)
+  -- bufs will be all buffers of the filetype for a buffer-local mapping
+  -- OR `false` for a global mapping
+  local bufs = { false }
+
+  if keys.ft then
+    local ft = type(keys.ft) == "string" and { keys.ft } or keys.ft --[[@as string[] ]]
+    bufs = vim.tbl_filter(function(buf)
+      return vim.tbl_contains(ft, vim.bo[buf].filetype)
+    end, vim.api.nvim_list_bufs())
+  end
+
+  for _, buf in ipairs(bufs) do
+    pcall(vim.keymap.del, keys.mode, keys.lhs, { buffer = buf or nil })
+    self:_set(keys, buf or nil)
   end
 end
 

lua/lazy/core/loader.lua

@@ -1,8 +1,8 @@
-local Util = require("lazy.core.util")
+local Cache = require("lazy.core.cache")
 local Config = require("lazy.core.config")
 local Handler = require("lazy.core.handler")
 local Plugin = require("lazy.core.plugin")
-local Cache = require("lazy.core.cache")
+local Util = require("lazy.core.util")
 
 ---@class LazyCoreLoader
 local M = {}
@@ -16,6 +16,7 @@ M.init_done = false
 M.disabled_rtp_plugins = { packer_compiled = true }
 ---@type table<string,string>
 M.did_ftdetect = {}
+M.did_handlers = false
 
 function M.disable_rtp_plugin(plugin)
   M.disabled_rtp_plugins[plugin] = true
@@ -43,12 +44,14 @@ function M.setup()
     while M.install_missing() do
       count = count + 1
       if count > 5 then
+        Util.error("Too many rounds of missing plugins")
         break
       end
     end
     Util.track()
   end
   Config.mapleader = vim.g.mapleader
+  Config.maplocalleader = vim.g.maplocalleader
 
   -- report any warnings & errors
   Config.spec:report()
@@ -56,6 +59,7 @@ function M.setup()
   -- setup handlers
   Util.track("handlers")
   Handler.setup()
+  M.did_handlers = true
   Util.track()
 end
 
@@ -63,8 +67,14 @@ end
 -- multiple rounds can happen when importing a spec from a missing plugin
 function M.install_missing()
   for _, plugin in pairs(Config.plugins) do
-    if not (plugin._.installed or Plugin.has_errors(plugin)) then
+    local installed = plugin._.installed
+    local has_errors = Plugin.has_errors(plugin)
+
+    if not has_errors and not (installed and not plugin._.build) then
       for _, colorscheme in ipairs(Config.options.install.colorscheme) do
+        if colorscheme == "default" then
+          break
+        end
         M.colorscheme(colorscheme)
         if vim.g.colors_name or pcall(vim.cmd.colorscheme, colorscheme) then
           break
@@ -94,7 +104,7 @@ function M.startup()
   M.source(vim.env.VIMRUNTIME .. "/filetype.lua")
 
   -- backup original rtp
-  local rtp = vim.opt.rtp:get()
+  local rtp = vim.opt.rtp:get() --[[@as string[] ]]
 
   -- 1. run plugin init
   Util.track({ start = "init" })
@@ -125,7 +135,7 @@ function M.startup()
     if not path:find("after/?$") then
       -- these paths don't will already have their ftdetect ran,
       -- by sourcing filetype.lua above, so skip them
-      M.did_ftdetect[path] = true
+      M.did_ftdetect[path] = path
       M.packadd(path)
     end
   end
@@ -133,7 +143,9 @@ function M.startup()
 
   -- 4. load after plugins
   Util.track({ start = "after" })
-  for _, path in ipairs(vim.opt.rtp:get()) do
+  for _, path in
+    ipairs(vim.opt.rtp:get() --[[@as string[] ]])
+  do
     if path:find("after/?$") then
       M.source_runtime(path, "plugin")
     end
@@ -149,7 +161,7 @@ function M.get_start_plugins()
   ---@type LazyPlugin[]
   local start = {}
   for _, plugin in pairs(Config.plugins) do
-    if plugin.lazy == false and not plugin._.loaded then
+    if not plugin._.loaded and (plugin._.rtp_loaded or plugin.lazy == false) then
       start[#start + 1] = plugin
     end
   end
@@ -214,6 +226,9 @@ function M.deactivate(plugin)
   -- disable handlers
   Handler.disable(plugin)
 
+  -- clear plugin properties cache
+  plugin._.cache = nil
+
   -- remove loaded lua modules
   Util.walkmods(plugin.dir .. "/lua", function(modname)
     package.loaded[modname] = nil
@@ -259,8 +274,10 @@ function M.reload(plugin)
     load = true
   end
 
-  for _, event in ipairs(plugin.event or {}) do
-    if event == "VimEnter" or event == "UIEnter" or event:find("VeryLazy") then
+  local events = plugin._.handlers and plugin._.handlers.event and plugin._.handlers.event or {}
+
+  for _, event in pairs(events) do
+    if event.id:find("VimEnter") or event.id:find("UIEnter") or event.id:find("VeryLazy") then
       load = true
       break
     end
@@ -324,7 +341,13 @@ function M._load(plugin, reason, opts)
   Util.track({ plugin = plugin.name, start = reason.start })
   Handler.disable(plugin)
 
-  M.add_to_rtp(plugin)
+  if not plugin.virtual then
+    M.add_to_rtp(plugin)
+  end
+
+  if plugin._.pkg and plugin._.pkg.source == "rockspec" then
+    M.add_to_luapath(plugin)
+  end
 
   if plugin.dependencies then
     Util.try(function()
@@ -332,7 +355,9 @@ function M._load(plugin, reason, opts)
     end, "Failed to load deps for " .. plugin.name)
   end
 
-  M.packadd(plugin.dir)
+  if not plugin.virtual then
+    M.packadd(plugin.dir)
+  end
   if plugin.config or plugin.opts then
     M.config(plugin)
   end
@@ -443,10 +468,8 @@ function M.add_to_rtp(plugin)
   local rtp = vim.api.nvim_get_runtime_file("", true)
   local idx_dir, idx_after
 
-  local is_win = jit.os:find("Windows")
-
   for i, path in ipairs(rtp) do
-    if is_win then
+    if Util.is_win then
       path = Util.norm(path)
     end
     if path == Config.me then
@@ -461,13 +484,26 @@ function M.add_to_rtp(plugin)
   table.insert(rtp, idx_dir or (#rtp + 1), plugin.dir)
 
   local after = plugin.dir .. "/after"
-  if vim.loop.fs_stat(after) then
+  if vim.uv.fs_stat(after) then
     table.insert(rtp, idx_after or (#rtp + 1), after)
   end
 
+  ---@type vim.Option
   vim.opt.rtp = rtp
 end
 
+---@param plugin LazyPlugin
+function M.add_to_luapath(plugin)
+  local root = Config.options.rocks.root .. "/" .. plugin.name
+  local path = root .. "/share/lua/5.1"
+  local cpath = root .. "/lib/lua/5.1"
+  local cpath2 = root .. "/lib64/lua/5.1"
+
+  package.path = package.path .. ";" .. path .. "/?.lua;" .. path .. "/?/init.lua;"
+  package.cpath = package.cpath .. ";" .. cpath .. "/?." .. (jit.os:find("Windows") and "dll" or "so") .. ";"
+  package.cpath = package.cpath .. ";" .. cpath2 .. "/?." .. (jit.os:find("Windows") and "dll" or "so") .. ";"
+end
+
 function M.source(path)
   Util.track({ runtime = path })
   Util.try(function()
@@ -484,7 +520,7 @@ function M.colorscheme(name)
     if not plugin._.loaded then
       for _, ext in ipairs({ "lua", "vim" }) do
         local path = plugin.dir .. "/colors/" .. name .. "." .. ext
-        if vim.loop.fs_stat(path) then
+        if vim.uv.fs_stat(path) then
           return M.load(plugin, { colorscheme = name })
         end
       end
@@ -493,10 +529,14 @@ function M.colorscheme(name)
 end
 
 function M.auto_load(modname, modpath)
-  local plugin = Plugin.find(modpath)
-  if plugin and modpath:find(plugin.dir, 1, true) == 1 then
-    -- don't load if we're loading specs or if the plugin is already loaded
-    if not (Plugin.loading or plugin._.loaded) then
+  local plugin = Plugin.find(modpath, { fast = not M.did_handlers })
+  if plugin then
+    plugin._.rtp_loaded = true
+    -- don't load if:
+    -- * handlers haven't been setup yet
+    -- * we're loading specs
+    -- * the plugin is already loaded
+    if M.did_handlers and not (Plugin.loading or plugin._.loaded) then
       if plugin.module == false then
         error("Plugin " .. plugin.name .. " is not loaded and is configured with module=false")
       end
@@ -505,16 +545,22 @@ function M.auto_load(modname, modpath)
         error("You're trying to load `" .. plugin.name .. "` for which `cond==false`")
       end
     end
-    return true
   end
-  return false
 end
 
 ---@param modname string
 function M.loader(modname)
-  local paths = Util.get_unloaded_rtp(modname)
+  local paths, cached = Util.get_unloaded_rtp(modname, { cache = true })
   local ret = Cache.find(modname, { rtp = false, paths = paths })[1]
+
+  if not ret and cached then
+    paths = Util.get_unloaded_rtp(modname)
+    ret = Cache.find(modname, { rtp = false, paths = paths })[1]
+  end
+
   if ret then
+    -- explicitly set to nil to prevent loading errors
+    package.loaded[modname] = nil
     M.auto_load(modname, ret.modpath)
     local mod = package.loaded[modname]
     if type(mod) == "table" then

lua/lazy/core/meta.lua

@@ -0,0 +1,360 @@
+local Config = require("lazy.core.config")
+local Pkg = require("lazy.pkg")
+local Util = require("lazy.core.util")
+
+--- This class is used to manage the plugins.
+--- A plugin is a collection of fragments that are related to each other.
+---@class LazyMeta
+---@field plugins table<string, LazyPlugin>
+---@field str_to_meta table<string, LazyPlugin>
+---@field frag_to_meta table<number, LazyPlugin>
+---@field dirty table<string, boolean>
+---@field spec LazySpecLoader
+---@field fragments LazyFragments
+---@field pkgs table<string, number>
+local M = {}
+
+---@param spec LazySpecLoader
+---@return LazyMeta
+function M.new(spec)
+  local self = setmetatable({}, { __index = M })
+  self.spec = spec
+  self.fragments = require("lazy.core.fragments").new(spec)
+  self.plugins = {}
+  self.frag_to_meta = {}
+  self.str_to_meta = {}
+  self.dirty = {}
+  self.pkgs = {}
+  return self
+end
+
+-- import package specs
+function M:load_pkgs()
+  if not Config.options.pkg.enabled then
+    return
+  end
+  for _, pkg in ipairs(Pkg.get()) do
+    local last_id = self.fragments._fid
+    local meta, fragment = self:add(pkg.spec)
+    if meta and fragment then
+      meta._.pkg = pkg
+      -- tag all top-level package fragments that were added as optional
+      for _, fid in ipairs(meta._.frags) do
+        if fid > last_id then
+          local frag = self.fragments:get(fid)
+          frag.spec.optional = true
+        end
+      end
+      -- keep track of the top-level package fragment
+      self.pkgs[pkg.dir] = fragment.id
+    end
+  end
+end
+
+--- Remove a plugin and all its fragments.
+---@param name string
+function M:del(name)
+  local meta = self.plugins[name]
+  if not meta then
+    return
+  end
+  for _, fid in ipairs(meta._.frags or {}) do
+    self.fragments:del(fid)
+  end
+  self.plugins[name] = nil
+end
+
+--- Add a fragment to a plugin.
+--- This will create a new plugin if it does not exist.
+--- It also keeps track of renames.
+---@param plugin LazyPluginSpec
+function M:add(plugin)
+  local fragment = self.fragments:add(plugin)
+  if not fragment then
+    return
+  end
+
+  local meta = self.plugins[fragment.name]
+    or fragment.url and self.str_to_meta[fragment.url]
+    or fragment.dir and self.str_to_meta[fragment.dir]
+
+  if not meta then
+    meta = { name = fragment.name, _ = { frags = {} } }
+    local url, dir = fragment.url, fragment.dir
+    -- add to index
+    if url then
+      self.str_to_meta[url] = meta
+    end
+    if dir then
+      self.str_to_meta[dir] = meta
+    end
+  end
+
+  table.insert(meta._.frags, fragment.id)
+
+  if meta._ and meta._.rtp_loaded and meta.dir then
+    local old_dir = meta.dir
+    self:_rebuild(meta.name)
+    local new_dir = meta.dir
+    if old_dir ~= new_dir then
+      local msg = "Plugin `" .. meta.name .. "` changed `dir`:\n- from: `" .. old_dir .. "`\n- to: `" .. new_dir .. "`"
+      msg = msg .. "\n\nThis plugin was already partially loaded, so things may break.\nPlease fix your config."
+      self.spec:error(msg)
+    end
+  end
+
+  if plugin.name then
+    -- handle renames
+    if meta.name ~= plugin.name then
+      self.plugins[meta.name] = nil
+      meta.name = plugin.name
+    end
+  end
+
+  self.plugins[meta.name] = meta
+  self.frag_to_meta[fragment.id] = meta
+  self.dirty[meta.name] = true
+  return meta, fragment
+end
+
+--- Rebuild all plugins based on dirty fragments,
+--- or dirty plugins. Will remove plugins that no longer have fragments.
+function M:rebuild()
+  local frag_count = vim.tbl_count(self.fragments.dirty)
+  local plugin_count = vim.tbl_count(self.dirty)
+  if frag_count == 0 and plugin_count == 0 then
+    return
+  end
+  if Config.options.debug then
+    Util.track("rebuild plugins frags=" .. frag_count .. " plugins=" .. plugin_count)
+  end
+  for fid in pairs(self.fragments.dirty) do
+    local meta = self.frag_to_meta[fid]
+    if meta then
+      if self.fragments:get(fid) then
+        -- fragment still exists, so mark plugin as dirty
+        self.dirty[meta.name] = true
+      else
+        -- fragment was deleted, so remove it from plugin
+        self.frag_to_meta[fid] = nil
+        ---@param f number
+        meta._.frags = Util.filter(function(f)
+          return f ~= fid
+        end, meta._.frags)
+        -- if no fragments left, delete plugin
+        if #meta._.frags == 0 then
+          self:del(meta.name)
+        else
+          self.dirty[meta.name] = true
+        end
+      end
+    end
+  end
+  self.fragments.dirty = {}
+  for n, _ in pairs(self.dirty) do
+    self:_rebuild(n)
+  end
+  if Config.options.debug then
+    Util.track()
+  end
+end
+
+--- Rebuild a single plugin.
+--- This will resolve the plugin based on its fragments using metatables.
+--- This also resolves dependencies, dep, optional, dir, dev, and url.
+---@param name string
+function M:_rebuild(name)
+  if not self.dirty[name] then
+    return
+  end
+  self.dirty[name] = nil
+  local plugin = self.plugins[name]
+  if not plugin or #plugin._.frags == 0 then
+    self.plugins[name] = nil
+    return
+  end
+  setmetatable(plugin, nil)
+  plugin.dependencies = {}
+
+  local super = nil
+  plugin.url = nil
+  plugin._.dep = true
+  plugin._.top = true
+  plugin.optional = true
+
+  assert(#plugin._.frags > 0, "no fragments found for plugin " .. name)
+
+  ---@type table<number, boolean>
+  local added = {}
+  for _, fid in ipairs(plugin._.frags) do
+    if not added[fid] then
+      added[fid] = true
+      local fragment = self.fragments:get(fid)
+      assert(fragment, "fragment " .. fid .. " not found, for plugin " .. name)
+      ---@diagnostic disable-next-line: no-unknown
+      super = setmetatable(fragment.spec, super and { __index = super } or nil)
+      plugin._.dep = plugin._.dep and fragment.dep
+      plugin.optional = plugin.optional and (rawget(fragment.spec, "optional") == true)
+      plugin.url = fragment.url or plugin.url
+      plugin._.top = plugin._.top and fragment.pid == nil
+
+      -- dependencies
+      for _, dep in ipairs(fragment.deps or {}) do
+        local dep_meta = self.frag_to_meta[dep]
+        if dep_meta then
+          table.insert(plugin.dependencies, dep_meta.name)
+        end
+      end
+    end
+  end
+
+  super = super or {}
+
+  -- dir / dev
+  plugin.dev = super.dev
+  plugin.dir = super.dir
+  if plugin.dir then
+    plugin.dir = Util.norm(plugin.dir)
+  elseif super.virtual then
+    plugin.dir = Util.norm("/dev/null/" .. plugin.name)
+  else
+    if plugin.dev == nil and plugin.url then
+      for _, pattern in ipairs(Config.options.dev.patterns) do
+        if plugin.url:find(pattern, 1, true) then
+          plugin.dev = true
+          break
+        end
+      end
+    end
+    if plugin.dev == true then
+      local dev_dir = type(Config.options.dev.path) == "string" and Config.options.dev.path .. "/" .. plugin.name
+        or Util.norm(Config.options.dev.path(plugin))
+      if not Config.options.dev.fallback or vim.fn.isdirectory(dev_dir) == 1 then
+        plugin.dir = dev_dir
+      else
+        plugin.dev = false
+      end
+    end
+    plugin.dir = plugin.dir or Config.options.root .. "/" .. plugin.name
+  end
+
+  -- dependencies
+  if #plugin.dependencies == 0 and not super.dependencies then
+    plugin.dependencies = nil
+  end
+
+  -- optional
+  if not plugin.optional and not super.optional then
+    plugin.optional = nil
+  end
+
+  setmetatable(plugin, { __index = super })
+
+  return plugin
+end
+
+--- Disable a plugin.
+---@param plugin LazyPlugin
+function M:disable(plugin)
+  plugin._.kind = "disabled"
+  self:del(plugin.name)
+  self.spec.disabled[plugin.name] = plugin
+end
+
+--- Check if a plugin should be disabled, but ignore uninstalling it.
+function M:fix_cond()
+  for _, plugin in pairs(self.plugins) do
+    local cond = plugin.cond
+    if cond == nil then
+      cond = Config.options.defaults.cond
+    end
+    if cond == false or (type(cond) == "function" and not cond(plugin)) then
+      plugin._.cond = false
+      local stack = { plugin }
+      while #stack > 0 do
+        local p = table.remove(stack) --[[@as LazyPlugin]]
+        if not self.spec.ignore_installed[p.name] then
+          for _, dep in ipairs(p.dependencies or {}) do
+            table.insert(stack, self.plugins[dep])
+          end
+          self.spec.ignore_installed[p.name] = true
+        end
+      end
+      plugin.enabled = false
+    end
+  end
+end
+
+--- Removes plugins for which all its fragments are optional.
+function M:fix_optional()
+  if self.spec.optional then
+    return 0
+  end
+  local changes = 0
+  for _, plugin in pairs(self.plugins) do
+    if plugin.optional then
+      changes = changes + 1
+      self:del(plugin.name)
+    end
+  end
+  self:rebuild()
+  return changes
+end
+
+--- Removes plugins that are disabled.
+function M:fix_disabled()
+  local changes = 0
+  local function check(top)
+    for _, plugin in pairs(self.plugins) do
+      if (plugin._.top or false) == top then
+        if plugin.enabled == false or (type(plugin.enabled) == "function" and not plugin.enabled()) then
+          changes = changes + 1
+          if plugin.optional then
+            self:del(plugin.name)
+          else
+            self:disable(plugin)
+          end
+          self:rebuild()
+        end
+      end
+    end
+  end
+  -- disable top-level plugins first, since they may have non-top-level frags
+  -- that disable other plugins
+  check(true)
+  -- then disable non-top-level plugins
+  check(false)
+  return changes
+end
+
+--- Removes package fragments for plugins that no longer use the same directory.
+function M:fix_pkgs()
+  for dir, fid in pairs(self.pkgs) do
+    local plugin = self.frag_to_meta[fid]
+    plugin = plugin and self.plugins[plugin.name]
+    if plugin then
+      -- check if plugin is still in the same directory
+      if plugin.dir ~= dir then
+        self.fragments:del(fid)
+      end
+    end
+  end
+  self:rebuild()
+end
+
+--- Resolve all plugins, based on cond, enabled and optional.
+function M:resolve()
+  Util.track("resolve plugins")
+  self:rebuild()
+
+  self:fix_pkgs()
+
+  self:fix_cond()
+
+  -- selene: allow(empty_loop)
+  while self:fix_disabled() + self:fix_optional() > 0 do
+  end
+  Util.track()
+end
+
+return M

lua/lazy/core/plugin.lua

@@ -1,16 +1,16 @@
 local Config = require("lazy.core.config")
+local Meta = require("lazy.core.meta")
+local Pkg = require("lazy.pkg")
 local Util = require("lazy.core.util")
-local Handler = require("lazy.core.handler")
 
 ---@class LazyCorePlugin
 local M = {}
 M.loading = false
 
 ---@class LazySpecLoader
+---@field meta LazyMeta
 ---@field plugins table<string, LazyPlugin>
----@field fragments table<number, LazyPlugin>
 ---@field disabled table<string, LazyPlugin>
----@field dirty table<string, true>
 ---@field ignore_installed table<string, true>
 ---@field modules string[]
 ---@field notifs {msg:string, level:number, file?:string}[]
@@ -18,42 +18,44 @@ M.loading = false
 ---@field optional? boolean
 local Spec = {}
 M.Spec = Spec
-M.last_fid = 0
-M.fid_stack = {} ---@type number[]
+M.LOCAL_SPEC = ".lazy.lua"
 
 ---@param spec? LazySpec
----@param opts? {optional?:boolean}
+---@param opts? {optional?:boolean, pkg?:boolean}
 function Spec.new(spec, opts)
-  local self = setmetatable({}, { __index = Spec })
-  self.plugins = {}
-  self.fragments = {}
+  local self = setmetatable({}, Spec)
+  self.meta = Meta.new(self)
   self.disabled = {}
   self.modules = {}
-  self.dirty = {}
   self.notifs = {}
   self.ignore_installed = {}
   self.optional = opts and opts.optional
+  if not (opts and opts.pkg == false) then
+    self.meta:load_pkgs()
+  end
   if spec then
     self:parse(spec)
   end
   return self
 end
 
-function Spec:parse(spec)
-  self:normalize(spec)
-  self:fix_disabled()
-
-  -- calculate handlers
-  for _, plugin in pairs(self.plugins) do
-    for _, handler in pairs(Handler.types) do
-      if plugin[handler] then
-        plugin[handler] = M.values(plugin, handler, true)
-      end
-    end
+function Spec:__index(key)
+  if Spec[key] then
+    return Spec[key]
+  end
+  if key == "plugins" then
+    self.meta:rebuild()
+    return self.meta.plugins
   end
 end
 
+function Spec:parse(spec)
+  self:normalize(spec)
+  self.meta:resolve()
+end
+
 -- PERF: optimized code to get package name without using lua patterns
+---@return string
 function Spec.get_name(pkg)
   local name = pkg:sub(-4) == ".git" and pkg:sub(1, -5) or pkg
   name = name:sub(-1) == "/" and name:sub(1, -2) or name
@@ -61,108 +63,6 @@ function Spec.get_name(pkg)
   return slash and name:sub(#name - slash + 2) or pkg:gsub("%W+", "_")
 end
 
----@param plugin LazyPlugin
----@param results? string[]
-function Spec:add(plugin, results)
-  -- check if we already processed this spec. Can happen when a user uses the same instance of a spec in multiple specs
-  -- see https://github.com/folke/lazy.nvim/issues/45
-  if rawget(plugin, "_") then
-    if results then
-      table.insert(results, plugin.name)
-    end
-    return plugin
-  end
-
-  local is_ref = plugin[1] and not plugin[1]:find("/", 1, true)
-
-  if not plugin.url and not is_ref and plugin[1] then
-    local prefix = plugin[1]:sub(1, 4)
-    if prefix == "http" or prefix == "git@" then
-      plugin.url = plugin[1]
-    else
-      plugin.url = Config.options.git.url_format:format(plugin[1])
-    end
-  end
-
-  if plugin.dir then
-    plugin.dir = Util.norm(plugin.dir)
-    -- local plugin
-    plugin.name = plugin.name or Spec.get_name(plugin.dir)
-  elseif plugin.url then
-    plugin.name = plugin.name or Spec.get_name(plugin.url)
-    -- check for dev plugins
-    if plugin.dev == nil then
-      for _, pattern in ipairs(Config.options.dev.patterns) do
-        if plugin.url:find(pattern, 1, true) then
-          plugin.dev = true
-          break
-        end
-      end
-    end
-    -- dev plugins
-    if
-      plugin.dev
-      and (not Config.options.dev.fallback or vim.fn.isdirectory(Config.options.dev.path .. "/" .. plugin.name) == 1)
-    then
-      plugin.dir = Config.options.dev.path .. "/" .. plugin.name
-    else
-      -- remote plugin
-      plugin.dir = Config.options.root .. "/" .. plugin.name
-    end
-  elseif is_ref then
-    plugin.name = plugin[1]
-  else
-    self:error("Invalid plugin spec " .. vim.inspect(plugin))
-    return
-  end
-
-  if not plugin.name or plugin.name == "" then
-    self:error("Plugin spec " .. vim.inspect(plugin) .. " has no name")
-    return
-  end
-
-  if type(plugin.config) == "table" then
-    self:warn(
-      "{" .. plugin.name .. "}: setting a table to `Plugin.config` is deprecated. Please use `Plugin.opts` instead"
-    )
-    ---@diagnostic disable-next-line: assign-type-mismatch
-    plugin.opts = plugin.config
-    plugin.config = nil
-  end
-
-  local fpid = M.fid_stack[#M.fid_stack]
-
-  M.last_fid = M.last_fid + 1
-  plugin._ = {
-    fid = M.last_fid,
-    fpid = fpid,
-    dep = fpid ~= nil,
-    module = self.importing,
-  }
-  self.fragments[plugin._.fid] = plugin
-
-  if fpid then
-    local parent = self.fragments[fpid]
-    parent._.fdeps = parent._.fdeps or {}
-    table.insert(parent._.fdeps, plugin._.fid)
-  end
-
-  if plugin.dependencies then
-    table.insert(M.fid_stack, plugin._.fid)
-    plugin.dependencies = self:normalize(plugin.dependencies, {})
-    table.remove(M.fid_stack)
-  end
-
-  if self.plugins[plugin.name] then
-    plugin = self:merge(self.plugins[plugin.name], plugin)
-  end
-  self.plugins[plugin.name] = plugin
-  if results then
-    table.insert(results, plugin.name)
-  end
-  return plugin
-end
-
 function Spec:error(msg)
   self:log(msg, vim.log.levels.ERROR)
 end
@@ -171,155 +71,6 @@ function Spec:warn(msg)
   self:log(msg, vim.log.levels.WARN)
 end
 
---- Rebuilds a plugin spec excluding any removed fragments
----@param name? string
-function Spec:rebuild(name)
-  if not name then
-    for n, _ in pairs(self.dirty) do
-      self:rebuild(n)
-    end
-    self.dirty = {}
-  end
-  local plugin = self.plugins[name]
-  if not plugin then
-    return
-  end
-
-  local fragments = {} ---@type LazyPlugin[]
-
-  repeat
-    local super = plugin._.super
-    if self.fragments[plugin._.fid] then
-      plugin._.dep = plugin._.fpid ~= nil
-      plugin._.super = nil
-      if plugin._.fdeps then
-        plugin.dependencies = {}
-        for _, cid in ipairs(plugin._.fdeps) do
-          if self.fragments[cid] then
-            table.insert(plugin.dependencies, self.fragments[cid].name)
-          end
-        end
-      end
-      setmetatable(plugin, nil)
-      table.insert(fragments, 1, plugin)
-    end
-    plugin = super
-  until not plugin
-
-  if #fragments == 0 then
-    self.plugins[name] = nil
-    return
-  end
-
-  plugin = fragments[1]
-  for i = 2, #fragments do
-    plugin = self:merge(plugin, fragments[i])
-  end
-  self.plugins[name] = plugin
-end
-
---- Recursively removes all fragments from a plugin spec or a given fragment
----@param id string|number Plugin name or fragment id
----@param opts {self: boolean}
-function Spec:remove_fragments(id, opts)
-  local fids = {} ---@type number[]
-
-  if type(id) == "number" then
-    fids[1] = id
-  else
-    local plugin = self.plugins[id]
-    repeat
-      fids[#fids + 1] = plugin._.fid
-      plugin = plugin._.super
-    until not plugin
-  end
-
-  for _, fid in ipairs(fids) do
-    local fragment = self.fragments[fid]
-    if fragment then
-      for _, cid in ipairs(fragment._.fdeps or {}) do
-        self:remove_fragments(cid, { self = true })
-      end
-      if opts.self then
-        self.fragments[fid] = nil
-      end
-      self.dirty[fragment.name] = true
-    end
-  end
-end
-
-function Spec:fix_cond()
-  for _, plugin in pairs(self.plugins) do
-    local cond = plugin.cond
-    if cond == nil then
-      cond = Config.options.defaults.cond
-    end
-    if cond == false or (type(cond) == "function" and not cond(plugin)) then
-      plugin._.cond = false
-      local stack = { plugin }
-      while #stack > 0 do
-        local p = table.remove(stack)
-        if not self.ignore_installed[p.name] then
-          for _, dep in ipairs(p.dependencies or {}) do
-            table.insert(stack, self.plugins[dep])
-          end
-          self.ignore_installed[p.name] = true
-        end
-      end
-      plugin.enabled = false
-    end
-  end
-end
-
-function Spec:fix_optional()
-  if not self.optional then
-    ---@param plugin LazyPlugin
-    local function all_optional(plugin)
-      return (not plugin) or (rawget(plugin, "optional") and all_optional(plugin._.super))
-    end
-
-    -- handle optional plugins
-    for _, plugin in pairs(self.plugins) do
-      if plugin.optional and all_optional(plugin) then
-        -- remove all optional fragments
-        self:remove_fragments(plugin.name, { self = true })
-        self.plugins[plugin.name] = nil
-      end
-    end
-  end
-end
-
-function Spec:fix_disabled()
-  for _, plugin in pairs(self.plugins) do
-    if not plugin.name or not plugin.dir then
-      self:error("Plugin spec for **" .. plugin.name .. "** not found.\n```lua\n" .. vim.inspect(plugin) .. "\n```")
-      self.plugins[plugin.name] = nil
-    end
-  end
-
-  self:fix_optional()
-  self:rebuild()
-
-  self:fix_cond()
-  self:rebuild()
-
-  self.dirty = {}
-
-  for _, plugin in pairs(self.plugins) do
-    local disabled = plugin.enabled == false or (type(plugin.enabled) == "function" and not plugin.enabled())
-    if disabled then
-      plugin._.kind = "disabled"
-      -- remove all child fragments
-      self:remove_fragments(plugin.name, { self = false })
-      self.plugins[plugin.name] = nil
-      self.disabled[plugin.name] = plugin
-    end
-  end
-
-  -- rebuild any plugin specs that were modified
-  self:rebuild()
-end
-
 ---@param msg string
 ---@param level number
 function Spec:log(msg, level)
@@ -328,37 +79,32 @@ end
 
 function Spec:report(level)
   level = level or vim.log.levels.ERROR
+  local count = 0
   for _, notif in ipairs(self.notifs) do
     if notif.level >= level then
       Util.notify(notif.msg, { level = notif.level })
+      count = count + 1
     end
   end
+  return count
 end
 
 ---@param spec LazySpec|LazySpecImport
----@param results? string[]
-function Spec:normalize(spec, results)
+function Spec:normalize(spec)
   if type(spec) == "string" then
-    if not spec:find("/", 1, true) then
-      -- spec is a plugin name
-      if results then
-        table.insert(results, spec)
-      end
-    else
-      self:add({ spec }, results)
-    end
+    self.meta:add({ spec })
   elseif #spec > 1 or Util.is_list(spec) then
     ---@cast spec LazySpec[]
     for _, s in ipairs(spec) do
-      self:normalize(s, results)
+      self:normalize(s)
     end
   elseif spec[1] or spec.dir or spec.url then
-    ---@cast spec LazyPlugin
-    local plugin = self:add(spec, results)
+    ---@cast spec LazyPluginSpec
+    self.meta:add(spec)
     ---@diagnostic disable-next-line: cast-type-mismatch
-    ---@cast plugin LazySpecImport
-    if plugin and plugin.import then
-      self:import(plugin)
+    ---@cast spec LazySpecImport
+    if spec and spec.import then
+      self:import(spec)
     end
   elseif spec.import then
     ---@cast spec LazySpecImport
@@ -366,7 +112,6 @@ function Spec:normalize(spec, results)
   else
     self:error("Invalid plugin spec " .. vim.inspect(spec))
   end
-  return results
 end
 
 ---@param spec LazySpecImport
@@ -374,10 +119,18 @@ function Spec:import(spec)
   if spec.import == "lazy" then
     return self:error("You can't name your plugins module `lazy`.")
   end
-  if type(spec.import) ~= "string" then
+  if type(spec.import) == "function" then
+    if not spec.name then
+      return self:error("Invalid import spec. Missing name: " .. vim.inspect(spec))
+    end
+  elseif type(spec.import) ~= "string" then
     return self:error("Invalid import spec. `import` should be a string: " .. vim.inspect(spec))
   end
-  if vim.tbl_contains(self.modules, spec.import) then
+
+  local import_name = spec.name or spec.import
+  ---@cast import_name string
+
+  if vim.tbl_contains(self.modules, import_name) then
     return
   end
   if spec.cond == false or (type(spec.cond) == "function" and not spec.cond()) then
@@ -387,28 +140,49 @@ function Spec:import(spec)
     return
   end
 
-  self.modules[#self.modules + 1] = spec.import
+  self.modules[#self.modules + 1] = import_name
+
+  local import = spec.import
 
   local imported = 0
 
-  ---@type string[]
-  local modnames = {}
-  Util.lsmod(spec.import, function(modname)
-    modnames[#modnames + 1] = modname
-  end)
-  table.sort(modnames)
+  ---@type {modname: string, load: fun():(LazyPluginSpec?, string?)}[]
+  local modspecs = {}
 
-  for _, modname in ipairs(modnames) do
+  if type(import) == "string" then
+    Util.lsmod(import, function(modname, modpath)
+      modspecs[#modspecs + 1] = {
+        modname = modname,
+        load = function()
+          local mod, err = loadfile(modpath)
+          if mod then
+            return mod()
+          else
+            return nil, err
+          end
+        end,
+      }
+    end)
+    table.sort(modspecs, function(a, b)
+      return a.modname < b.modname
+    end)
+  else
+    modspecs = { { modname = import_name, load = spec.import } }
+  end
+
+  for _, modspec in ipairs(modspecs) do
     imported = imported + 1
+    local modname = modspec.modname
     Util.track({ import = modname })
     self.importing = modname
     -- unload the module so we get a clean slate
     ---@diagnostic disable-next-line: no-unknown
     package.loaded[modname] = nil
     Util.try(function()
-      local mod = require(modname)
-      if type(mod) ~= "table" then
-        self.importing = nil
+      local mod, err = modspec.load()
+      if err then
+        self:error("Failed to load `" .. modname .. "`:\n" .. err)
+      elseif type(mod) ~= "table" then
         return self:error(
           "Invalid spec module: `"
             .. modname
@@ -416,44 +190,23 @@ function Spec:import(spec)
             .. type(mod)
             .. "` was returned instead"
         )
+      else
+        self:normalize(mod)
       end
-      self:normalize(mod)
-      self.importing = nil
-      Util.track()
     end, {
       msg = "Failed to load `" .. modname .. "`",
       on_error = function(msg)
         self:error(msg)
-        self.importing = nil
-        Util.track()
       end,
     })
+    self.importing = nil
+    Util.track()
   end
   if imported == 0 then
-    self:error("No specs found for module " .. spec.import)
+    self:error("No specs found for module " .. vim.inspect(spec.import))
   end
 end
 
----@param old LazyPlugin
----@param new LazyPlugin
----@return LazyPlugin
-function Spec:merge(old, new)
-  new._.dep = old._.dep and new._.dep
-
-  if new.url and old.url and new.url ~= old.url then
-    self:error("Two plugins with the same name and different url:\n" .. vim.inspect({ old = old, new = new }))
-  end
-
-  if new.dependencies and old.dependencies then
-    Util.extend(new.dependencies, old.dependencies)
-  end
-
-  new._.super = old
-  setmetatable(new, { __index = old })
-
-  return new
-end
-
 function M.update_state()
   ---@type string[]
   local cloning = {}
@@ -484,12 +237,15 @@ function M.update_state()
         or plugin.cmd
       plugin.lazy = lazy and true or false
     end
-    if plugin.dir:find(Config.options.root, 1, true) == 1 then
+    if plugin.virtual then
+      plugin._.is_local = true
+      plugin._.installed = true -- local plugins are managed by the user
+    elseif plugin.dir:find(Config.options.root, 1, true) == 1 then
       plugin._.installed = installed[plugin.name] ~= nil
       installed[plugin.name] = nil
     else
       plugin._.is_local = true
-      plugin._.installed = true -- local plugins are managed by the user
+      plugin._.installed = vim.fn.isdirectory(plugin.dir) == 1
     end
   end
 
@@ -497,6 +253,8 @@ function M.update_state()
     installed[name] = nil
   end
 
+  M.update_rocks_state()
+
   Config.to_clean = {}
   for pack, dir_type in pairs(installed) do
     table.insert(Config.to_clean, {
@@ -512,12 +270,65 @@ function M.update_state()
   end
 end
 
+function M.update_rocks_state()
+  local root = Config.options.rocks.root
+  ---@type table<string,string>
+  local installed = {}
+  Util.ls(root, function(_, name, type)
+    if type == "directory" then
+      installed[name] = name
+    end
+  end)
+
+  for _, plugin in pairs(Config.plugins) do
+    if plugin.build == "rockspec" or plugin.name == "hererocks" then
+      plugin._.build = not installed[plugin.name]
+    end
+  end
+end
+
+---@return LazySpecImport?
+function M.find_local_spec()
+  if not Config.options.local_spec then
+    return
+  end
+  local path = vim.uv.cwd()
+  while path and path ~= "" do
+    local file = path .. "/" .. M.LOCAL_SPEC
+    if vim.fn.filereadable(file) == 1 then
+      return {
+        name = vim.fn.fnamemodify(file, ":~:."),
+        import = function()
+          local data = vim.secure.read(file)
+          if data then
+            return loadstring(data, M.LOCAL_SPEC)()
+          end
+          return {}
+        end,
+      }
+    end
+    local p = vim.fn.fnamemodify(path, ":h")
+    if p == path then
+      break
+    end
+    path = p
+  end
+end
+
 function M.load()
   M.loading = true
   -- load specs
   Util.track("spec")
   Config.spec = Spec.new()
-  Config.spec:parse({ vim.deepcopy(Config.options.spec), { "folke/lazy.nvim" } })
+
+  local specs = {
+    ---@diagnostic disable-next-line: param-type-mismatch
+    vim.deepcopy(Config.options.spec),
+  }
+  specs[#specs + 1] = M.find_local_spec()
+  specs[#specs + 1] = { "folke/lazy.nvim" }
+
+  Config.spec:parse(specs)
 
   -- override some lazy props
   local lazy = Config.spec.plugins["lazy.nvim"]
@@ -530,16 +341,30 @@ function M.load()
     lazy._.loaded = {}
   end
 
+  -- add hererocks when enabled and needed
+  for _, plugin in pairs(Config.spec.plugins) do
+    if plugin.build == "rockspec" then
+      if Config.hererocks() then
+        Config.spec.meta:add({
+          "luarocks/hererocks",
+          build = "rockspec",
+          lazy = true,
+        })
+      end
+      break
+    end
+  end
+
   local existing = Config.plugins
   Config.plugins = Config.spec.plugins
   -- copy state. This wont do anything during startup
   for name, plugin in pairs(existing) do
     if Config.plugins[name] then
-      local dep = Config.plugins[name]._.dep
-      local super = Config.plugins[name]._.super
+      local new_state = Config.plugins[name]._
       Config.plugins[name]._ = plugin._
-      Config.plugins[name]._.dep = dep
-      Config.plugins[name]._.super = super
+      Config.plugins[name]._.dep = new_state.dep
+      Config.plugins[name]._.frags = new_state.frags
+      Config.plugins[name]._.pkg = new_state.pkg
     end
   end
   Util.track()
@@ -547,23 +372,36 @@ function M.load()
   Util.track("state")
   M.update_state()
   Util.track()
+
+  if Config.options.pkg.enabled and Pkg.dirty then
+    Pkg.update()
+    return M.load()
+  end
+
   M.loading = false
   vim.api.nvim_exec_autocmds("User", { pattern = "LazyPlugins", modeline = false })
 end
 
 -- Finds the plugin that has this path
 ---@param path string
-function M.find(path)
+---@param opts? {fast?:boolean}
+function M.find(path, opts)
   if not Config.spec then
     return
   end
+  opts = opts or {}
   local lua = path:find("/lua/", 1, true)
   if lua then
     local name = path:sub(1, lua - 1)
     local slash = name:reverse():find("/", 1, true)
     if slash then
       name = name:sub(#name - slash + 2)
-      return name and Config.plugins[name] or Config.spec.plugins[name] or nil
+      if name then
+        if opts.fast then
+          return Config.spec.meta.plugins[name]
+        end
+        return Config.spec.plugins[name]
+      end
     end
   end
 end
@@ -571,32 +409,76 @@ end
 ---@param plugin LazyPlugin
 function M.has_errors(plugin)
   for _, task in ipairs(plugin._.tasks or {}) do
-    if task.error then
+    if task:has_errors() then
       return true
     end
   end
   return false
 end
 
--- Merges super values or runs the values function to override values or return new ones
+-- Merges super values or runs the values function to override values or return new ones.
+-- Values are cached for performance.
 -- Used for opts, cmd, event, ft and keys
 ---@param plugin LazyPlugin
 ---@param prop string
 ---@param is_list? boolean
 function M.values(plugin, prop, is_list)
+  if not plugin[prop] then
+    return {}
+  end
+  plugin._.cache = plugin._.cache or {}
+  local key = prop .. (is_list and "_list" or "")
+  if plugin._.cache[key] == nil then
+    plugin._.cache[key] = M._values(plugin, plugin, prop, is_list)
+  end
+  return plugin._.cache[key]
+end
+
+-- Merges super values or runs the values function to override values or return new ones
+-- Used for opts, cmd, event, ft and keys
+---@param root LazyPlugin
+---@param plugin LazyPlugin
+---@param prop string
+---@param is_list? boolean
+function M._values(root, plugin, prop, is_list)
+  if not plugin[prop] then
+    return {}
+  end
+  local super = getmetatable(plugin)
   ---@type table
-  local ret = plugin._.super and M.values(plugin._.super, prop, is_list) or {}
+  local ret = super and M._values(root, super.__index, prop, is_list) or {}
   local values = rawget(plugin, prop)
 
   if not values then
     return ret
   elseif type(values) == "function" then
-    ret = values(plugin, ret) or ret
+    ret = values(root, ret) or ret
     return type(ret) == "table" and ret or { ret }
   end
 
   values = type(values) == "table" and values or { values }
-  return is_list and Util.extend(ret, values) or Util.merge(ret, values)
+  if is_list then
+    return Util.extend(ret, values)
+  else
+    ---@type {path:string[], list:any[]}[]
+    local lists = {}
+    ---@diagnostic disable-next-line: no-unknown
+    for _, key in ipairs(plugin[prop .. "_extend"] or {}) do
+      local path = vim.split(key, ".", { plain = true })
+      local r = Util.key_get(ret, path)
+      local v = Util.key_get(values, path)
+      if type(r) == "table" and type(v) == "table" then
+        lists[key] = { path = path, list = {} }
+        vim.list_extend(lists[key].list, r)
+        vim.list_extend(lists[key].list, v)
+      end
+    end
+    local t = Util.merge(ret, values)
+    for _, list in pairs(lists) do
+      Util.key_set(t, list.path, list.list)
+    end
+    return t
+  end
 end
 
 return M

lua/lazy/core/util.lua

@@ -5,6 +5,7 @@ local M = {}
 
 ---@type LazyProfile[]
 M._profiles = { { name = "lazy" } }
+M.is_win = jit.os:find("Windows")
 
 ---@param data (string|{[string]:string})?
 ---@param time number?
@@ -12,7 +13,7 @@ function M.track(data, time)
   if data then
     local entry = {
       data = data,
-      time = time or vim.loop.hrtime(),
+      time = time or vim.uv.hrtime(),
     }
     table.insert(M._profiles[#M._profiles], entry)
 
@@ -23,11 +24,29 @@ function M.track(data, time)
   else
     ---@type LazyProfile
     local entry = table.remove(M._profiles)
-    entry.time = vim.loop.hrtime() - entry.time
+    entry.time = vim.uv.hrtime() - entry.time
     return entry
   end
 end
 
+function M.exiting()
+  return vim.v.exiting ~= vim.NIL
+end
+
+---@generic T
+---@param list T[]
+---@param fn fun(v: T):boolean?
+---@return T[]
+function M.filter(fn, list)
+  local ret = {}
+  for _, v in ipairs(list) do
+    if fn(v) then
+      table.insert(ret, v)
+    end
+  end
+  return ret
+end
+
 ---@generic F: fun()
 ---@param data (string|{[string]:string})?
 ---@param fn F
@@ -47,14 +66,14 @@ end
 ---@param name string
 ---@return string
 function M.normname(name)
-  local ret = name:lower():gsub("^n?vim%-", ""):gsub("%.n?vim$", ""):gsub("%.lua", ""):gsub("[^a-z]+", "")
+  local ret = name:lower():gsub("^n?vim%-", ""):gsub("%.n?vim$", ""):gsub("[%.%-]lua", ""):gsub("[^a-z]+", "")
   return ret
 end
 
 ---@return string
 function M.norm(path)
   if path:sub(1, 1) == "~" then
-    local home = vim.loop.os_homedir()
+    local home = vim.uv.os_homedir()
     if home:sub(-1) == "\\" or home:sub(-1) == "/" then
       home = home:sub(1, -2)
     end
@@ -64,38 +83,44 @@ function M.norm(path)
   return path:sub(-1) == "/" and path:sub(1, -2) or path
 end
 
+---@param opts? {level?: number}
+function M.pretty_trace(opts)
+  opts = opts or {}
+  local Config = require("lazy.core.config")
+  local trace = {}
+  local level = opts.level or 2
+  while true do
+    local info = debug.getinfo(level, "Sln")
+    if not info then
+      break
+    end
+    if info.what ~= "C" and (Config.options.debug or not info.source:find("lazy.nvim")) then
+      local source = info.source:sub(2)
+      if source:find(Config.options.root, 1, true) == 1 then
+        source = source:sub(#Config.options.root + 1)
+      end
+      source = vim.fn.fnamemodify(source, ":p:~:.") --[[@as string]]
+      local line = "  - " .. source .. ":" .. info.currentline
+      if info.name then
+        line = line .. " _in_ **" .. info.name .. "**"
+      end
+      table.insert(trace, line)
+    end
+    level = level + 1
+  end
+  return #trace > 0 and ("\n\n# stacktrace:\n" .. table.concat(trace, "\n")) or ""
+end
+
+---@generic R
+---@param fn fun():R?
 ---@param opts? string|{msg:string, on_error:fun(msg)}
+---@return R
 function M.try(fn, opts)
   opts = type(opts) == "string" and { msg = opts } or opts or {}
   local msg = opts.msg
   -- error handler
   local error_handler = function(err)
-    local Config = require("lazy.core.config")
-    local trace = {}
-    local level = 1
-    while true do
-      local info = debug.getinfo(level, "Sln")
-      if not info then
-        break
-      end
-      if info.what ~= "C" and not info.source:find("lazy.nvim") then
-        local source = info.source:sub(2)
-        if source:find(Config.options.root, 1, true) == 1 then
-          source = source:sub(#Config.options.root + 1)
-        end
-        source = vim.fn.fnamemodify(source, ":p:~:.")
-        local line = "  - " .. source .. ":" .. info.currentline
-        if info.name then
-          line = line .. " _in_ **" .. info.name .. "**"
-        end
-        table.insert(trace, line)
-      end
-      level = level + 1
-    end
-    msg = (msg and (msg .. "\n\n") or "") .. err
-    if #trace > 0 then
-      msg = msg .. "\n\n# stacktrace:\n" .. table.concat(trace, "\n")
-    end
+    msg = (msg and (msg .. "\n\n") or "") .. err .. M.pretty_trace()
     if opts.on_error then
       opts.on_error(msg)
     else
@@ -118,7 +143,7 @@ function M.get_source()
     if not info then
       break
     end
-    if info.what ~= "C" and not info.source:find("lazy.nvim", 1, true) then
+    if info.what ~= "C" and not info.source:find("lazy.nvim", 1, true) and info.source ~= "@vim/loader.lua" then
       return info.source:sub(2)
     end
     f = f + 1
@@ -146,7 +171,9 @@ function M.very_lazy()
         return
       end
       vim.g.did_very_lazy = true
+      M.track({ event = "VeryLazy" })
       vim.api.nvim_exec_autocmds("User", { pattern = "VeryLazy", modeline = false })
+      M.track()
     end)
   end
 
@@ -172,9 +199,9 @@ end
 ---@param path string
 ---@param fn fun(path: string, name:string, type:FileType):boolean?
 function M.ls(path, fn)
-  local handle = vim.loop.fs_scandir(path)
+  local handle = vim.uv.fs_scandir(path)
   while handle do
-    local name, t = vim.loop.fs_scandir_next(handle)
+    local name, t = vim.uv.fs_scandir_next(handle)
     if not name then
       break
     end
@@ -184,7 +211,7 @@ function M.ls(path, fn)
     -- HACK: type is not always returned due to a bug in luv,
     -- so fecth it with fs_stat instead when needed.
     -- see https://github.com/folke/lazy.nvim/issues/306
-    if fn(fname, name, t or vim.loop.fs_stat(fname).type) == false then
+    if fn(fname, name, t or vim.uv.fs_stat(fname).type) == false then
       break
     end
   end
@@ -218,18 +245,33 @@ function M.walkmods(root, fn, modname)
 end
 
 ---@param modname string
-function M.get_unloaded_rtp(modname)
-  modname = modname:gsub("/", ".")
-  local idx = modname:find(".", 1, true)
-  local topmod = idx and modname:sub(1, idx - 1) or modname
-  topmod = M.normname(topmod)
+---@return string
+function M.topmod(modname)
+  return modname:match("^[^./]+") or modname
+end
 
+---@type table<string, string[]>
+M.unloaded_cache = {}
+
+---@param modname string
+---@param opts? {cache?:boolean}
+function M.get_unloaded_rtp(modname, opts)
+  opts = opts or {}
+
+  local topmod = M.topmod(modname)
+  if opts.cache and M.unloaded_cache[topmod] then
+    return M.unloaded_cache[topmod], true
+  end
+
+  local norm = M.normname(topmod)
+
+  ---@type string[]
   local rtp = {}
   local Config = require("lazy.core.config")
   if Config.spec then
     for _, plugin in pairs(Config.spec.plugins) do
-      if not (plugin._.loaded or plugin.module == false) then
-        if topmod == M.normname(plugin.name) then
+      if not (plugin._.loaded or plugin.module == false or plugin.virtual) then
+        if norm == M.normname(plugin.name) then
           table.insert(rtp, 1, plugin.dir)
         else
           table.insert(rtp, plugin.dir)
@@ -237,31 +279,45 @@ function M.get_unloaded_rtp(modname)
       end
     end
   end
-  return rtp
+  M.unloaded_cache[topmod] = rtp
+  return rtp, false
 end
 
 function M.find_root(modname)
+  local paths, cached = M.get_unloaded_rtp(modname, { cache = true })
+
   local ret = require("lazy.core.cache").find(modname, {
     rtp = true,
-    paths = M.get_unloaded_rtp(modname),
-    patterns = { "", ".lua" },
+    paths = paths,
+    patterns = { ".lua", "" },
   })[1]
+
+  if not ret and cached then
+    paths = M.get_unloaded_rtp(modname)
+    ret = require("lazy.core.cache").find(modname, {
+      rtp = false,
+      paths = paths,
+      patterns = { ".lua", "" },
+    })[1]
+  end
   if ret then
-    local root = ret.modpath:gsub("/init%.lua$", ""):gsub("%.lua$", "")
-    return root
+    return ret.modpath:gsub("%.lua$", ""), ret.modpath
   end
 end
 
 ---@param modname string
 ---@param fn fun(modname:string, modpath:string)
 function M.lsmod(modname, fn)
-  local root = M.find_root(modname)
+  local root, match = M.find_root(modname)
   if not root then
     return
   end
 
-  if vim.loop.fs_stat(root .. ".lua") then
-    fn(modname, root .. ".lua")
+  if match:sub(-4) == ".lua" then
+    fn(modname, match)
+    if not vim.uv.fs_stat(root) then
+      return
+    end
   end
 
   M.ls(root, function(path, name, type)
@@ -269,7 +325,7 @@ function M.lsmod(modname, fn)
       fn(modname, path)
     elseif (type == "file" or type == "link") and name:sub(-4) == ".lua" then
       fn(modname .. "." .. name:sub(1, -5), path)
-    elseif type == "directory" and vim.loop.fs_stat(path .. "/init.lua") then
+    elseif type == "directory" and vim.uv.fs_stat(path .. "/init.lua") then
       fn(modname .. "." .. name, path .. "/init.lua")
     end
   end)
@@ -292,7 +348,7 @@ function M.extend(list, add)
   return list
 end
 
----@alias LazyNotifyOpts {lang?:string, title?:string, level?:number}
+---@alias LazyNotifyOpts {lang?:string, title?:string, level?:number, once?:boolean, stacktrace?:boolean, stacklevel?:number}
 
 ---@param msg string|string[]
 ---@param opts? LazyNotifyOpts
@@ -312,8 +368,13 @@ function M.notify(msg, opts)
       "\n"
     )
   end
+  if opts.stacktrace then
+    msg = msg .. M.pretty_trace({ level = opts.stacklevel or 2 })
+  end
   local lang = opts.lang or "markdown"
-  vim.notify(msg, opts.level or vim.log.levels.INFO, {
+  local n = opts.once and vim.notify_once or vim.notify
+  n(msg, opts.level or vim.log.levels.INFO, {
+    ft = lang,
     on_open = function(win)
       local ok = pcall(function()
         vim.treesitter.language.add("markdown")
@@ -389,26 +450,67 @@ end
 ---@param ... T
 ---@return T
 function M.merge(...)
-  local values = { ... }
-  local ret = values[1]
-
+  local ret = select(1, ...)
   if ret == vim.NIL then
     ret = nil
   end
-
-  for i = 2, #values, 1 do
-    local value = values[i]
+  for i = 2, select("#", ...) do
+    local value = select(i, ...)
     if can_merge(ret) and can_merge(value) then
       for k, v in pairs(value) do
         ret[k] = M.merge(ret[k], v)
       end
     elseif value == vim.NIL then
       ret = nil
-    else
+    elseif value ~= nil then
       ret = value
     end
   end
   return ret
 end
 
+function M.lazy_require(module)
+  local mod = nil
+  -- if already loaded, return the module
+  -- otherwise return a lazy module
+  return type(package.loaded[module]) == "table" and package.loaded[module]
+    or setmetatable({}, {
+      __index = function(_, key)
+        mod = mod or require(module)
+        return mod[key]
+      end,
+    })
+end
+
+---@param t table
+---@param key string|string[]
+---@return any
+function M.key_get(t, key)
+  local path = type(key) == "table" and key or vim.split(key, ".", true)
+  local value = t
+  for _, k in ipairs(path) do
+    if type(value) ~= "table" then
+      return value
+    end
+    value = value[k]
+  end
+  return value
+end
+
+---@param t table
+---@param key string|string[]
+---@param value any
+function M.key_set(t, key, value)
+  local path = type(key) == "table" and key or vim.split(key, ".", true)
+  local last = t
+  for i = 1, #path - 1 do
+    local k = path[i]
+    if type(last[k]) ~= "table" then
+      last[k] = {}
+    end
+    last = last[k]
+  end
+  last[path[#path]] = value
+end
+
 return M

lua/lazy/docs.lua

@@ -71,7 +71,7 @@ function M.commands()
   modes.load.opts = true
   local lines = {
     { "Command", "Lua", "Description" },
-    { "---", "---", "---", "---" },
+    { "---", "---", "---" },
   }
   Util.foreach(modes, function(name, mode)
     if commands[name] then
@@ -109,9 +109,15 @@ function M.table(lines)
   return table.concat(ret, "\n")
 end
 
+---@param opts? {name?:string, path?:string, modname?:string}
 ---@return ReadmeBlock
-function M.colors()
-  local str = M.extract("lua/lazy/view/colors.lua", "\nM%.colors = ({.-\n})")
+function M.colors(opts)
+  opts = vim.tbl_extend("force", {
+    name = "Lazy",
+    path = "lua/lazy/view/colors.lua",
+    modname = "lazy.view.colors",
+  }, opts or {})
+  local str = M.extract(opts.path, "\nM%.colors = ({.-\n})")
   ---@type table<string,string>
   local comments = {}
   for _, line in ipairs(vim.split(str, "\n")) do
@@ -124,8 +130,9 @@ function M.colors()
     { "Highlight Group", "Default Group", "Description" },
     { "---", "---", "---" },
   }
-  Util.foreach(require("lazy.view.colors").colors, function(group, link)
-    lines[#lines + 1] = { "**Lazy" .. group .. "**", "***" .. link .. "***", comments[group] or "" }
+  Util.foreach(require(opts.modname).colors, function(group, link)
+    link = type(link) == "table" and "`" .. vim.inspect(link):gsub("%s+", " ") .. "`" or "***" .. link .. "***"
+    lines[#lines + 1] = { "**" .. opts.name .. group .. "**", link, comments[group] or "" }
   end)
   return { content = M.table(lines) }
 end

lua/lazy/example.lua

@@ -80,8 +80,8 @@ return {
   -- you can use a custom url to fetch a plugin
   { url = "git@github.com:folke/noice.nvim.git" },
 
-  -- local plugins can also be configure with the dev option.
-  -- This will use {config.dev.path}/noice.nvim/ instead of fetching it from Github
+  -- local plugins can also be configured with the dev option.
+  -- This will use {config.dev.path}/noice.nvim/ instead of fetching it from GitHub
   -- With the dev option, you can easily switch between the local and installed version of a plugin
   { "folke/noice.nvim", dev = true },
 }

lua/lazy/health.lua

@@ -1,4 +1,6 @@
 local Config = require("lazy.core.config")
+local Process = require("lazy.manage.process")
+local uv = vim.uv or vim.loop
 
 local M = {}
 
@@ -7,15 +9,67 @@ local start = vim.health.start or vim.health.report_start
 local ok = vim.health.ok or vim.health.report_ok
 local warn = vim.health.warn or vim.health.report_warn
 local error = vim.health.error or vim.health.report_error
+local info = vim.health.info or vim.health.report_info
+
+---@class LazyHealth
+---@field error? fun(msg:string)
+---@field warn? fun(msg:string)
+---@field ok? fun(msg:string)
+
+---@class LazyHealthHave : LazyHealth
+---@field version? string
+---@field version_pattern? string
+---@field optional? boolean
+
+---@param cmd string|string[]
+---@param opts? LazyHealthHave
+function M.have(cmd, opts)
+  opts = vim.tbl_extend("force", {
+    error = error,
+    warn = warn,
+    ok = ok,
+    version = "--version",
+  }, opts or {})
+
+  cmd = type(cmd) == "table" and cmd or { cmd }
+  ---@cast cmd string[]
+  ---@type string?
+  local found
+  for _, c in ipairs(cmd) do
+    if vim.fn.executable(c) == 1 then
+      local out, exit_code = Process.exec({ c, opts.version })
+      if exit_code ~= 0 then
+        opts.error(("failed to get version of {%s}\n%s"):format(c, table.concat(out, "\n")))
+      else
+        local version = vim.trim(out[1] or "")
+        version = version:gsub("^%s*" .. vim.pesc(c) .. "%s*", "")
+        if opts.version_pattern and not version:find(opts.version_pattern, 1, true) then
+          opts.warn(("`%s` version `%s` needed, but found `%s`"):format(c, opts.version_pattern, version))
+        else
+          found = ("{%s} `%s`"):format(c, version)
+          break
+        end
+      end
+    end
+  end
+  if found then
+    opts.ok(found)
+    return true
+  else
+    (opts.optional and opts.warn or opts.error)(
+      ("{%s} %snot installed"):format(
+        table.concat(cmd, "} or {"),
+        opts.version_pattern and "version `" .. opts.version_pattern .. "` " or ""
+      )
+    )
+  end
+end
 
 function M.check()
   start("lazy.nvim")
+  info("{lazy.nvim} version `" .. Config.version .. "`")
 
-  if vim.fn.executable("git") == 1 then
-    ok("Git installed")
-  else
-    error("Git not installed?")
-  end
+  M.have("git")
 
   local sites = vim.opt.packpath:get()
   local default_site = vim.fn.stdpath("data") .. "/site"
@@ -26,7 +80,7 @@ function M.check()
   local existing = false
   for _, site in pairs(sites) do
     for _, packs in ipairs(vim.fn.expand(site .. "/pack/*", false, true)) do
-      if not packs:find("[/\\]dist$") and vim.loop.fs_stat(packs) then
+      if not packs:find("[/\\]dist$") and uv.fs_stat(packs) then
         existing = true
         warn("found existing packages at `" .. packs .. "`")
       end
@@ -36,7 +90,7 @@ function M.check()
     ok("no existing packages found by other package managers")
   end
 
-  for _, name in ipairs({ "packer", "plugged", "paq" }) do
+  for _, name in ipairs({ "packer", "plugged", "paq", "pckr", "mini.deps" }) do
     for _, path in ipairs(vim.opt.rtp:get()) do
       if path:find(name, 1, true) then
         error("Found paths on the rtp from another plugin manager `" .. name .. "`")
@@ -46,7 +100,7 @@ function M.check()
   end
 
   local packer_compiled = vim.fn.stdpath("config") .. "/plugin/packer_compiled.lua"
-  if vim.loop.fs_stat(packer_compiled) then
+  if uv.fs_stat(packer_compiled) then
     error("please remove the file `" .. packer_compiled .. "`")
   else
     ok("packer_compiled.lua not found")
@@ -54,11 +108,10 @@ function M.check()
 
   local spec = Config.spec
   if spec == nil then
-    error("No plugins loaded. Did you forget to run `require(\"lazy\").setup()`?")
+    error('No plugins loaded. Did you forget to run `require("lazy").setup()`?')
   else
     for _, plugin in pairs(spec.plugins) do
       M.check_valid(plugin)
-      M.check_override(plugin)
     end
     if #spec.notifs > 0 then
       error("Issues were reported when loading your specs:")
@@ -74,6 +127,47 @@ function M.check()
       end
     end
   end
+
+  start("luarocks")
+  if Config.options.rocks.enabled then
+    if Config.hererocks() then
+      info("checking `hererocks` installation")
+    else
+      info("checking `luarocks` installation")
+    end
+    local need_luarocks = {}
+    for _, plugin in pairs(spec.plugins) do
+      if plugin.build == "rockspec" then
+        table.insert(need_luarocks, plugin.name)
+      end
+    end
+    if #need_luarocks == 0 then
+      ok("no plugins require `luarocks`, so you can ignore any warnings below")
+    else
+      local lines = vim.tbl_map(function(name)
+        return "  * `" .. name .. "`"
+      end, need_luarocks)
+
+      info("you have some plugins that require `luarocks`:\n" .. table.concat(lines, "\n"))
+    end
+    local ok = require("lazy.pkg.rockspec").check({
+      error = #need_luarocks > 0 and error or warn,
+      warn = warn,
+      ok = ok,
+    })
+    if not ok then
+      warn(table.concat({
+        "Lazy won't be able to install plugins that require `luarocks`.",
+        "Here's what you can do:",
+        " - fix your `luarocks` installation",
+        Config.hererocks() and " - disable *hererocks* with `opts.rocks.hererocks = false`"
+          or " - enable `hererocks` with `opts.rocks.hererocks = true`",
+        " - disable `luarocks` support completely with `opts.rocks.enabled = false`",
+      }, "\n"))
+    end
+  else
+    ok("luarocks disabled")
+  end
 end
 
 ---@param plugin LazyPlugin
@@ -87,23 +181,6 @@ function M.check_valid(plugin)
   end
 end
 
----@param plugin LazyPlugin
-function M.check_override(plugin)
-  if not plugin._.super then
-    return
-  end
-
-  local Handler = require("lazy.core.handler")
-  local skip = { "dependencies", "_", "opts", 1 }
-  vim.list_extend(skip, vim.tbl_values(Handler.types))
-
-  for key, value in pairs(plugin._.super) do
-    if not vim.tbl_contains(skip, key) and plugin[key] and plugin[key] ~= value then
-      warn("{" .. plugin.name .. "}: overriding <" .. key .. ">")
-    end
-  end
-end
-
 M.valid = {
   1,
   "_",
@@ -131,6 +208,7 @@ M.valid = {
   "opts",
   "pin",
   "priority",
+  "submodules",
   "tag",
   "url",
   "version",

lua/lazy/help.lua

@@ -4,20 +4,21 @@ local Util = require("lazy.util")
 local M = {}
 
 function M.index(plugin)
-  if Config.options.readme.skip_if_doc_exists and vim.loop.fs_stat(plugin.dir .. "/doc") then
+  if Config.options.readme.skip_if_doc_exists and vim.uv.fs_stat(plugin.dir .. "/doc") then
     return {}
   end
 
-  ---@param file string
-  local files = vim.tbl_flatten(vim.tbl_map(function(file)
-    return vim.fn.expand(plugin.dir .. "/" .. file, false, true)
-  end, Config.options.readme.files))
+  local files = {}
+
+  for _, file in ipairs(Config.options.readme.files) do
+    vim.list_extend(files, vim.fn.expand(plugin.dir .. "/" .. file, false, true))
+  end
 
   ---@type table<string,{file:string, tag:string, line:string}>
   local tags = {}
   for _, file in ipairs(files) do
     file = Util.norm(file)
-    if vim.loop.fs_stat(file) then
+    if vim.uv.fs_stat(file) then
       local rel_file = file:sub(#plugin.dir + 1)
       local tag_filename = plugin.name .. vim.fn.fnamemodify(rel_file, ":h"):gsub("%W+", "-"):gsub("^%-$", "")
       local lines = vim.split(Util.read_file(file), "\n")
@@ -50,7 +51,7 @@ function M.update()
 
   Util.ls(docs, function(path, name, type)
     if type == "file" and name:sub(-2) == "md" then
-      vim.loop.fs_unlink(path)
+      vim.uv.fs_unlink(path)
     end
   end)
   ---@type {file:string, tag:string, line:string}[]

lua/lazy/init.lua

@@ -2,6 +2,30 @@
 local M = {}
 M._start = 0
 
+vim.uv = vim.uv or vim.loop
+
+local function profile_require()
+  local done = {} ---@type table<string, true>
+  local r = require
+  _G.require = function(modname)
+    local Util = package.loaded["lazy.core.util"]
+    if Util and not done[modname] then
+      done[modname] = true
+      Util.track({ require = modname })
+      local ok, ret = pcall(function()
+        return vim.F.pack_len(r(modname))
+      end)
+      Util.track()
+      if not ok then
+        error(ret, 2)
+      end
+      return vim.F.unpack_len(ret)
+    else
+      return r(modname)
+    end
+  end
+end
+
 ---@overload fun(opts: LazyConfig)
 ---@overload fun(spec:LazySpec, opts: LazyConfig)
 function M.setup(spec, opts)
@@ -13,7 +37,7 @@ function M.setup(spec, opts)
     opts.spec = spec
   end
 
-  M._start = M._start == 0 and vim.loop.hrtime() or M._start
+  M._start = M._start == 0 and vim.uv.hrtime() or M._start
   if vim.g.lazy_did_setup then
     return vim.notify(
       "Re-sourcing your config is not supported with lazy.nvim",
@@ -31,7 +55,7 @@ function M.setup(spec, opts)
   if not (pcall(require, "ffi") and jit and jit.version) then
     return vim.notify("lazy.nvim requires Neovim built with LuaJIT", vim.log.levels.ERROR, { title = "lazy.nvim" })
   end
-  local start = vim.loop.hrtime()
+  local start = vim.uv.hrtime()
 
   -- use the Neovim cache if available
   if vim.loader and vim.fn.has("nvim-0.9.1") == 1 then
@@ -40,17 +64,16 @@ function M.setup(spec, opts)
 
   local Cache = require("lazy.core.cache")
 
-  local enable_cache = not (
-    opts
-    and opts.performance
-    and opts.performance.cache
-    and opts.performance.cache.enabled == false
-  )
+  local enable_cache = vim.tbl_get(opts, "performance", "cache", "enabled") ~= false
   -- load module cache before anything else
   if enable_cache then
     Cache.enable()
   end
 
+  if vim.tbl_get(opts, "profiling", "require") then
+    profile_require()
+  end
+
   require("lazy.stats").track("LazyStart")
 
   local Util = require("lazy.core.util")
@@ -59,12 +82,16 @@ function M.setup(spec, opts)
 
   table.insert(package.loaders, 3, Loader.loader)
 
-  if vim.g.profile_loaders then
-    Cache.profile_loaders()
+  if vim.tbl_get(opts, "profiling", "loader") then
+    if vim.loader then
+      vim.loader._profile({ loaders = true })
+    else
+      Cache._profile_loaders()
+    end
   end
 
   Util.track({ plugin = "lazy.nvim" }) -- setup start
-  Util.track("module", vim.loop.hrtime() - start)
+  Util.track("module", vim.uv.hrtime() - start)
 
   -- load config
   Util.track("config")
@@ -75,7 +102,7 @@ function M.setup(spec, opts)
   Loader.setup()
 
   -- correct time delta and loaded
-  local delta = vim.loop.hrtime() - start
+  local delta = vim.uv.hrtime() - start
   Util.track().time = delta -- end setup
   if Config.plugins["lazy.nvim"] then
     Config.plugins["lazy.nvim"]._.loaded = { time = delta, source = "init.lua" }
@@ -95,7 +122,7 @@ end
 
 function M.bootstrap()
   local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
-  if not vim.loop.fs_stat(lazypath) then
+  if not (vim.uv or vim.loop).fs_stat(lazypath) then
     vim.fn.system({
       "git",
       "clone",

lua/lazy/manage/checker.lua

@@ -1,9 +1,9 @@
 local Config = require("lazy.core.config")
-local Manage = require("lazy.manage")
-local Util = require("lazy.util")
-local Plugin = require("lazy.core.plugin")
 local Git = require("lazy.manage.git")
+local Manage = require("lazy.manage")
+local Plugin = require("lazy.core.plugin")
 local State = require("lazy.state")
+local Util = require("lazy.util")
 
 local M = {}
 
@@ -35,7 +35,9 @@ end
 function M.fast_check(opts)
   opts = opts or {}
   for _, plugin in pairs(Config.plugins) do
-    if not plugin.pin and plugin._.installed then
+    -- don't check local plugins here, since we mark them as needing updates
+    -- only if local is behind upstream (if the git log task gives no output)
+    if plugin._.installed and not (plugin.pin or plugin._.is_local) then
       plugin._.updates = nil
       local info = Git.info(plugin.dir)
       local ok, target = pcall(Git.get_target, plugin)

lua/lazy/manage/git.lua

@@ -1,7 +1,7 @@
-local Util = require("lazy.util")
-local Semver = require("lazy.manage.semver")
 local Config = require("lazy.core.config")
 local Process = require("lazy.manage.process")
+local Semver = require("lazy.manage.semver")
+local Util = require("lazy.util")
 
 local M = {}
 
@@ -116,6 +116,12 @@ end
 ---@param plugin LazyPlugin
 ---@return GitInfo?
 function M.get_target(plugin)
+  if plugin._.is_local then
+    local info = M.info(plugin.dir)
+    local branch = assert(info and info.branch or M.get_branch(plugin))
+    return { branch = branch, commit = M.get_commit(plugin.dir, branch, true) }
+  end
+
   local branch = assert(M.get_branch(plugin))
 
   if plugin.commit then
@@ -144,7 +150,6 @@ function M.get_target(plugin)
       }
     end
   end
-  ---@diagnostic disable-next-line: return-type-mismatch
   return { branch = branch, commit = M.get_commit(plugin.dir, branch, true) }
 end
 
@@ -184,7 +189,12 @@ function M.get_tag_refs(repo, tagref)
   tagref = tagref or "--tags"
   ---@type table<string,string>
   local tags = {}
-  local lines = Process.exec({ "git", "show-ref", "-d", tagref }, { cwd = repo })
+  local ok, lines = pcall(function()
+    return Process.exec({ "git", "show-ref", "-d", tagref }, { cwd = repo })
+  end)
+  if not ok then
+    return {}
+  end
   for _, line in ipairs(lines) do
     local ref, tag = line:match("^(%w+) refs/tags/([^%^]+)%^?{?}?$")
     if ref then
@@ -217,7 +227,7 @@ function M.get_config(repo)
       current_section = section:gsub('%s+"', "."):gsub('"+%s*$', "")
     else
       -- Ignore comments and blank lines
-      if not line:match("^%s*#") and line:match("%S") then
+      if not line:match("^%s*[#;]") and line:match("%S") then
         local key, value = line:match("^%s*(%S+)%s*=%s*(.+)%s*$")
         ret[current_section .. "." .. key] = value
       end

lua/lazy/manage/init.lua

@@ -1,6 +1,6 @@
 local Config = require("lazy.core.config")
-local Runner = require("lazy.manage.runner")
 local Plugin = require("lazy.core.plugin")
+local Runner = require("lazy.manage.runner")
 
 local M = {}
 
@@ -80,14 +80,23 @@ function M.install(opts)
   opts = M.opts(opts, { mode = "install" })
   return M.run({
     pipeline = {
+      "plugin.exists",
       "git.clone",
       { "git.checkout", lockfile = opts.lockfile },
       "plugin.docs",
-      "wait",
+      {
+        "wait",
+        ---@param runner Runner
+        sync = function(runner)
+          require("lazy.pkg").update()
+          Plugin.load()
+          runner:update()
+        end,
+      },
       "plugin.build",
     },
     plugins = function(plugin)
-      return plugin.url and not plugin._.installed
+      return not (plugin._.installed and not plugin._.build)
     end,
   }, opts):wait(function()
     require("lazy.manage.lock").update()
@@ -100,12 +109,22 @@ function M.update(opts)
   opts = M.opts(opts, { mode = "update" })
   return M.run({
     pipeline = {
+      "plugin.exists",
       "git.origin",
       "git.branch",
       "git.fetch",
+      "git.status",
       { "git.checkout", lockfile = opts.lockfile },
       "plugin.docs",
-      "wait",
+      {
+        "wait",
+        ---@param runner Runner
+        sync = function(runner)
+          require("lazy.pkg").update()
+          Plugin.load()
+          runner:update()
+        end,
+      },
       "plugin.build",
       { "git.log", updated = true },
     },
@@ -130,8 +149,10 @@ function M.check(opts)
   opts = opts or {}
   return M.run({
     pipeline = {
+      "plugin.exists",
       { "git.origin", check = true },
       "git.fetch",
+      "git.status",
       "wait",
       { "git.log", check = true },
     },
@@ -218,7 +239,7 @@ function M.clear(plugins)
     if plugin._.tasks then
       ---@param task LazyTask
       plugin._.tasks = vim.tbl_filter(function(task)
-        return task:is_running()
+        return task:running() or task:has_errors()
       end, plugin._.tasks)
     end
   end

lua/lazy/manage/lock.lua

@@ -3,50 +3,53 @@ local Git = require("lazy.manage.git")
 
 local M = {}
 
----@type table<string, {commit:string, branch:string}>
+---@alias LazyLockfile table<string, {commit:string, branch:string}>
+---@type LazyLockfile
 M.lock = {}
 M._loaded = false
 
 function M.update()
+  M.load()
   vim.fn.mkdir(vim.fn.fnamemodify(Config.options.lockfile, ":p:h"), "p")
-  local f = assert(io.open(Config.options.lockfile, "w"))
+  local f = assert(io.open(Config.options.lockfile, "wb"))
   f:write("{\n")
-  M.lock = {}
 
-  ---@param plugin LazyPlugin
-  local plugins = vim.tbl_filter(function(plugin)
-    return not plugin._.is_local and plugin._.installed
-  end, Config.plugins)
+  -- keep disabled and cond plugins
+  for name in pairs(M.lock) do
+    if not (Config.spec.disabled[name] or Config.spec.ignore_installed[name]) then
+      M.lock[name] = nil
+    end
+  end
+
+  for _, plugin in pairs(Config.plugins) do
+    if not plugin._.is_local and plugin._.installed then
+      local info = assert(Git.info(plugin.dir))
+      M.lock[plugin.name] = {
+        branch = info.branch or assert(Git.get_branch(plugin)),
+        commit = assert(info.commit, "commit is nil"),
+      }
+    end
+  end
 
-  ---@param plugin LazyPlugin
   ---@type string[]
-  local names = vim.tbl_map(function(plugin)
-    return plugin.name
-  end, plugins)
+  local names = vim.tbl_keys(M.lock)
   table.sort(names)
 
   for n, name in ipairs(names) do
-    local plugin = Config.plugins[name]
-    if not plugin._.is_local and plugin._.installed then
-      local info = assert(Git.info(plugin.dir))
-      if not info.branch then
-        info.branch = assert(Git.get_branch(plugin))
-      end
-      info.commit = info.commit
-      -- f:write(([[  [%q] = { branch = %q, commit = %q },]]):format(name, info.branch, info.commit) .. "\n")
-      f:write(([[  %q: { "branch": %q, "commit": %q }]]):format(name, info.branch, info.commit))
-      if n ~= #names then
-        f:write(",\n")
-      end
-      ---@diagnostic disable-next-line: assign-type-mismatch
-      M.lock[plugin.name] = info
+    local info = M.lock[name]
+    f:write(([[  %q: { "branch": %q, "commit": %q }]]):format(name, info.branch, info.commit))
+    if n ~= #names then
+      f:write(",\n")
     end
   end
-  f:write("\n}")
+  f:write("\n}\n")
   f:close()
 end
 
 function M.load()
+  if M._loaded then
+    return
+  end
   M.lock = {}
   M._loaded = true
   local f = io.open(Config.options.lockfile, "r")
@@ -64,9 +67,7 @@ end
 ---@param plugin LazyPlugin
 ---@return {commit:string, branch:string}
 function M.get(plugin)
-  if not M._loaded then
-    M.load()
-  end
+  M.load()
   return M.lock[plugin.name]
 end
 

lua/lazy/manage/process.lua

@@ -1,192 +1,239 @@
+local Async = require("lazy.async")
 local Config = require("lazy.core.config")
 
-local M = {}
-
----@type table<uv_process_t, true>
-M.running = {}
-
-M.signals = {
-  "HUP",
-  "INT",
-  "QUIT",
-  "ILL",
-  "TRAP",
-  "ABRT",
-  "BUS",
-  "FPE",
-  "KILL",
-  "USR1",
-  "SEGV",
-  "USR2",
-  "PIPE",
-  "ALRM",
-  "TERM",
-  "CHLD",
-  "CONT",
-  "STOP",
-  "TSTP",
-  "TTIN",
-  "TTOU",
-  "URG",
-  "XCPU",
-  "XFSZ",
-  "VTALRM",
-  "PROF",
-  "WINCH",
-  "IO",
-  "PWR",
-  "EMT",
-  "SYS",
-  "INFO",
-}
-
 ---@diagnostic disable-next-line: no-unknown
-local uv = vim.loop
+local uv = vim.uv
 
 ---@class ProcessOpts
 ---@field args string[]
 ---@field cwd? string
----@field on_line? fun(string)
+---@field on_line? fun(line:string)
 ---@field on_exit? fun(ok:boolean, output:string)
+---@field on_data? fun(data:string, is_stderr?:boolean)
 ---@field timeout? number
 ---@field env? table<string,string>
 
----@param opts? ProcessOpts
----@param cmd string
-function M.spawn(cmd, opts)
-  opts = opts or {}
-  opts.timeout = opts.timeout or (Config.options.git and Config.options.git.timeout * 1000)
+local M = {}
 
+---@type table<uv_process_t, LazyProcess>
+M.running = setmetatable({}, { __mode = "k" })
+
+---@class LazyProcess: Async
+---@field handle? uv_process_t
+---@field pid? number
+---@field cmd string
+---@field opts ProcessOpts
+---@field timeout? uv_timer_t
+---@field timedout? boolean
+---@field data string
+---@field check? uv_check_t
+---@field code? number
+---@field signal? number
+local Process = setmetatable({}, { __index = Async.Async })
+
+---@param cmd string|string[]
+---@param opts? ProcessOpts
+function Process.new(cmd, opts)
+  local self = setmetatable({}, { __index = Process })
+  ---@async
+  Process.init(self, function()
+    self:_run()
+  end)
+  opts = opts or {}
+  opts.args = opts.args or {}
+  if type(cmd) == "table" then
+    self.cmd = cmd[1]
+    vim.list_extend(opts.args, vim.list_slice(cmd, 2))
+  else
+    self.cmd = cmd
+  end
+  opts.timeout = opts.timeout or (Config.options.git and Config.options.git.timeout * 1000)
+  -- make sure the cwd is valid
+  if not opts.cwd and type(uv.cwd()) ~= "string" then
+    opts.cwd = uv.os_homedir()
+  end
+  opts.on_line = opts.on_line and vim.schedule_wrap(opts.on_line) or nil
+  opts.on_data = opts.on_data and vim.schedule_wrap(opts.on_data) or nil
+  self.data = ""
+  self.opts = opts
+  self.code = 1
+  self.signal = 0
+  return self
+end
+
+---@async
+function Process:_run()
+  self:guard()
+  local stdout = assert(uv.new_pipe())
+  local stderr = assert(uv.new_pipe())
+  self.handle = uv.spawn(self.cmd, {
+    stdio = { nil, stdout, stderr },
+    args = self.opts.args,
+    cwd = self.opts.cwd,
+    env = self:env(),
+  }, function(code, signal)
+    self.code = code
+    self.signal = signal
+    if self.timeout then
+      self.timeout:stop()
+    end
+    self.handle:close()
+    stdout:close()
+    stderr:close()
+    self:resume()
+  end)
+
+  if self.handle then
+    M.running[self.handle] = self
+    stdout:read_start(function(err, data)
+      self:on_data(err, data)
+    end)
+    stderr:read_start(function(err, data)
+      self:on_data(err, data, true)
+    end)
+    self:suspend()
+    while not (self.handle:is_closing() and stdout:is_closing() and stderr:is_closing()) do
+      Async.yield()
+    end
+  else
+    self.data = "Failed to spawn process " .. self.cmd .. " " .. vim.inspect(self.opts)
+  end
+  self:on_exit()
+end
+
+function Process:on_exit()
+  self.data = self.data:gsub("[^\r\n]+\r", "")
+  if self.timedout then
+    self.data = self.data .. "\n" .. "Process was killed because it reached the timeout"
+  elseif self.signal ~= 0 then
+    self.data = self.data .. "\n" .. "Process was killed with SIG" .. M.signals[self.signal]:upper()
+  end
+  if self.opts.on_exit then
+    self.opts.on_exit(self.code == 0 and self.signal == 0, self.data)
+  end
+end
+
+function Process:guard()
+  if self.opts.timeout then
+    self.timeout = assert(uv.new_timer())
+    self.timeout:start(self.opts.timeout, 0, function()
+      self.timedout = true
+      self:kill()
+    end)
+  end
+end
+
+function Process:env()
   ---@type table<string, string>
   local env = vim.tbl_extend("force", {
     GIT_SSH_COMMAND = "ssh -oBatchMode=yes",
-  }, uv.os_environ(), opts.env or {})
+  }, uv.os_environ(), self.opts.env or {})
   env.GIT_DIR = nil
   env.GIT_WORK_TREE = nil
   env.GIT_TERMINAL_PROMPT = "0"
+  env.GIT_INDEX_FILE = nil
 
   ---@type string[]
   local env_flat = {}
   for k, v in pairs(env) do
     env_flat[#env_flat + 1] = k .. "=" .. v
   end
-
-  local stdout = assert(uv.new_pipe())
-  local stderr = assert(uv.new_pipe())
-
-  local output = ""
-  ---@type uv_process_t?
-  local handle = nil
-
-  ---@type uv_timer_t
-  local timeout
-  local killed = false
-  if opts.timeout then
-    timeout = assert(uv.new_timer())
-    timeout:start(opts.timeout, 0, function()
-      if M.kill(handle) then
-        killed = true
-      end
-    end)
-  end
-
-  handle = uv.spawn(cmd, {
-    stdio = { nil, stdout, stderr },
-    args = opts.args,
-    cwd = opts.cwd,
-    env = env_flat,
-  }, function(exit_code, signal)
-    ---@cast handle uv_process_t
-    M.running[handle] = nil
-    if timeout then
-      timeout:stop()
-      timeout:close()
-    end
-    handle:close()
-    stdout:close()
-    stderr:close()
-    local check = assert(uv.new_check())
-    check:start(function()
-      if not stdout:is_closing() or not stderr:is_closing() then
-        return
-      end
-      check:stop()
-      if opts.on_exit then
-        output = output:gsub("[^\r\n]+\r", "")
-        if killed then
-          output = output .. "\n" .. "Process was killed because it reached the timeout"
-        elseif signal ~= 0 then
-          output = output .. "\n" .. "Process was killed with SIG" .. M.signals[signal]
-        end
-
-        vim.schedule(function()
-          opts.on_exit(exit_code == 0 and signal == 0, output)
-        end)
-      end
-    end)
-  end)
-
-  if not handle then
-    if opts.on_exit then
-      opts.on_exit(false, "Failed to spawn process " .. cmd .. " " .. vim.inspect(opts))
-    end
-    return
-  end
-  M.running[handle] = true
-
-  ---@param data? string
-  local function on_output(err, data)
-    assert(not err, err)
-
-    if data then
-      output = output .. data:gsub("\r\n", "\n")
-      local lines = vim.split(vim.trim(output:gsub("\r$", "")):gsub("[^\n\r]+\r", ""), "\n")
-
-      if opts.on_line then
-        vim.schedule(function()
-          opts.on_line(lines[#lines])
-        end)
-      end
-    end
-  end
-
-  uv.read_start(stdout, on_output)
-  uv.read_start(stderr, on_output)
-
-  return handle
+  return env_flat
 end
 
-function M.kill(handle)
-  if handle and not handle:is_closing() then
-    M.running[handle] = nil
-    uv.process_kill(handle, "sigint")
-    return true
+---@param signals uv.aliases.signals|uv.aliases.signals[]|nil
+function Process:kill(signals)
+  if not self.handle or self.handle:is_closing() then
+    return
   end
+  signals = signals or { "sigterm", "sigkill" }
+  signals = type(signals) == "table" and signals or { signals }
+  ---@cast signals uv.aliases.signals[]
+  local timer = assert(uv.new_timer())
+  timer:start(0, 1000, function()
+    if self.handle and not self.handle:is_closing() and #signals > 0 then
+      self.handle:kill(table.remove(signals, 1))
+    else
+      timer:stop()
+    end
+  end)
+end
+
+---@param err? string
+---@param data? string
+---@param is_stderr? boolean
+function Process:on_data(err, data, is_stderr)
+  assert(not err, err)
+  if not data then
+    return
+  end
+
+  if self.opts.on_data then
+    self.opts.on_data(data, is_stderr)
+  end
+  self.data = self.data .. data:gsub("\r\n", "\n")
+  local lines = vim.split(vim.trim(self.data:gsub("\r$", "")):gsub("[^\n\r]+\r", ""), "\n")
+
+  if self.opts.on_line then
+    self.opts.on_line(lines[#lines])
+  end
+end
+
+M.signals = {
+  "hup",
+  "int",
+  "quit",
+  "ill",
+  "trap",
+  "abrt",
+  "bus",
+  "fpe",
+  "kill",
+  "usr1",
+  "segv",
+  "usr2",
+  "pipe",
+  "alrm",
+  "term",
+  "chld",
+  "cont",
+  "stop",
+  "tstp",
+  "ttin",
+  "ttou",
+  "urg",
+  "xcpu",
+  "xfsz",
+  "vtalrm",
+  "prof",
+  "winch",
+  "io",
+  "pwr",
+  "emt",
+  "sys",
+  "info",
+}
+
+---@param cmd string|string[]
+---@param opts? ProcessOpts
+function M.spawn(cmd, opts)
+  return Process.new(cmd, opts)
 end
 
 function M.abort()
-  for handle in pairs(M.running) do
-    M.kill(handle)
+  for _, proc in pairs(M.running) do
+    proc:kill()
   end
 end
 
----@param cmd string[]
----@param opts? {cwd:string, env:table}
+---@async
+---@param cmd string|string[]
+---@param opts? ProcessOpts
 function M.exec(cmd, opts)
   opts = opts or {}
-  ---@type string[]
-  local lines
-  local job = vim.fn.jobstart(cmd, {
-    cwd = opts.cwd,
-    pty = false,
-    env = opts.env,
-    stdout_buffered = true,
-    on_stdout = function(_, _lines)
-      lines = _lines
-    end,
-  })
-  vim.fn.jobwait({ job })
-  return lines
+  local proc = M.spawn(cmd, opts)
+  proc:wait()
+  return vim.split(proc.data, "\n"), proc.code
 end
 
 return M

lua/lazy/manage/reloader.lua

@@ -1,7 +1,7 @@
 local Config = require("lazy.core.config")
-local Util = require("lazy.util")
-local Plugin = require("lazy.core.plugin")
 local Loader = require("lazy.core.loader")
+local Plugin = require("lazy.core.plugin")
+local Util = require("lazy.util")
 
 local M = {}
 
@@ -16,7 +16,7 @@ function M.enable()
     M.timer:stop()
   end
   if #Config.spec.modules > 0 then
-    M.timer = assert(vim.loop.new_timer())
+    M.timer = assert(vim.uv.new_timer())
     M.check(true)
     M.timer:start(2000, 2000, M.check)
   end
@@ -44,7 +44,7 @@ function M.check(start)
   -- spec is a module
   local function check(_, modpath)
     checked[modpath] = true
-    local hash = vim.loop.fs_stat(modpath)
+    local hash = vim.uv.fs_stat(modpath)
     if hash then
       if M.files[modpath] then
         if not M.eq(M.files[modpath], hash) then
@@ -76,20 +76,32 @@ function M.check(start)
     Config.mapleader = vim.g.mapleader
   end
 
-  if not (start or #changes == 0) then
+  if Loader.init_done and Config.maplocalleader ~= vim.g.maplocalleader then
     vim.schedule(function()
-      if Config.options.change_detection.notify and not Config.headless() then
-        local lines = { "# Config Change Detected. Reloading...", "" }
-        for _, change in ipairs(changes) do
-          table.insert(lines, "- **" .. change.what .. "**: `" .. vim.fn.fnamemodify(change.file, ":p:~:.") .. "`")
-        end
-        Util.warn(lines)
-      end
-      Plugin.load()
-      vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
-      vim.api.nvim_exec_autocmds("User", { pattern = "LazyReload", modeline = false })
+      require("lazy.core.util").warn("You need to set `vim.g.maplocalleader` **BEFORE** loading lazy")
     end)
+    Config.maplocalleader = vim.g.maplocalleader
+  end
+
+  if not (start or #changes == 0) then
+    M.reload(changes)
   end
 end
 
+---@param {file:string, what:string}[]
+function M.reload(changes)
+  vim.schedule(function()
+    if Config.options.change_detection.notify and not Config.headless() then
+      local lines = { "# Config Change Detected. Reloading...", "" }
+      for _, change in ipairs(changes) do
+        table.insert(lines, "- **" .. change.what .. "**: `" .. vim.fn.fnamemodify(change.file, ":p:~:.") .. "`")
+      end
+      Util.warn(lines)
+    end
+    Plugin.load()
+    vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
+    vim.api.nvim_exec_autocmds("User", { pattern = "LazyReload", modeline = false })
+  end)
+end
+
 return M

lua/lazy/manage/runner.lua

@@ -1,21 +1,23 @@
-local Task = require("lazy.manage.task")
+local Async = require("lazy.async")
 local Config = require("lazy.core.config")
-local Util = require("lazy.util")
+local Task = require("lazy.manage.task")
 
 ---@class RunnerOpts
 ---@field pipeline (string|{[1]:string, [string]:any})[]
 ---@field plugins? LazyPlugin[]|fun(plugin:LazyPlugin):any?
 ---@field concurrency? number
 
----@alias PipelineStep {task:string, opts?:TaskOptions}
----@alias LazyRunnerTask {co:thread, status: {task?:LazyTask, waiting?:boolean}}
+---@class RunnerTask
+---@field task? LazyTask
+---@field step number
+
+---@alias PipelineStep {task:string, opts?:TaskOptions }
 
 ---@class Runner
----@field _plugins LazyPlugin[]
----@field _running LazyRunnerTask[]
+---@field _plugins table<string,LazyPlugin>
 ---@field _pipeline PipelineStep[]
----@field _on_done fun()[]
 ---@field _opts RunnerOpts
+---@field _running? Async
 local Runner = {}
 
 ---@param opts RunnerOpts
@@ -24,13 +26,17 @@ function Runner.new(opts)
   self._opts = opts or {}
 
   local plugins = self._opts.plugins
+  ---@type LazyPlugin[]
+  local pp = {}
   if type(plugins) == "function" then
-    self._plugins = vim.tbl_filter(plugins, Config.plugins)
+    pp = vim.tbl_filter(plugins, Config.plugins)
   else
-    self._plugins = plugins or Config.plugins
+    pp = plugins or Config.plugins
+  end
+  self._plugins = {}
+  for _, plugin in ipairs(pp) do
+    self._plugins[plugin.name] = plugin
   end
-  self._running = {}
-  self._on_done = {}
 
   ---@param step string|(TaskOptions|{[1]:string})
   self._pipeline = vim.tbl_map(function(step)
@@ -40,118 +46,152 @@ function Runner.new(opts)
   return self
 end
 
----@param entry LazyRunnerTask
-function Runner:_resume(entry)
-  if entry.status.task and not entry.status.task:is_done() then
-    return true
-  end
-  local ok, status = coroutine.resume(entry.co)
-  if not ok then
-    Util.error("Could not resume a task\n" .. status)
-  end
-  entry.status = ok and status
-  return entry.status ~= nil
+function Runner:plugin(name)
+  return self._plugins[name]
 end
 
-function Runner:resume(waiting)
-  local running = 0
-  for _, entry in ipairs(self._running) do
-    if entry.status then
-      if waiting and entry.status.waiting then
-        entry.status.waiting = false
-      end
-      if not entry.status.waiting and self:_resume(entry) then
-        running = running + 1
-        if self._opts.concurrency and running >= self._opts.concurrency then
-          break
-        end
-      end
-    end
+--- Update plugins
+function Runner:update()
+  for name in pairs(self._plugins) do
+    self._plugins[name] = Config.plugins[name] or self._plugins[name]
   end
-  return running > 0 or (not waiting and self:resume(true))
 end
 
 function Runner:start()
-  for _, plugin in pairs(self._plugins) do
-    local co = coroutine.create(self.run_pipeline)
-    local ok, err = coroutine.resume(co, self, plugin)
-    if ok then
-      table.insert(self._running, { co = co, status = {} })
-    else
-      Util.error("Could not start tasks for " .. plugin.name .. "\n" .. err)
-    end
-  end
-
-  local check = vim.loop.new_check()
-  check:start(function()
-    if self:resume() then
-      return
-    end
-    check:stop()
-    self._running = {}
-    for _, cb in ipairs(self._on_done) do
-      vim.schedule(cb)
-    end
-    self._on_done = {}
+  ---@async
+  self._running = Async.new(function()
+    self:_start()
   end)
 end
 
 ---@async
----@param plugin LazyPlugin
-function Runner:run_pipeline(plugin)
-  coroutine.yield()
-  for _, step in ipairs(self._pipeline) do
-    if step.task == "wait" then
-      coroutine.yield({ waiting = true })
-    else
-      local task = self:queue(plugin, step.task, step.opts)
-      if task then
-        coroutine.yield({ task = task })
-        assert(task:is_done())
-        if task.error then
-          return
+function Runner:_start()
+  ---@type string[]
+  local names = vim.tbl_keys(self._plugins)
+  table.sort(names)
+
+  ---@type table<string,RunnerTask>
+  local state = {}
+
+  local active = 1
+  local waiting = 0
+  ---@type number?
+  local wait_step = nil
+
+  ---@async
+  ---@param resume? boolean
+  local function continue(resume)
+    active = 0
+    waiting = 0
+    wait_step = nil
+    local next = {} ---@type string[]
+
+    -- check running tasks
+    for _, name in ipairs(names) do
+      state[name] = state[name] or { step = 0 }
+      local s = state[name]
+      local is_running = s.task and s.task:running()
+      local step = self._pipeline[s.step]
+
+      if is_running then
+        -- still running
+        active = active + 1
+      -- selene:allow(empty_if)
+      elseif s.task and s.task:has_errors() then
+        -- don't continue tasks if there are errors
+      elseif step and step.task == "wait" and not resume then
+        -- waiting for sync
+        waiting = waiting + 1
+        wait_step = s.step
+      else
+        next[#next + 1] = name
+      end
+    end
+
+    -- schedule next tasks
+    for _, name in ipairs(next) do
+      if self._opts.concurrency and active >= self._opts.concurrency then
+        break
+      end
+      local s = state[name]
+      local plugin = self:plugin(name)
+      while s.step <= #self._pipeline do
+        if s.step == #self._pipeline then
+          -- done
+          s.task = nil
+          plugin._.working = false
+          break
+        elseif s.step < #self._pipeline then
+          -- next
+          s.step = s.step + 1
+          local step = self._pipeline[s.step]
+          if step.task == "wait" then
+            plugin._.working = false
+            waiting = waiting + 1
+            wait_step = s.step
+            break
+          else
+            s.task = self:queue(plugin, step)
+            plugin._.working = true
+            if s.task then
+              active = active + 1
+              s.task:wake(false)
+              break
+            end
+          end
         end
       end
     end
   end
+
+  while active > 0 do
+    continue()
+    if active == 0 and waiting > 0 then
+      local sync = self._pipeline[wait_step]
+      if sync and sync.opts and type(sync.opts.sync) == "function" then
+        sync.opts.sync(self)
+      end
+      continue(true)
+    end
+    if active > 0 then
+      self._running:suspend()
+    end
+  end
 end
 
 ---@param plugin LazyPlugin
----@param task_name string
----@param opts? TaskOptions
+---@param step PipelineStep
 ---@return LazyTask?
-function Runner:queue(plugin, task_name, opts)
-  assert(self._running)
-  local def = vim.split(task_name, ".", { plain = true })
+function Runner:queue(plugin, step)
+  assert(self._running and self._running:running(), "Runner is not running")
+  local def = vim.split(step.task, ".", { plain = true })
   ---@type LazyTaskDef
   local task_def = require("lazy.manage.task." .. def[1])[def[2]]
-  assert(task_def)
-  opts = opts or {}
+  assert(task_def, "Task not found: " .. step.task)
+  local opts = step.opts or {}
   if not (task_def.skip and task_def.skip(plugin, opts)) then
-    local task = Task.new(plugin, def[2], task_def.run, opts)
-    task:start()
-    return task
+    return Task.new(plugin, def[2], task_def.run, opts)
   end
 end
 
+function Runner:is_running()
+  return self._running and self._running:running()
+end
+
 -- Execute the callback async when done.
 -- When no callback is specified, this will wait sync
 ---@param cb? fun()
 function Runner:wait(cb)
-  if #self._running == 0 then
+  if not self:is_running() then
     if cb then
       cb()
     end
     return self
   end
-
   if cb then
-    table.insert(self._on_done, cb)
+    self._running:on("done", cb)
   else
-    -- sync wait
-    while #self._running > 0 do
-      vim.wait(10)
-    end
+    self._running:wait()
   end
   return self
 end

lua/lazy/manage/semver.lua

@@ -9,6 +9,7 @@ local M = {}
 ---@field patch number
 ---@field prerelease? string
 ---@field build? string
+---@field input? string
 local Semver = {}
 Semver.__index = Semver
 
@@ -90,6 +91,7 @@ function M.version(version)
       patch = patch == "" and 0 or tonumber(patch),
       prerelease = prerelease ~= "" and prerelease or nil,
       build = build ~= "" and build or nil,
+      input = version,
     }, Semver)
   end
 end

lua/lazy/manage/task/fs.lua

@@ -1,28 +1,42 @@
-local Util = require("lazy.util")
 local Config = require("lazy.core.config")
+local Util = require("lazy.util")
 
 ---@type table<string, LazyTaskDef>
 local M = {}
 
+local function rm(dir)
+  local stat = vim.uv.fs_lstat(dir)
+  assert(stat and stat.type == "directory", dir .. " should be a directory!")
+  Util.walk(dir, function(path, _, type)
+    if type == "directory" then
+      vim.uv.fs_rmdir(path)
+    else
+      vim.uv.fs_unlink(path)
+    end
+  end)
+  vim.uv.fs_rmdir(dir)
+end
+
 M.clean = {
   skip = function(plugin)
     return plugin._.is_local
   end,
-  run = function(self)
+  ---@param opts? {rocks_only?:boolean}
+  run = function(self, opts)
+    opts = opts or {}
     local dir = self.plugin.dir:gsub("/+$", "")
     assert(dir:find(Config.options.root, 1, true) == 1, self.plugin.dir .. " should be under packpath!")
 
-    local stat = vim.loop.fs_lstat(dir)
-    assert(stat.type == "directory", self.plugin.dir .. " should be a directory!")
+    local rock_root = Config.options.rocks.root .. "/" .. self.plugin.name
+    if vim.uv.fs_stat(rock_root) then
+      rm(rock_root)
+    end
 
-    Util.walk(dir, function(path, _, type)
-      if type == "directory" then
-        vim.loop.fs_rmdir(path)
-      else
-        vim.loop.fs_unlink(path)
-      end
-    end)
-    vim.loop.fs_rmdir(dir)
+    if opts.rocks_only then
+      return
+    end
+
+    rm(dir)
 
     self.plugin._.installed = false
   end,

lua/lazy/manage/task/git.lua

@@ -1,8 +1,54 @@
+local Async = require("lazy.async")
+local Config = require("lazy.core.config")
 local Git = require("lazy.manage.git")
 local Lock = require("lazy.manage.lock")
-local Config = require("lazy.core.config")
 local Util = require("lazy.util")
 
+local throttle = {}
+throttle.running = 0
+throttle.waiting = {} ---@type Async[]
+throttle.timer = vim.uv.new_timer()
+
+function throttle.next()
+  throttle.running = 0
+  while #throttle.waiting > 0 and throttle.running < Config.options.git.throttle.rate do
+    ---@type Async
+    local task = table.remove(throttle.waiting, 1)
+    task:resume()
+    throttle.running = throttle.running + 1
+  end
+  if throttle.running == 0 then
+    throttle.timer:stop()
+  end
+end
+
+function throttle.wait()
+  if not Config.options.git.throttle.enabled then
+    return
+  end
+  if not throttle.timer:is_active() then
+    throttle.timer:start(0, Config.options.git.throttle.duration, vim.schedule_wrap(throttle.next))
+  end
+  local running = Async.running()
+  if throttle.running < Config.options.git.throttle.rate then
+    throttle.running = throttle.running + 1
+  else
+    table.insert(throttle.waiting, running)
+    coroutine.yield("waiting")
+    running:suspend()
+    coroutine.yield("")
+  end
+end
+
+---@param plugin LazyPlugin
+local function cooldown(plugin)
+  if not plugin._.last_check then
+    return false
+  end
+  local delta = (vim.uv.now() - plugin._.last_check) / 1000
+  return delta < Config.options.git.cooldown
+end
+
 ---@type table<string, LazyTaskDef>
 local M = {}
 
@@ -15,11 +61,13 @@ M.log = {
     if opts.updated and not (plugin._.updated and plugin._.updated.from ~= plugin._.updated.to) then
       return true
     end
-    local stat = vim.loop.fs_stat(plugin.dir .. "/.git")
+    local stat = vim.uv.fs_stat(plugin.dir .. "/.git")
     return not (stat and stat.type == "directory")
   end,
+  ---@async
   ---@param opts {args?: string[], updated?:boolean, check?:boolean}
   run = function(self, opts)
+    -- self:spawn({ "sleep", "5" })
     local args = {
       "log",
       "--pretty=format:%h %s (%cr)",
@@ -30,11 +78,13 @@ M.log = {
       "--no-show-signature",
     }
 
+    local info, target
+
     if opts.updated then
       table.insert(args, self.plugin._.updated.from .. ".." .. (self.plugin._.updated.to or "HEAD"))
     elseif opts.check then
-      local info = assert(Git.info(self.plugin.dir))
-      local target = assert(Git.get_target(self.plugin))
+      info = assert(Git.info(self.plugin.dir))
+      target = assert(Git.get_target(self.plugin))
       if not target.commit then
         for k, v in pairs(target) do
           error(k .. " '" .. v .. "' not found")
@@ -42,8 +92,17 @@ M.log = {
         error("no target commit found")
       end
       assert(target.commit, self.plugin.name .. " " .. target.branch)
-      if not Git.eq(info, target) then
-        self.plugin._.updates = { from = info, to = target }
+      if not self.plugin._.is_local then
+        if Git.eq(info, target) then
+          if Config.options.checker.check_pinned then
+            local last_commit = Git.get_commit(self.plugin.dir, target.branch, true)
+            if not Git.eq(info, { commit = last_commit }) then
+              self.plugin._.outdated = true
+            end
+          end
+        else
+          self.plugin._.updates = { from = info, to = target }
+        end
       end
       table.insert(args, info.commit .. ".." .. target.commit)
     else
@@ -54,6 +113,14 @@ M.log = {
       args = args,
       cwd = self.plugin.dir,
     })
+
+    -- for local plugins, mark as needing updates only if local is
+    -- behind upstream, i.e. if git log gave no output
+    if opts.check and self.plugin._.is_local then
+      if not vim.tbl_isempty(self:get_log()) then
+        self.plugin._.updates = { from = info, to = target }
+      end
+    end
   end,
 }
 
@@ -61,7 +128,9 @@ M.clone = {
   skip = function(plugin)
     return plugin._.installed or plugin._.is_local
   end,
+  ---@async
   run = function(self)
+    throttle.wait()
     local args = {
       "clone",
       self.plugin.url,
@@ -77,6 +146,12 @@ M.clone = {
 
     args[#args + 1] = "--origin=origin"
 
+    -- If git config --global core.autocrlf is true on a Unix/Linux system, then the git clone
+    -- process will lead to files with CRLF endings. Vi / vim / neovim cannot handle this.
+    -- Force git to clone with core.autocrlf=false.
+    args[#args + 1] = "-c"
+    args[#args + 1] = "core.autocrlf=false"
+
     args[#args + 1] = "--progress"
 
     if self.plugin.branch then
@@ -99,7 +174,7 @@ M.clone = {
           self.plugin._.cloned = true
           self.plugin._.installed = true
           self.plugin._.dirty = true
-          vim.loop.fs_unlink(marker)
+          vim.uv.fs_unlink(marker)
         end
       end,
     })
@@ -114,8 +189,9 @@ M.branch = {
       return true
     end
     local branch = assert(Git.get_branch(plugin))
-    return Git.get_commit(plugin.dir, branch)
+    return Git.get_commit(plugin.dir, branch, true)
   end,
+  ---@async
   run = function(self)
     local args = {
       "remote",
@@ -141,14 +217,17 @@ M.origin = {
     local origin = Git.get_origin(plugin.dir)
     return origin == plugin.url
   end,
+  ---@async
   ---@param opts {check?:boolean}
   run = function(self, opts)
     if opts.check then
       local origin = Git.get_origin(self.plugin.dir)
-      self.error = "Origin has changed:\n"
-      self.error = self.error .. "  * old: " .. origin .. "\n"
-      self.error = self.error .. "  * new: " .. self.plugin.url .. "\n"
-      self.error = self.error .. "Please run update to fix"
+      self:error({
+        "Origin has changed:",
+        "  * old: " .. origin,
+        "  * new: " .. self.plugin.url,
+        "Please run update to fix",
+      })
       return
     end
     require("lazy.manage.task.fs").clean.run(self, opts)
@@ -156,13 +235,52 @@ M.origin = {
   end,
 }
 
--- fetches all needed origin branches
-M.fetch = {
+M.status = {
   skip = function(plugin)
     return not plugin._.installed or plugin._.is_local
   end,
-
+  ---@async
   run = function(self)
+    self:spawn("git", {
+      args = { "ls-files", "-d", "-m" },
+      cwd = self.plugin.dir,
+      on_exit = function(ok, output)
+        if ok then
+          local lines = vim.split(output, "\n")
+          ---@type string[]
+          lines = vim.tbl_filter(function(line)
+            -- Fix doc/tags being marked as modified
+            if line:gsub("[\\/]", "/") == "doc/tags" then
+              local Process = require("lazy.manage.process")
+              Process.exec({ "git", "checkout", "--", "doc/tags" }, { cwd = self.plugin.dir })
+              return false
+            end
+            return line ~= ""
+          end, lines)
+          if #lines > 0 then
+            local msg = { "You have local changes in `" .. self.plugin.dir .. "`:" }
+            for _, line in ipairs(lines) do
+              msg[#msg + 1] = "  * " .. line
+            end
+            msg[#msg + 1] = "Please remove them to update."
+            msg[#msg + 1] = "You can also press `x` to remove the plugin and then `I` to install it again."
+            self:error(msg)
+          end
+        end
+      end,
+    })
+  end,
+}
+
+-- fetches all needed origin branches
+M.fetch = {
+  skip = function(plugin)
+    return not plugin._.installed or plugin._.is_local or cooldown(plugin)
+  end,
+
+  ---@async
+  run = function(self)
+    throttle.wait()
     local args = {
       "fetch",
       "--recurse-submodules",
@@ -178,6 +296,11 @@ M.fetch = {
     self:spawn("git", {
       args = args,
       cwd = self.plugin.dir,
+      on_exit = function(ok)
+        if ok then
+          self.plugin._.last_check = vim.uv.now()
+        end
+      end,
     })
   end,
 }
@@ -189,8 +312,10 @@ M.checkout = {
     return not plugin._.installed or plugin._.is_local
   end,
 
+  ---@async
   ---@param opts {lockfile?:boolean}
   run = function(self, opts)
+    throttle.wait()
     local info = assert(Git.info(self.plugin.dir))
     local target = assert(Git.get_target(self.plugin))
 
@@ -210,7 +335,7 @@ M.checkout = {
       end
     end
 
-    -- dont run checkout if target is already reached.
+    -- don't run checkout if target is already reached.
     -- unless we just cloned, since then we won't have any data yet
     if Git.eq(info, target) and info.branch == target.branch then
       self.plugin._.updated = {

lua/lazy/manage/task/init.lua

@@ -1,23 +1,29 @@
+local Async = require("lazy.async")
+local Config = require("lazy.core.config")
 local Process = require("lazy.manage.process")
+local Terminal = require("lazy.terminal")
+
+local colors = Config.options.headless.colors
 
 ---@class LazyTaskDef
 ---@field skip? fun(plugin:LazyPlugin, opts?:TaskOptions):any?
----@field run fun(task:LazyTask, opts:TaskOptions)
+---@field run async fun(task:LazyTask, opts:TaskOptions)
 
----@alias LazyTaskState fun():boolean?
+---@alias LazyTaskFn async fun(task:LazyTask, opts:TaskOptions)
 
----@class LazyTask
+---@class LazyMsg
+---@field msg string
+---@field level? number
+
+---@class LazyTask: Async
 ---@field plugin LazyPlugin
 ---@field name string
----@field output string
----@field status string
----@field error? string
----@field private _task fun(task:LazyTask)
----@field private _running LazyPluginState[]
----@field private _started? number
+---@field private _log LazyMsg[]
+---@field private _started number
 ---@field private _ended? number
 ---@field private _opts TaskOptions
-local Task = {}
+---@field private _level number
+local Task = setmetatable({}, { __index = Async.Async })
 
 ---@class TaskOptions: {[string]:any}
 ---@field on_done? fun(task:LazyTask)
@@ -25,146 +31,210 @@ local Task = {}
 ---@param plugin LazyPlugin
 ---@param name string
 ---@param opts? TaskOptions
----@param task fun(task:LazyTask)
+---@param task LazyTaskFn
 function Task.new(plugin, name, task, opts)
-  local self = setmetatable({}, {
-    __index = Task,
-  })
+  local self = setmetatable({}, { __index = Task })
+  ---@async
+  Task.init(self, function()
+    self:_run(task)
+  end)
+  self:set_level()
   self._opts = opts or {}
-  self._running = {}
-  self._task = task
-  self._started = nil
+  self._log = {}
   self.plugin = plugin
   self.name = name
-  self.output = ""
-  self.status = ""
-  plugin._.tasks = plugin._.tasks or {}
+  self._started = vim.uv.hrtime()
   ---@param other LazyTask
   plugin._.tasks = vim.tbl_filter(function(other)
-    return other.name ~= name or other:is_running()
-  end, plugin._.tasks)
+    return other.name ~= name or other:running()
+  end, plugin._.tasks or {})
   table.insert(plugin._.tasks, self)
+  self:render()
   return self
 end
 
-function Task:has_started()
-  return self._started ~= nil
+---@param level? number
+---@return LazyMsg[]
+function Task:get_log(level)
+  level = level or vim.log.levels.DEBUG
+  return vim.tbl_filter(function(msg)
+    return msg.level >= level
+  end, self._log)
 end
 
-function Task:is_done()
-  return self:has_started() and not self:is_running()
+---@param level? number
+function Task:output(level)
+  return table.concat(
+    ---@param m LazyMsg
+    vim.tbl_map(function(m)
+      return m.msg
+    end, self:get_log(level)),
+    "\n"
+  )
 end
 
-function Task:is_running()
-  return self:has_started() and self._ended == nil
+function Task:status()
+  local ret = self._log[#self._log]
+  local msg = ret and vim.trim(ret.msg) or ""
+  return msg ~= "" and msg or nil
 end
 
-function Task:start()
-  if vim.in_fast_event() then
-    return vim.schedule(function()
-      self:start()
+function Task:has_errors()
+  return self._level >= vim.log.levels.ERROR
+end
+
+function Task:has_warnings()
+  return self._level >= vim.log.levels.WARN
+end
+
+---@param level? number
+function Task:set_level(level)
+  self._level = level or vim.log.levels.TRACE
+end
+
+---@async
+---@param task LazyTaskFn
+function Task:_run(task)
+  if Config.headless() and Config.options.headless.task then
+    self:log("Running task " .. self.name, vim.log.levels.INFO)
+  end
+
+  self
+    :on("done", function()
+      self:_done()
     end)
+    :on("error", function(err)
+      self:error(err)
+    end)
+    :on("yield", function(msg)
+      self:log(msg)
+    end)
+  task(self, self._opts)
+end
+
+---@param msg string|string[]|LazyMsg
+---@param level? number
+function Task:log(msg, level)
+  if type(msg) == "table" and msg.msg then
+    level = msg.level or level
+    msg = msg.msg
   end
-  self._started = vim.loop.hrtime()
-  ---@type boolean, string|any
-  local ok, err = pcall(self._task, self, self._opts)
-  if not ok then
-    self.error = err or "failed"
+  level = level or vim.log.levels.DEBUG
+  self._level = math.max(self._level or 0, level or 0)
+  msg = type(msg) == "table" and table.concat(msg, "\n") or msg
+  ---@cast msg string
+  table.insert(self._log, { msg = msg, level = level })
+  self:render()
+  if Config.headless() then
+    self:headless()
   end
-  self:_check()
+end
+
+function Task:render()
+  vim.schedule(function()
+    vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
+  end)
+end
+
+function Task:headless()
+  if not Config.options.headless.log then
+    return
+  end
+  local msg = self._log[#self._log]
+  if not msg or msg.level == vim.log.levels.TRACE then
+    return
+  end
+  local map = {
+    [vim.log.levels.ERROR] = Terminal.red,
+    [vim.log.levels.WARN] = Terminal.yellow,
+    [vim.log.levels.INFO] = Terminal.blue,
+  }
+  local color = Config.options.headless.colors and map[msg.level]
+  io.write(Terminal.prefix(color and color(msg.msg) or msg.msg, self:prefix()))
+  io.write("\n")
+end
+
+---@param msg string|string[]
+function Task:error(msg)
+  self:log(msg, vim.log.levels.ERROR)
+end
+
+---@param msg string|string[]
+function Task:warn(msg)
+  self:log(msg, vim.log.levels.WARN)
 end
 
 ---@private
-function Task:_check()
-  for _, state in ipairs(self._running) do
-    if state() then
-      return
-    end
+function Task:_done()
+  if Config.headless() and Config.options.headless.task then
+    local ms = math.floor(self:time() + 0.5)
+    self:log("Finished task " .. self.name .. " in " .. ms .. "ms", vim.log.levels.INFO)
   end
-  self._ended = vim.loop.hrtime()
+  self._ended = vim.uv.hrtime()
   if self._opts.on_done then
     self._opts.on_done(self)
   end
-  vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
-  vim.api.nvim_exec_autocmds("User", {
-    pattern = "LazyPlugin" .. self.name:sub(1, 1):upper() .. self.name:sub(2),
-    data = { plugin = self.plugin.name },
-  })
+  self:render()
+  vim.schedule(function()
+    vim.api.nvim_exec_autocmds("User", {
+      pattern = "LazyPlugin" .. self.name:sub(1, 1):upper() .. self.name:sub(2),
+      data = { plugin = self.plugin.name },
+    })
+  end)
 end
 
 function Task:time()
-  if not self:has_started() then
-    return 0
-  end
-  if not self:is_done() then
-    return (vim.loop.hrtime() - self._started) / 1e6
-  end
-  return (self._ended - self._started) / 1e6
-end
-
----@param fn fun()
-function Task:schedule(fn)
-  local done = false
-  table.insert(self._running, function()
-    return not done
-  end)
-  vim.schedule(function()
-    ---@type boolean, string|any
-    local ok, err = pcall(fn)
-    if not ok then
-      self.error = err or "failed"
-    end
-    done = true
-    self:_check()
-  end)
+  return ((self._ended or vim.uv.hrtime()) - self._started) / 1e6
 end
 
+---@async
 ---@param cmd string
 ---@param opts? ProcessOpts
 function Task:spawn(cmd, opts)
   opts = opts or {}
   local on_line = opts.on_line
-  local on_exit = opts.on_exit
+
+  local headless = Config.headless() and Config.options.headless.process
 
   function opts.on_line(line)
-    self.status = line
+    if not headless then
+      return self:log(line, vim.log.levels.TRACE)
+    end
     if on_line then
       pcall(on_line, line)
     end
-    vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
   end
 
-  ---@param output string
-  function opts.on_exit(ok, output)
-    self.output = self.output .. output
-    if not ok then
-      self.error = self.error and (self.error .. "\n" .. output) or output
+  if headless then
+    opts.on_data = function(data)
+      -- prefix with plugin name
+      io.write(Terminal.prefix(data, self:prefix()))
     end
-    if on_exit then
-      pcall(on_exit, ok, output)
-    end
-    self:_check()
   end
+
   local proc = Process.spawn(cmd, opts)
-  table.insert(self._running, function()
-    return proc and not proc:is_closing()
-  end)
-end
+  proc:wait()
 
----@param tasks (LazyTask?)[]
-function Task.all_done(tasks)
-  for _, task in ipairs(tasks) do
-    if task and not task:is_done() then
-      return false
+  local ok = proc.code == 0 and proc.signal == 0
+  if not headless then
+    local msg = vim.trim(proc.data)
+    if #msg > 0 then
+      self:log(vim.trim(proc.data), ok and vim.log.levels.DEBUG or vim.log.levels.ERROR)
     end
   end
-  return true
+
+  if opts.on_exit then
+    pcall(opts.on_exit, ok, proc.data)
+  end
+  return ok
 end
 
-function Task:wait()
-  while self:is_running() do
-    vim.wait(10)
-  end
+function Task:prefix()
+  local plugin = "[" .. self.plugin.name .. "] "
+  local task = string.rep(" ", 20 - #(self.name .. self.plugin.name)) .. self.name
+
+  return colors and Terminal.magenta(plugin) .. Terminal.cyan(task) .. Terminal.bright_black(" | ")
+    or plugin .. " " .. task .. " | "
 end
 
 return Task

lua/lazy/manage/task/plugin.lua

@@ -1,6 +1,6 @@
-local Util = require("lazy.util")
 local Loader = require("lazy.core.loader")
-local Config = require("lazy.core.config")
+local Rocks = require("lazy.pkg.rockspec")
+local Util = require("lazy.util")
 
 ---@type table<string, LazyTaskDef>
 local M = {}
@@ -8,61 +8,77 @@ local M = {}
 ---@param plugin LazyPlugin
 local function get_build_file(plugin)
   for _, path in ipairs({ "build.lua", "build/init.lua" }) do
-    path = plugin.dir .. "/" .. path
-    if Util.file_exists(path) then
+    if Util.file_exists(plugin.dir .. "/" .. path) then
       return path
     end
   end
 end
 
+local B = {}
+
+---@param task LazyTask
+---@param build string
+function B.cmd(task, build)
+  if task.plugin.build ~= "rockspec" then
+    Loader.load(task.plugin, { task = "build" })
+  end
+  local cmd = vim.api.nvim_parse_cmd(build:sub(2), {}) --[[@as vim.api.keyset.cmd]]
+  task:log(vim.api.nvim_cmd(cmd, { output = true }))
+end
+
+---@async
+---@param task LazyTask
+---@param build string
+function B.shell(task, build)
+  local shell = vim.env.SHELL or vim.o.shell
+  local shell_args = shell:find("cmd.exe", 1, true) and "/c" or "-c"
+
+  task:spawn(shell, {
+    args = { shell_args, build },
+    cwd = task.plugin.dir,
+  })
+end
+
 M.build = {
   ---@param opts? {force:boolean}
   skip = function(plugin, opts)
     if opts and opts.force then
       return false
     end
-    return not (plugin._.dirty and (plugin.build or get_build_file(plugin)))
+    return not ((plugin._.dirty or plugin._.build) and (plugin.build or get_build_file(plugin)))
   end,
+  ---@async
   run = function(self)
     vim.cmd([[silent! runtime plugin/rplugin.vim]])
 
-    Loader.load(self.plugin, { task = "build" })
-
     local builders = self.plugin.build
 
-    local build_file = get_build_file(self.plugin)
-    if build_file then
-      if builders then
-        if Config.options.build.warn_on_override then
-          Util.warn(
-            ("Plugin **%s** provides its own build script, but you also defined a `build` command.\nThe `build.lua` file will not be used"):format(
-              self.plugin.name
-            )
-          )
-        end
-      else
-        builders = function()
-          Loader.source(build_file)
-        end
-      end
+    -- Skip if `build` is set to `false`
+    if builders == false then
+      return
     end
+
+    builders = builders or get_build_file(self.plugin)
+
     if builders then
       builders = type(builders) == "table" and builders or { builders }
       ---@cast builders (string|fun(LazyPlugin))[]
       for _, build in ipairs(builders) do
-        if type(build) == "string" and build:sub(1, 1) == ":" then
-          local cmd = vim.api.nvim_parse_cmd(build:sub(2), {})
-          self.output = vim.api.nvim_cmd(cmd, { output = true })
-        elseif type(build) == "function" then
+        if type(build) == "function" then
           build(self.plugin)
+        elseif build == "rockspec" then
+          Rocks.build(self)
+        elseif build:sub(1, 1) == ":" then
+          B.cmd(self, build)
+        elseif build:match("%.lua$") then
+          local file = self.plugin.dir .. "/" .. build
+          local chunk, err = loadfile(file)
+          if not chunk or err then
+            error(err)
+          end
+          chunk()
         else
-          local shell = vim.env.SHELL or vim.o.shell
-          local shell_args = shell:find("cmd.exe", 1, true) and "/c" or "-c"
-
-          self:spawn(shell, {
-            args = { shell_args, build },
-            cwd = self.plugin.dir,
-          })
+          B.shell(self, build)
         end
       end
     end
@@ -71,12 +87,23 @@ M.build = {
 
 M.docs = {
   skip = function(plugin)
-    return not plugin._.dirty
+    return not plugin._.is_local and not plugin._.dirty
   end,
   run = function(self)
-    local docs = self.plugin.dir .. "/doc/"
+    local docs = self.plugin.dir .. "/doc"
     if Util.file_exists(docs) then
-      self.output = vim.api.nvim_cmd({ cmd = "helptags", args = { docs } }, { output = true })
+      self:log(vim.api.nvim_cmd({ cmd = "helptags", args = { docs } }, { output = true }))
+    end
+  end,
+}
+
+M.exists = {
+  skip = function(plugin)
+    return not plugin._.is_local or plugin.virtual
+  end,
+  run = function(self)
+    if not Util.file_exists(self.plugin.dir) then
+      self:error("Local plugin does not exist at `" .. self.plugin.dir .. "`")
     end
   end,
 }

lua/lazy/minit.lua

@@ -0,0 +1,214 @@
+---@diagnostic disable: inject-field
+
+local islist = vim.islist or vim.tbl_islist
+
+local M = {}
+
+---@param opts LazyConfig
+---@return LazySpec[]
+local function get_spec(opts)
+  local ret = opts.spec or {}
+  return ret and type(ret) == "table" and islist(ret) and ret or { ret }
+end
+
+---@param defaults LazyConfig
+---@param opts LazyConfig
+function M.extend(defaults, opts)
+  local spec = {}
+  vim.list_extend(spec, get_spec(defaults))
+  vim.list_extend(spec, get_spec(opts))
+  return vim.tbl_deep_extend("force", defaults, opts, { spec = spec })
+end
+
+---@param opts LazyConfig
+function M.setup(opts)
+  opts = M.extend({
+    local_spec = false,
+    change_detection = { enabled = false },
+    dev = {
+      patterns = vim.env.LAZY_DEV and vim.split(vim.env.LAZY_DEV, ",") or nil,
+    },
+  }, opts)
+
+  local args = {}
+  local is_busted = false
+  local is_minitest = false
+  for _, a in ipairs(_G.arg) do
+    if a == "--busted" then
+      is_busted = true
+    elseif a == "--minitest" then
+      is_minitest = true
+    else
+      table.insert(args, a)
+    end
+  end
+  _G.arg = args
+
+  if is_busted then
+    opts = M.busted.setup(opts)
+  elseif is_minitest then
+    opts = M.minitest.setup(opts)
+  end
+
+  -- set stdpaths to use .tests
+  if vim.env.LAZY_STDPATH then
+    local root = vim.fn.fnamemodify(vim.env.LAZY_STDPATH, ":p")
+    for _, name in ipairs({ "config", "data", "state", "cache" }) do
+      vim.env[("XDG_%s_HOME"):format(name:upper())] = root .. "/" .. name
+    end
+  end
+  vim.o.loadplugins = true
+  require("lazy").setup(opts)
+  if vim.g.colors_name == nil then
+    vim.cmd("colorscheme habamax")
+  end
+  require("lazy").update():wait()
+  if vim.bo.filetype == "lazy" then
+    local errors = false
+    for _, plugin in pairs(require("lazy.core.config").spec.plugins) do
+      errors = errors or require("lazy.core.plugin").has_errors(plugin)
+    end
+    if not errors then
+      vim.cmd.close()
+    end
+  end
+
+  if is_busted then
+    M.busted.run()
+  elseif is_minitest then
+    M.minitest.run()
+  end
+end
+
+function M.repro(opts)
+  opts = M.extend({
+    spec = {
+      {
+        "folke/tokyonight.nvim",
+        priority = 1000,
+        lazy = false,
+        config = function()
+          require("tokyonight").setup({ style = "moon" })
+          require("tokyonight").load()
+        end,
+      },
+    },
+    install = { colorscheme = { "tokyonight" } },
+  }, opts)
+  M.setup(opts)
+end
+
+M.minitest = {}
+
+function M.minitest.run()
+  local Config = require("lazy.core.config")
+  -- disable termnial output for the tests
+  Config.options.headless = {}
+
+  if not require("lazy.core.config").headless() then
+    return vim.notify("busted can only run in headless mode. Please run with `nvim -l`", vim.log.levels.WARN)
+  end
+  package.path = package.path .. ";" .. vim.uv.cwd() .. "/tests/?.lua"
+  local Test = require("mini.test")
+  local expect = Test.expect
+  local _assert = assert
+  local Assert = {
+    __call = function(_, ...)
+      return _assert(...)
+    end,
+    same = expect.equality,
+    equal = expect.equality,
+    are = {
+      equal = expect.equality,
+    },
+    is_not = {
+      same = expect.no_equality,
+    },
+    is_not_nil = function(a)
+      return expect.no_equality(nil, a)
+    end,
+    is_true = function(a)
+      return expect.equality(true, a)
+    end,
+    is_false = function(a)
+      return expect.equality(false, a)
+    end,
+  }
+  Assert.__index = Assert
+  assert = setmetatable({}, Assert)
+  assert = require("luassert")
+  require("mini.test").run()
+end
+
+---@param opts LazyConfig
+function M.minitest.setup(opts)
+  return M.extend({
+    spec = {
+      "lunarmodules/luassert",
+      {
+        "echasnovski/mini.test",
+        opts = {
+          collect = {
+            find_files = function()
+              return vim.fn.globpath("tests", "**/*_spec.lua", true, true)
+            end,
+          },
+          -- script_path = "tests/minit.lua",
+        },
+      },
+      { dir = vim.uv.cwd() },
+    },
+    rocks = { hererocks = true },
+  }, opts)
+end
+
+M.busted = {}
+
+function M.busted.run()
+  local Config = require("lazy.core.config")
+  -- disable termnial output for the tests
+  Config.options.headless = {}
+
+  if not require("lazy.core.config").headless() then
+    return vim.notify("busted can only run in headless mode. Please run with `nvim -l`", vim.log.levels.WARN)
+  end
+  package.path = package.path .. ";" .. vim.uv.cwd() .. "/tests/?.lua"
+  -- run busted
+  return pcall(require("busted.runner"), {
+    standalone = false,
+  }) or os.exit(1)
+end
+
+---@param opts LazyConfig
+function M.busted.setup(opts)
+  local args = table.concat(_G.arg, " ")
+  local json = args:find("--output[ =]json")
+
+  return M.extend({
+    spec = {
+      "lunarmodules/busted",
+      { dir = vim.uv.cwd() },
+    },
+    headless = {
+      process = not json,
+      log = not json,
+      task = not json,
+    },
+    rocks = { hererocks = true },
+  }, opts)
+end
+
+---@param opts LazyConfig
+function M.busted.init(opts)
+  opts = M.busted.setup(opts)
+  M.setup(opts)
+  M.busted.run()
+end
+
+setmetatable(M.busted, {
+  __call = function(_, opts)
+    M.busted.init(opts)
+  end,
+})
+
+return M

lua/lazy/pkg/init.lua

@@ -0,0 +1,137 @@
+local Config = require("lazy.core.config")
+local Util = require("lazy.core.util")
+
+local M = {}
+M.VERSION = 12
+M.dirty = false
+
+---@class LazyPkg
+---@field name string
+---@field dir string
+---@field source "lazy" | "packspec" | "rockspec"
+---@field file string
+---@field spec LazyPluginSpec
+
+---@class LazyPkgSpec
+---@field file string
+---@field source? string
+---@field spec? LazySpec
+---@field code? string
+
+---@class LazyPkgSource
+---@field name string
+---@field get fun(plugin:LazyPlugin):LazyPkgSpec?
+
+---@class LazyPkgCache
+---@field pkgs LazyPkg[]
+---@field version number
+
+---@type LazyPkg[]?
+M.cache = nil
+
+function M.update()
+  ---@type LazyPkgSource[]
+  local sources = {}
+  for _, s in ipairs(Config.options.pkg.sources) do
+    if s ~= "rockspec" or Config.options.rocks.enabled then
+      sources[#sources + 1] = {
+        name = s,
+        get = require("lazy.pkg." .. s).get,
+      }
+    end
+  end
+
+  ---@type LazyPkgCache
+  local ret = {
+    version = M.VERSION,
+    pkgs = {},
+  }
+  for _, plugin in pairs(Config.plugins) do
+    if plugin._.installed then
+      for _, source in ipairs(sources) do
+        local spec = source.get(plugin)
+        if spec then
+          ---@type LazyPkg
+          local pkg = {
+            name = plugin.name,
+            dir = plugin.dir,
+            source = spec.source or source.name,
+            file = spec.file,
+            spec = spec.spec or {},
+          }
+          if type(spec.code) == "string" then
+            pkg.spec = { _raw = spec.code }
+          end
+          table.insert(ret.pkgs, pkg)
+          break
+        end
+      end
+    end
+  end
+  table.sort(ret.pkgs, function(a, b)
+    return a.name < b.name
+  end)
+  local U = require("lazy.util")
+  local code = "return " .. U.dump(ret)
+  vim.fn.mkdir(vim.fn.fnamemodify(Config.options.pkg.cache, ":h"), "p")
+  U.write_file(Config.options.pkg.cache, code)
+  M.dirty = false
+  M.cache = nil
+end
+
+local function _load()
+  Util.track("pkg")
+  M.cache = nil
+  if vim.uv.fs_stat(Config.options.pkg.cache) then
+    Util.try(function()
+      local chunk, err = loadfile(Config.options.pkg.cache)
+      if not chunk then
+        error(err)
+      end
+      ---@type LazyPkgCache?
+      local ret = chunk()
+      if ret and ret.version == M.VERSION then
+        M.cache = {}
+        for _, pkg in ipairs(ret.pkgs) do
+          if type(pkg.spec) == "function" then
+            pkg.spec = pkg.spec()
+          end
+          -- wrap in the scope of the plugin
+          pkg.spec = { pkg.name, specs = pkg.spec }
+        end
+        M.cache = ret.pkgs
+      end
+    end, "Error loading pkg:")
+  end
+  if rawget(M, "cache") then
+    M.dirty = false
+  else
+    M.cache = {}
+    M.dirty = true
+  end
+  Util.track()
+end
+
+---@param dir string
+---@return LazyPkg?
+---@overload fun():LazyPkg[]
+function M.get(dir)
+  if dir then
+    for _, pkg in ipairs(M.cache) do
+      if pkg.dir == dir then
+        return pkg
+      end
+    end
+    return
+  end
+  return M.cache
+end
+
+return setmetatable(M, {
+  __index = function(_, key)
+    if key == "cache" then
+      _load()
+      return M.cache
+    end
+  end,
+})

lua/lazy/pkg/lazy.lua

@@ -0,0 +1,29 @@
+local Util = require("lazy.util")
+
+local M = {}
+
+M.lazy_file = "lazy.lua"
+
+---@param plugin LazyPlugin
+---@return LazyPkg?
+function M.get(plugin)
+  local file = Util.norm(plugin.dir .. "/" .. M.lazy_file)
+  if Util.file_exists(file) then
+    ---@type fun(): LazySpec
+    local chunk = Util.try(function()
+      local ret, err = loadfile(file)
+      return err and error(err) or ret
+    end, "`" .. M.lazy_file .. "` for **" .. plugin.name .. "** has errors:")
+    if not chunk then
+      Util.error("Invalid `" .. M.lazy_file .. "` for **" .. plugin.name .. "**")
+      return
+    end
+    return {
+      source = "lazy",
+      file = M.lazy_file,
+      code = "function()\n" .. Util.read_file(file) .. "\nend",
+    }
+  end
+end
+
+return M

lua/lazy/pkg/packspec.lua

@@ -0,0 +1,54 @@
+local Util = require("lazy.util")
+
+---@class PackSpec
+---@field dependencies? table<string, string>
+---@field lazy? LazyPluginSpec
+---
+local M = {}
+
+M.pkg_file = "pkg.json"
+
+---@param plugin LazyPlugin
+---@return LazyPkg?
+function M.get(plugin)
+  local file = Util.norm(plugin.dir .. "/" .. M.pkg_file)
+  if not Util.file_exists(file) then
+    return
+  end
+  ---@type PackSpec
+  local pkg = Util.try(function()
+    return vim.json.decode(Util.read_file(file))
+  end, "`" .. M.pkg_file .. "` for **" .. plugin.name .. "** has errors:")
+
+  if not pkg then
+    return
+  end
+
+  ---@type LazySpec
+  local ret = {}
+  if pkg.dependencies then
+    for url, version in pairs(pkg.dependencies) do
+      -- HACK: Add `.git` to github urls
+      if url:find("github") and not url:match("%.git$") then
+        url = url .. ".git"
+      end
+      ret[#ret + 1] = { url = url, version = version }
+    end
+  end
+  local p = pkg.lazy
+  if p then
+    p.url = p.url or plugin.url
+    p.dir = p.dir or plugin.dir
+    ret[#ret + 1] = p
+  end
+  if pkg.lazy then
+    ret[#ret + 1] = pkg.lazy
+  end
+  return {
+    source = "lazy",
+    file = M.pkg_file,
+    spec = ret,
+  }
+end
+
+return M

lua/lazy/pkg/rockspec.lua

@@ -0,0 +1,343 @@
+--# selene:allow(incorrect_standard_library_use)
+local Community = require("lazy.community")
+
+local Config = require("lazy.core.config")
+local Health = require("lazy.health")
+local Util = require("lazy.util")
+
+---@class RockSpec
+---@field rockspec_format string
+---@field package string
+---@field version string
+---@field dependencies string[]
+---@field build? {type?: string, modules?: any[]}
+---@field source? {url?: string}
+
+---@class RockManifest
+---@field repository table<string, table<string,any>>
+
+local M = {}
+
+M.skip = { "lua" }
+M.rewrites = {
+  ["plenary.nvim"] = { "nvim-lua/plenary.nvim", lazy = true },
+}
+
+M.python = { "python3", "python" }
+
+---@class HereRocks
+M.hererocks = {}
+
+---@param task LazyTask
+function M.hererocks.build(task)
+  local root = Config.options.rocks.root .. "/hererocks"
+
+  ---@param p string
+  local python = vim.tbl_filter(function(p)
+    return vim.fn.executable(p) == 1
+  end, M.python)[1]
+
+  task:spawn(python, {
+    args = {
+      "hererocks.py",
+      "--verbose",
+      "-l",
+      "5.1",
+      "-r",
+      "latest",
+      root,
+    },
+    cwd = task.plugin.dir,
+  })
+end
+
+---@param bin string
+function M.hererocks.bin(bin)
+  local hererocks = Config.options.rocks.root .. "/hererocks/bin"
+  return Util.norm(hererocks .. "/" .. bin)
+end
+
+-- check if hererocks is building
+---@return boolean?
+function M.hererocks.building()
+  return vim.tbl_get(Config.plugins.hererocks or {}, "_", "build")
+end
+
+---@param opts? LazyHealth
+function M.check(opts)
+  opts = vim.tbl_extend("force", {
+    error = Util.error,
+    warn = Util.warn,
+    ok = function() end,
+  }, opts or {})
+
+  local ok = false
+  if Config.hererocks() then
+    if M.hererocks.building() then
+      ok = true
+    else
+      ok = Health.have(M.python, opts)
+      ok = Health.have(M.hererocks.bin("luarocks")) and ok
+      Health.have(
+        M.hererocks.bin("lua"),
+        vim.tbl_extend("force", opts, {
+          version = "-v",
+          version_pattern = "5.1",
+        })
+      )
+    end
+  else
+    ok = Health.have("luarocks", opts)
+    Health.have(
+      { "lua5.1", "lua", "lua-5.1" },
+      vim.tbl_extend("force", opts, {
+        version = "-v",
+        version_pattern = "5.1",
+      })
+    )
+  end
+  return ok
+end
+
+---@async
+---@param task LazyTask
+function M.build(task)
+  M.check({
+    error = function(msg)
+      task:error(msg:gsub("[{}]", "`"))
+    end,
+    warn = function(msg)
+      task:warn(msg)
+    end,
+    ok = function(msg) end,
+  })
+
+  if task:has_warnings() then
+    task:log({
+      "",
+      "This plugin requires `luarocks`. Try one of the following:",
+      " - fix your `luarocks` installation",
+      Config.hererocks() and " - disable *hererocks* with `opts.rocks.hererocks = false`"
+        or " - enable `hererocks` with `opts.rocks.hererocks = true`",
+      " - disable `luarocks` support completely with `opts.rocks.enabled = false`",
+    })
+    task:warn("\nWill try building anyway, but will likely fail...")
+
+    task:warn("\n" .. string.rep("-", 80) .. "\n")
+
+    task:set_level(vim.log.levels.WARN)
+  end
+
+  if task.plugin.name == "hererocks" then
+    return M.hererocks.build(task)
+  end
+
+  local env = {}
+  local luarocks = "luarocks"
+  if Config.hererocks() then
+    -- hererocks is still building, so skip for now
+    -- a new build will happen in the next round
+    if M.hererocks.building() then
+      return
+    end
+
+    local sep = Util.is_win and ";" or ":"
+    local hererocks = Config.options.rocks.root .. "/hererocks/bin"
+    if Util.is_win then
+      hererocks = hererocks:gsub("/", "\\")
+    end
+    local path = vim.split(vim.env.PATH, sep)
+    table.insert(path, 1, hererocks)
+    env = {
+      PATH = table.concat(path, sep),
+    }
+    if Util.is_win then
+      luarocks = luarocks .. ".bat"
+    end
+  end
+
+  local pkg = task.plugin._.pkg
+  assert(pkg, "missing rockspec pkg for " .. task.plugin.name .. "\nThis shouldn't happen, please report.")
+
+  local rockspec = M.rockspec(task.plugin.dir .. "/" .. pkg.file) or {}
+  assert(
+    rockspec.package,
+    "missing rockspec package name for " .. task.plugin.name .. "\nThis shouldn't happen, please report."
+  )
+
+  local root = Config.options.rocks.root .. "/" .. task.plugin.name
+  local ok = task:spawn(luarocks, {
+    args = {
+      "--tree",
+      root,
+      "--server",
+      Config.options.rocks.server,
+      "--lua-version",
+      "5.1",
+      "install", -- use install so that we can make use of pre-built rocks
+      "--force-fast",
+      "--deps-mode",
+      "one",
+      rockspec.package,
+    },
+    cwd = task.plugin.dir,
+    env = env,
+  })
+
+  if ok then
+    return
+  end
+
+  task:warn("Failed installing " .. rockspec.package .. " with `luarocks`.")
+  task:warn("\n" .. string.rep("-", 80) .. "\n")
+  task:warn("Trying to build from source.")
+
+  -- install failed, so try building from source
+  task:set_level() -- reset level
+  ok = task:spawn(luarocks, {
+    args = {
+      "--tree",
+      root,
+      "--dev",
+      "--lua-version",
+      "5.1",
+      "make",
+      "--force-fast",
+      "--deps-mode",
+      "one",
+    },
+    cwd = task.plugin.dir,
+    env = env,
+  })
+  if not ok then
+    require("lazy.manage.task.fs").clean.run(task, { rocks_only = true })
+  end
+end
+
+---@param rockspec RockSpec
+function M.is_simple_build(rockspec)
+  local type = vim.tbl_get(rockspec, "build", "type")
+  return type == nil or type == "none" or (type == "builtin" and not rockspec.build.modules)
+end
+
+---@param file string
+---@return table?
+function M.parse(file)
+  local ret = {}
+  local ok = pcall(function()
+    loadfile(file, nil, ret)()
+  end) and ret or nil
+  return ok and ret or nil
+end
+
+---@param plugin LazyPlugin
+function M.deps(plugin)
+  local root = Config.options.rocks.root .. "/" .. plugin.name
+  ---@type RockManifest?
+  local manifest = M.parse(root .. "/lib/luarocks/rocks-5.1/manifest")
+  return manifest and vim.tbl_keys(manifest.repository or {})
+end
+
+---@param file string
+---@return RockSpec?
+function M.rockspec(file)
+  return M.parse(file)
+end
+
+---@param plugin LazyPlugin
+function M.find_rockspec(plugin)
+  local rockspec_file ---@type string?
+  Util.ls(plugin.dir, function(path, name, t)
+    if t == "file" then
+      for _, suffix in ipairs({ "scm", "git", "dev" }) do
+        suffix = suffix .. "-1.rockspec"
+        if name:sub(-#suffix) == suffix then
+          rockspec_file = path
+          return false
+        end
+      end
+    end
+  end)
+  return rockspec_file
+end
+
+---@param plugin LazyPlugin
+---@return LazyPkgSpec?
+function M.get(plugin)
+  if Community.get_spec(plugin.name) then
+    return {
+      file = "community",
+      source = "lazy",
+      spec = Community.get_spec(plugin.name),
+    }
+  end
+
+  local rockspec_file = M.find_rockspec(plugin)
+  local rockspec = rockspec_file and M.rockspec(rockspec_file)
+  if not rockspec then
+    return
+  end
+
+  local has_lua = not not vim.uv.fs_stat(plugin.dir .. "/lua")
+
+  ---@type LazyPluginSpec
+  local specs = {}
+
+  ---@param dep string
+  local rocks = vim.tbl_filter(function(dep)
+    local name = dep:gsub("%s.*", "")
+    local url = Community.get_url(name)
+    local spec = Community.get_spec(name)
+
+    if spec then
+      -- community spec
+      table.insert(specs, spec)
+      return false
+    elseif url then
+      -- Neovim plugin rock
+      table.insert(specs, { url })
+      return false
+    end
+    return not vim.tbl_contains(M.skip, name)
+  end, rockspec.dependencies or {})
+
+  local use =
+    -- package without a /lua directory
+    not has_lua
+    -- has dependencies that are not skipped, 
+    -- not in community specs, 
+    -- and don't have a rockspec mapping
+    or #rocks > 0
+    -- has a complex build process
+    or not M.is_simple_build(rockspec)
+
+  if not use then
+    -- community specs only
+    return #specs > 0
+        and {
+          file = vim.fn.fnamemodify(rockspec_file, ":t"),
+          spec = {
+            plugin.name,
+            specs = specs,
+            build = false,
+          },
+        }
+      or nil
+  end
+
+  local lazy = nil
+  if not has_lua then
+    lazy = false
+  end
+
+  return {
+    file = vim.fn.fnamemodify(rockspec_file, ":t"),
+    spec = {
+      plugin.name,
+      build = "rockspec",
+      lazy = lazy,
+    },
+  }
+end
+
+return M

lua/lazy/state.lua

@@ -1,5 +1,5 @@
-local Util = require("lazy.util")
 local Config = require("lazy.core.config")
+local Util = require("lazy.util")
 
 ---@type LazyState
 local M = {}

lua/lazy/stats.lua

@@ -6,7 +6,7 @@ local M = {}
 M._stats = {
   -- startuptime in milliseconds till UIEnter
   startuptime = 0,
-  -- when true, startuptime is the accurate cputime for the Neovim process. (Linux & Macos)
+  -- when true, startuptime is the accurate cputime for the Neovim process. (Linux & macOS)
   -- this is more accurate than `nvim --startuptime`, and as such will be slightly higher
   -- when false, startuptime is calculated based on a delta with a timestamp when lazy started.
   real_cputime = false,
@@ -21,6 +21,7 @@ M.C = nil
 
 function M.on_ui_enter()
   M._stats.startuptime = M.track("UIEnter")
+  require("lazy.core.util").track({ start = "startuptime" }, M._stats.startuptime * 1e6)
   vim.api.nvim_exec_autocmds("User", { pattern = "LazyVimStarted", modeline = false })
 end
 
@@ -54,7 +55,7 @@ function M.cputime()
   end
 
   local function fallback()
-    return (vim.loop.hrtime() - require("lazy")._start) / 1e6
+    return (vim.uv.hrtime() - require("lazy")._start) / 1e6
   end
 
   local ok, ret = pcall(real)

lua/lazy/terminal.lua

@@ -0,0 +1,71 @@
+---@class Ansi: table<string, fun(string):string>
+local M = {}
+
+M.colors = {
+  reset = "\27[0m",
+  black = "\27[30m",
+  red = "\27[31m",
+  green = "\27[32m",
+  yellow = "\27[33m",
+  blue = "\27[34m",
+  magenta = "\27[35m",
+  cyan = "\27[36m",
+  white = "\27[37m",
+  bright_black = "\27[90m",
+  bright_red = "\27[91m",
+  bright_green = "\27[92m",
+  bright_yellow = "\27[93m",
+  bright_blue = "\27[94m",
+  bright_magenta = "\27[95m",
+  bright_cyan = "\27[96m",
+  bright_white = "\27[97m",
+}
+
+function M.color(text, color)
+  return M.colors[color] .. text .. M.colors.reset
+end
+
+-- stylua: ignore start
+function M.black(text) return M.color(text, "black") end
+function M.red(text) return M.color(text, "red") end
+function M.green(text) return M.color(text, "green") end
+function M.yellow(text) return M.color(text, "yellow") end
+function M.blue(text) return M.color(text, "blue") end
+function M.magenta(text) return M.color(text, "magenta") end
+function M.cyan(text) return M.color(text, "cyan") end
+function M.white(text) return M.color(text, "white") end
+function M.bright_black(text) return M.color(text, "bright_black") end
+function M.bright_red(text) return M.color(text, "bright_red") end
+function M.bright_green(text) return M.color(text, "bright_green") end
+function M.bright_yellow(text) return M.color(text, "bright_yellow") end
+function M.bright_blue(text) return M.color(text, "bright_blue") end
+function M.bright_magenta(text) return M.color(text, "bright_magenta") end
+function M.bright_cyan(text) return M.color(text, "bright_cyan") end
+function M.bright_white(text) return M.color(text, "bright_white") end
+-- stylua: ignore end
+
+---@param data string
+---@param prefix string
+function M.prefix(data, prefix)
+  -- Normalize Windows-style newlines to simple newlines
+  data = data:gsub("\r\n", "\n")
+
+  -- Handle prefix for the first line, if data starts immediately
+  data = prefix .. data
+
+  -- Prefix new lines ensuring not to double prefix if a line starts with \r
+  data = data:gsub("(\n)([^\r])", "%1" .. prefix .. "%2")
+
+  -- Handle carriage returns properly to avoid double prefixing
+  -- Replace any \r not followed by \n with \r, then add a prefix only if the following character isn't the start of our prefix
+  data = data:gsub("\r([^\n])", function(nextChar)
+    if nextChar:sub(1, #prefix) == prefix then
+      return "\r" .. nextChar
+    else
+      return "\r" .. prefix .. nextChar
+    end
+  end)
+  return data
+end
+
+return M

lua/lazy/types.lua

@@ -2,22 +2,28 @@
 ---@alias LazyPluginKind "normal"|"clean"|"disabled"
 
 ---@class LazyPluginState
----@field fid number id of the plugin spec fragment
----@field fpid? number parent id of the plugin spec fragment
----@field fdeps? number[] children ids of the fragment
----@field loaded? {[string]:string}|{time:number}
----@field installed? boolean
----@field tasks? LazyTask[]
----@field dirty? boolean
----@field updated? {from:string, to:string}
----@field is_local? boolean
----@field updates? {from:GitInfo, to:GitInfo}
+---@field cache? table<string,any>
 ---@field cloned? boolean
----@field kind? LazyPluginKind
----@field dep? boolean True if this plugin is only in the spec as a dependency
 ---@field cond? boolean
----@field super? LazyPlugin
----@field module? string
+---@field dep? boolean True if this plugin is only in the spec as a dependency
+---@field dir? string Explicit dir or dev set for this plugin
+---@field dirty? boolean
+---@field build? boolean
+---@field frags? number[]
+---@field top? boolean
+---@field handlers? LazyPluginHandlers
+---@field installed? boolean
+---@field is_local? boolean
+---@field kind? LazyPluginKind
+---@field loaded? {[string]:string}|{time:number}
+---@field outdated? boolean
+---@field rtp_loaded? boolean
+---@field tasks? LazyTask[]
+---@field updated? {from:string, to:string}
+---@field updates? {from:GitInfo, to:GitInfo}
+---@field last_check? number
+---@field working? boolean
+---@field pkg? LazyPkg
 
 ---@alias PluginOpts table|fun(self:LazyPlugin, opts:table):table?
 
@@ -25,21 +31,20 @@
 ---@field init? fun(self:LazyPlugin) Will always be run
 ---@field deactivate? fun(self:LazyPlugin) Unload/Stop a plugin
 ---@field config? fun(self:LazyPlugin, opts:table)|true Will be executed when loading the plugin
----@field build? string|fun(self:LazyPlugin)|(string|fun(self:LazyPlugin))[]
+---@field build? false|string|async fun(self:LazyPlugin)|(string|async fun(self:LazyPlugin))[]
 ---@field opts? PluginOpts
 
 ---@class LazyPluginHandlers
----@field event? string[]
----@field cmd? string[]
----@field ft? string[]
----@field keys? (string|LazyKeysSpec)[]
----@field module? false
+---@field event? table<string,LazyEvent>
+---@field ft? table<string,LazyEvent>
+---@field keys? table<string,LazyKeys>
+---@field cmd? table<string,string>
 
 ---@class LazyPluginRef
 ---@field branch? string
 ---@field tag? string
 ---@field commit? string
----@field version? string
+---@field version? string|boolean
 ---@field pin? boolean
 ---@field submodules? boolean Defaults to true
 
@@ -55,24 +60,43 @@
 ---@field lazy? boolean
 ---@field priority? number Only useful for lazy=false plugins to force loading certain plugins first. Default priority is 50
 ---@field dev? boolean If set, then link to the respective folder under your ~/projects
+---@field rocks? string[]
+---@field virtual? boolean virtual plugins won't be installed or added to the rtp.
 
 ---@class LazyPlugin: LazyPluginBase,LazyPluginHandlers,LazyPluginHooks,LazyPluginRef
 ---@field dependencies? string[]
+---@field specs? string|string[]|LazyPluginSpec[]
 ---@field _ LazyPluginState
 
 ---@class LazyPluginSpecHandlers
----@field event? string[]|string|fun(self:LazyPlugin, event:string[]):string[]
+---@field event? string[]|string|LazyEventSpec[]|fun(self:LazyPlugin, event:string[]):string[]
 ---@field cmd? string[]|string|fun(self:LazyPlugin, cmd:string[]):string[]
 ---@field ft? string[]|string|fun(self:LazyPlugin, ft:string[]):string[]
----@field keys? string|string[]|LazyKeys[]|fun(self:LazyPlugin, keys:string[]):(string|LazyKeys)[]
+---@field keys? string|string[]|LazyKeysSpec[]|fun(self:LazyPlugin, keys:string[]):((string|LazyKeys)[])
 ---@field module? false
 
 ---@class LazyPluginSpec: LazyPluginBase,LazyPluginSpecHandlers,LazyPluginHooks,LazyPluginRef
+---@field name? string display name and name used for plugin config files
+---@field dir? string
 ---@field dependencies? string|string[]|LazyPluginSpec[]
+---@field specs? string|string[]|LazyPluginSpec[]
 
 ---@alias LazySpec string|LazyPluginSpec|LazySpecImport|LazySpec[]
 
 ---@class LazySpecImport
----@field import string spec module to import
+---@field import string|(fun():LazyPluginSpec) spec module to import
+---@field name? string
 ---@field enabled? boolean|(fun():boolean)
 ---@field cond? boolean|(fun():boolean)
+
+---@class LazyFragment
+---@field id number
+---@field pkg? boolean
+---@field pid? number
+---@field deps? number[]
+---@field frags? number[]
+---@field dep? boolean
+---@field name string
+---@field url? string
+---@field dir? string
+---@field spec LazyPlugin

lua/lazy/util.lua

@@ -2,7 +2,7 @@
 local M = setmetatable({}, { __index = require("lazy.core.util") })
 
 function M.file_exists(file)
-  return vim.loop.fs_stat(file) ~= nil
+  return vim.uv.fs_stat(file) ~= nil
 end
 
 ---@param opts? LazyFloatOptions
@@ -19,13 +19,15 @@ function M.wo(win, k, v)
   end
 end
 
-function M.open(uri)
-  if M.file_exists(uri) then
+---@param opts? {system?:boolean}
+function M.open(uri, opts)
+  opts = opts or {}
+  if not opts.system and M.file_exists(uri) then
     return M.float({ style = "", file = uri })
   end
   local Config = require("lazy.core.config")
   local cmd
-  if Config.options.ui.browser then
+  if not opts.system and Config.options.ui.browser then
     cmd = { Config.options.ui.browser, uri }
   elseif vim.fn.has("win32") == 1 then
     cmd = { "explorer", uri }
@@ -71,31 +73,57 @@ end
 ---@param fn F
 ---@return F
 function M.throttle(ms, fn)
-  local timer = vim.loop.new_timer()
-  local running = false
-  local first = true
+  ---@type Async
+  local async
+  local pending = false
 
-  return function(...)
-    local args = { ... }
-    local wrapped = function()
-      fn(unpack(args))
+  return function()
+    if async and async:running() then
+      pending = true
+      return
     end
-    if not running then
-      if first then
-        wrapped()
-        first = false
-      end
+    ---@async
+    async = require("lazy.async").new(function()
+      repeat
+        pending = false
+        fn()
+        async:sleep(ms)
 
-      timer:start(ms, 0, function()
-        running = false
-        vim.schedule(wrapped)
-      end)
-
-      running = true
-    end
+      until not pending
+    end)
   end
 end
 
+--- Creates a weak reference to an object.
+--- Calling the returned function will return the object if it has not been garbage collected.
+---@generic T: table
+---@param obj T
+---@return T|fun():T?
+function M.weak(obj)
+  local weak = { _obj = obj }
+  ---@return table<any, any>
+  local function get()
+    local ret = rawget(weak, "_obj")
+    return ret == nil and error("Object has been garbage collected", 2) or ret
+  end
+  local mt = {
+    __mode = "v",
+    __call = function(t)
+      return rawget(t, "_obj")
+    end,
+    __index = function(_, k)
+      return get()[k]
+    end,
+    __newindex = function(_, k, v)
+      get()[k] = v
+    end,
+    __pairs = function()
+      return pairs(get())
+    end,
+  }
+  return setmetatable(weak, mt)
+end
+
 ---@class LazyCmdOptions: LazyFloatOptions
 ---@field cwd? string
 ---@field env? table<string,string>
@@ -134,12 +162,21 @@ end
 ---@param opts? LazyCmdOptions|{filetype?:string}
 function M.float_cmd(cmd, opts)
   opts = opts or {}
+  local Process = require("lazy.manage.process")
+  local lines, code = Process.exec(cmd, { cwd = opts.cwd })
+  if code ~= 0 then
+    M.error({
+      "`" .. table.concat(cmd, " ") .. "`",
+      "",
+      "## Error",
+      table.concat(lines, "\n"),
+    }, { title = "Command Failed (" .. code .. ")" })
+    return
+  end
   local float = M.float(opts)
   if opts.filetype then
     vim.bo[float.buf].filetype = opts.filetype
   end
-  local Process = require("lazy.manage.process")
-  local lines = Process.exec(cmd, { cwd = opts.cwd })
   vim.api.nvim_buf_set_lines(float.buf, 0, -1, false, lines)
   vim.bo[float.buf].modifiable = false
   return float
@@ -205,20 +242,25 @@ function M._dump(value, result)
     table.insert(result, tostring(value))
   elseif t == "string" then
     table.insert(result, ("%q"):format(value))
+  elseif t == "table" and value._raw then
+    table.insert(result, value._raw)
   elseif t == "table" then
     table.insert(result, "{")
-    local i = 1
-    ---@diagnostic disable-next-line: no-unknown
-    for k, v in pairs(value) do
-      if k == i then
-      elseif type(k) == "string" then
-        table.insert(result, ("[%q]="):format(k))
-      else
-        table.insert(result, k .. "=")
-      end
+    for _, v in ipairs(value) do
       M._dump(v, result)
       table.insert(result, ",")
-      i = i + 1
+    end
+    ---@diagnostic disable-next-line: no-unknown
+    for k, v in pairs(value) do
+      if type(k) == "string" then
+        if k:match("^[a-zA-Z]+$") then
+          table.insert(result, ("%s="):format(k))
+        else
+          table.insert(result, ("[%q]="):format(k))
+        end
+        M._dump(v, result)
+        table.insert(result, ",")
+      end
     end
     table.insert(result, "}")
   else

lua/lazy/view/colors.lua

@@ -21,27 +21,31 @@ M.colors = {
   ReasonPlugin = "Special",
   ReasonEvent = "Constant",
   ReasonKeys = "Statement",
-  ReasonStart = "@field",
+  ReasonStart = "@variable.member",
   ReasonSource = "Character",
   ReasonFt = "Character",
   ReasonCmd = "Operator",
   ReasonImport = "Identifier",
+  ReasonRequire = "@variable.parameter",
   Button = "CursorLine",
   ButtonActive = "Visual",
   TaskOutput = "MsgArea", -- task output
-  TaskError = "ErrorMsg", -- task errors
-  Dir = "@text.reference", -- directory
-  Url = "@text.reference", -- url
+  Error = "DiagnosticError", -- task errors
+  Warning = "DiagnosticWarn", -- task errors
+  Info = "DiagnosticInfo", -- task errors
+  Dir = "@markup.link", -- directory
+  Url = "@markup.link", -- url
+  Bold = { bold = true },
+  Italic = { italic = true },
 }
 
 M.did_setup = false
 
 function M.set_hl()
   for hl_group, link in pairs(M.colors) do
-    vim.api.nvim_set_hl(0, "Lazy" .. hl_group, {
-      link = link,
-      default = true,
-    })
+    local hl = type(link) == "table" and link or { link = link }
+    hl.default = true
+    vim.api.nvim_set_hl(0, "Lazy" .. hl_group, hl)
   end
 end
 
@@ -53,6 +57,11 @@ function M.setup()
   M.did_setup = true
 
   M.set_hl()
+  vim.api.nvim_create_autocmd("VimEnter", {
+    callback = function()
+      M.set_hl()
+    end,
+  })
   vim.api.nvim_create_autocmd("ColorScheme", {
     callback = function()
       M.set_hl()

lua/lazy/view/commands.lua

@@ -1,7 +1,8 @@
-local View = require("lazy.view")
+local require = require("lazy.core.util").lazy_require
+local Config = require("lazy.core.config")
 local Manage = require("lazy.manage")
 local Util = require("lazy.util")
-local Config = require("lazy.core.config")
+local View = require("lazy.view")
 local ViewConfig = require("lazy.view.config")
 
 local M = {}
@@ -33,6 +34,21 @@ M.commands = {
   health = function()
     vim.cmd.checkhealth("lazy")
   end,
+  ---@param opts ManagerOpts
+  pkg = function(opts)
+    local Pkg = require("lazy.pkg")
+    Pkg.update()
+    require("lazy.manage.reloader").reload({
+      {
+        file = "pkg",
+        what = "changed",
+      },
+    })
+    for _, plugin in pairs(opts and opts.plugins or {}) do
+      local spec = Pkg.get(plugin.dir)
+      Util.info(vim.inspect(spec), { lang = "lua", title = plugin.name })
+    end
+  end,
   home = function()
     View.show("home")
   end,
@@ -55,6 +71,9 @@ M.commands = {
   end,
   reload = function(opts)
     for _, plugin in pairs(opts.plugins) do
+      if type(plugin) == "string" then
+        plugin = Config.plugins[plugin]
+      end
       Util.warn("Reloading **" .. plugin.name .. "**")
       require("lazy.core.loader").reload(plugin)
     end
@@ -70,7 +89,7 @@ M.commands = {
 }
 
 function M.complete(cmd, prefix)
-  if not (ViewConfig.commands[cmd] or {}).plugins then
+  if not (ViewConfig.commands[cmd] or {}).plugins and cmd ~= "pkg" then
     return
   end
   ---@type string[]
@@ -127,7 +146,7 @@ end
 ---@return string, string[]
 function M.parse(args)
   local parts = vim.split(vim.trim(args), "%s+")
-  if parts[1]:find("Lazy") then
+  if vim.startswith("Lazy", parts[1]) then
     table.remove(parts, 1)
   end
   if args:sub(-1) == " " then

lua/lazy/view/config.lua

@@ -24,7 +24,7 @@ function M.get_commands()
   return ret
 end
 
-M.dimmed_commits = { "build", "ci", "chore", "doc", "test" }
+M.dimmed_commits = { "bot", "build", "ci", "chore", "doc", "style", "test" }
 
 M.keys = {
   hover = "K",
@@ -34,6 +34,8 @@ M.keys = {
   profile_sort = "<C-s>",
   profile_filter = "<C-f>",
   abort = "<C-c>",
+  next = "]]",
+  prev = "[[",
 }
 
 ---@type table<string,LazyViewCommand>

lua/lazy/view/float.lua

@@ -1,6 +1,6 @@
 local Config = require("lazy.core.config")
-local ViewConfig = require("lazy.view.config")
 local Util = require("lazy.util")
+local ViewConfig = require("lazy.view.config")
 
 ---@class LazyFloatOptions
 ---@field buf? number
@@ -15,12 +15,16 @@ local Util = require("lazy.util")
 ---@field persistent? boolean
 ---@field ft? string
 ---@field noautocmd? boolean
+---@field backdrop? float
 
 ---@class LazyFloat
 ---@field buf number
 ---@field win number
 ---@field opts LazyFloatOptions
 ---@field win_opts LazyWinOpts
+---@field backdrop_buf number
+---@field backdrop_win number
+---@field id number
 ---@overload fun(opts?:LazyFloatOptions):LazyFloat
 local M = {}
 
@@ -30,6 +34,12 @@ setmetatable(M, {
   end,
 })
 
+local _id = 0
+local function next_id()
+  _id = _id + 1
+  return _id
+end
+
 ---@param opts? LazyFloatOptions
 function M.new(opts)
   local self = setmetatable({}, { __index = M })
@@ -39,10 +49,12 @@ end
 ---@param opts? LazyFloatOptions
 function M:init(opts)
   require("lazy.view.colors").setup()
+  self.id = next_id()
   self.opts = vim.tbl_deep_extend("force", {
     size = Config.options.ui.size,
     style = "minimal",
     border = Config.options.ui.border or "none",
+    backdrop = Config.options.ui.backdrop or 60,
     zindex = 50,
   }, opts or {})
 
@@ -61,8 +73,13 @@ function M:init(opts)
     title_pos = self.opts.title and self.opts.title_pos or nil,
   }
   self:mount()
-  self:on_key(ViewConfig.keys.close, self.close)
-  self:on({ "BufDelete", "BufHidden" }, self.close, { once = true })
+  self:on("VimEnter", function()
+    vim.schedule(function()
+      if not self:win_valid() then
+        self:close()
+      end
+    end)
+  end, { buffer = false })
   return self
 end
 
@@ -104,6 +121,8 @@ function M:mount()
     self.buf = self.buf
   elseif self.opts.file then
     self.buf = vim.fn.bufadd(self.opts.file)
+    vim.bo[self.buf].readonly = true
+    vim.bo[self.buf].swapfile = false
     vim.fn.bufload(self.buf)
     vim.bo[self.buf].modifiable = false
   elseif self.opts.buf then
@@ -112,9 +131,43 @@ function M:mount()
     self.buf = vim.api.nvim_create_buf(false, true)
   end
 
+  local normal, has_bg
+  if vim.fn.has("nvim-0.9.0") == 0 then
+    normal = vim.api.nvim_get_hl_by_name("Normal", true)
+    has_bg = normal and normal.background ~= nil
+  else
+    normal = vim.api.nvim_get_hl(0, { name = "Normal" })
+    has_bg = normal and normal.bg ~= nil
+  end
+
+  if has_bg and self.opts.backdrop and self.opts.backdrop < 100 and vim.o.termguicolors then
+    self.backdrop_buf = vim.api.nvim_create_buf(false, true)
+    self.backdrop_win = vim.api.nvim_open_win(self.backdrop_buf, false, {
+      relative = "editor",
+      width = vim.o.columns,
+      height = vim.o.lines,
+      row = 0,
+      col = 0,
+      style = "minimal",
+      focusable = false,
+      zindex = self.opts.zindex - 1,
+    })
+    vim.api.nvim_set_hl(0, "LazyBackdrop", { bg = "#000000", default = true })
+    Util.wo(self.backdrop_win, "winhighlight", "Normal:LazyBackdrop")
+    Util.wo(self.backdrop_win, "winblend", self.opts.backdrop)
+    vim.bo[self.backdrop_buf].buftype = "nofile"
+    vim.bo[self.backdrop_buf].filetype = "lazy_backdrop"
+  end
+
   self:layout()
   self.win = vim.api.nvim_open_win(self.buf, true, self.win_opts)
+  self:on("WinClosed", function()
+    self:close()
+    self:augroup(true)
+  end, { win = true })
   self:focus()
+  self:on_key(ViewConfig.keys.close, self.close, "Close")
+  self:on({ "BufDelete", "BufHidden" }, self.close)
 
   if vim.bo[self.buf].buftype == "" then
     vim.bo[self.buf].buftype = "nofile"
@@ -147,40 +200,60 @@ function M:mount()
       end
       config.style = self.opts.style ~= "" and self.opts.style or nil
       vim.api.nvim_win_set_config(self.win, config)
+
+      if self.backdrop_win and vim.api.nvim_win_is_valid(self.backdrop_win) then
+        vim.api.nvim_win_set_config(self.backdrop_win, {
+          width = vim.o.columns,
+          height = vim.o.lines,
+        })
+      end
+
       opts()
       vim.api.nvim_exec_autocmds("User", { pattern = "LazyFloatResized", modeline = false })
     end,
   })
 end
 
+---@param clear? boolean
+function M:augroup(clear)
+  return vim.api.nvim_create_augroup("trouble.window." .. self.id, { clear = clear == true })
+end
+
 ---@param events string|string[]
----@param fn fun(self?):boolean?
----@param opts? table
+---@param fn fun(self:LazyFloat, event:{buf:number}):boolean?
+---@param opts? vim.api.keyset.create_autocmd | {buffer: false, win?:boolean}
 function M:on(events, fn, opts)
-  if type(events) == "string" then
-    events = { events }
+  opts = opts or {}
+  if opts.win then
+    opts.pattern = self.win .. ""
+    opts.win = nil
+  elseif opts.buffer == nil then
+    opts.buffer = self.buf
+  elseif opts.buffer == false then
+    opts.buffer = nil
   end
-  for _, e in ipairs(events) do
-    local event, pattern = e:match("(%w+) (%w+)")
-    event = event or e
-    vim.api.nvim_create_autocmd(
-      event,
-      vim.tbl_extend("force", {
-        pattern = pattern,
-        buffer = (not pattern) and self.buf or nil,
-        callback = function()
-          return fn(self)
-        end,
-      }, opts or {})
-    )
+  if opts.pattern then
+    opts.buffer = nil
   end
+  local _self = Util.weak(self)
+  opts.callback = function(e)
+    local this = _self()
+    if not this then
+      -- delete the autocmd
+      return true
+    end
+    return fn(this, e)
+  end
+  opts.group = self:augroup()
+  vim.api.nvim_create_autocmd(events, opts)
 end
 
 ---@param key string
 ---@param fn fun(self?)
 ---@param desc? string
-function M:on_key(key, fn, desc)
-  vim.keymap.set("n", key, function()
+---@param mode? string[]
+function M:on_key(key, fn, desc, mode)
+  vim.keymap.set(mode or "n", key, function()
     fn(self)
   end, {
     nowait = true,
@@ -191,6 +264,7 @@ end
 
 ---@param opts? {wipe:boolean}
 function M:close(opts)
+  self:augroup(true)
   local buf = self.buf
   local win = self.win
   local wipe = opts and opts.wipe
@@ -202,7 +276,18 @@ function M:close(opts)
   if wipe then
     self.buf = nil
   end
+  local backdrop_buf = self.backdrop_buf
+  local backdrop_win = self.backdrop_win
+  self.backdrop_buf = nil
+  self.backdrop_win = nil
+
   vim.schedule(function()
+    if backdrop_win and vim.api.nvim_win_is_valid(backdrop_win) then
+      vim.api.nvim_win_close(backdrop_win, true)
+    end
+    if backdrop_buf and vim.api.nvim_buf_is_valid(backdrop_buf) then
+      vim.api.nvim_buf_delete(backdrop_buf, { force = true })
+    end
     if win and vim.api.nvim_win_is_valid(win) then
       vim.api.nvim_win_close(win, true)
     end
@@ -210,6 +295,7 @@ function M:close(opts)
       vim.diagnostic.reset(Config.ns, buf)
       vim.api.nvim_buf_delete(buf, { force = true })
     end
+    vim.cmd.redraw()
   end)
 end
 

lua/lazy/view/init.lua

@@ -1,10 +1,10 @@
-local Util = require("lazy.util")
-local Render = require("lazy.view.render")
 local Config = require("lazy.core.config")
-local ViewConfig = require("lazy.view.config")
-local Git = require("lazy.manage.git")
 local Diff = require("lazy.view.diff")
 local Float = require("lazy.view.float")
+local Git = require("lazy.manage.git")
+local Render = require("lazy.view.render")
+local Util = require("lazy.util")
+local ViewConfig = require("lazy.view.config")
 
 ---@class LazyViewState
 ---@field mode string
@@ -53,7 +53,7 @@ function M.create()
   Float.init(self, {
     title = Config.options.ui.title,
     title_pos = Config.options.ui.title_pos,
-    noautocmd = true,
+    noautocmd = false,
   })
 
   if Config.options.ui.wrap then
@@ -67,19 +67,27 @@ function M.create()
   self.state = vim.deepcopy(default_state)
 
   self.render = Render.new(self)
-  self.update = Util.throttle(Config.options.ui.throttle, self.update)
-
-  self:on({ "User LazyRender", "User LazyFloatResized" }, function()
-    if not (self.buf and vim.api.nvim_buf_is_valid(self.buf)) then
-      return true
-    end
-    self:update()
+  local update = self.update
+  self.update = Util.throttle(Config.options.ui.throttle, function()
+    update(self)
   end)
 
+  for _, pattern in ipairs({ "LazyRender", "LazyFloatResized" }) do
+    self:on({ "User" }, function()
+      if not (self.buf and vim.api.nvim_buf_is_valid(self.buf)) then
+        return true
+      end
+      self:update()
+    end, { pattern = pattern })
+  end
+
   vim.keymap.set("n", ViewConfig.keys.abort, function()
     require("lazy.manage.process").abort()
+    require("lazy.async").abort()
     return ViewConfig.keys.abort
-  end, { silent = true, buffer = self.buf, expr = true })
+  end, { silent = true, buffer = self.buf, expr = true, desc = "Abort" })
+
+  vim.keymap.set("n", "gx", "K", { buffer = self.buf, remap = true })
 
   -- plugin details
   self:on_key(ViewConfig.keys.details, function()
@@ -89,17 +97,49 @@ function M.create()
         name = plugin.name,
         kind = plugin._.kind,
       }
-      self.state.plugin = not vim.deep_equal(self.state.plugin, selected) and selected or nil
+
+      local open = not vim.deep_equal(self.state.plugin, selected)
+
+      if not open then
+        local row = self.render:get_row(selected)
+        if row then
+          vim.api.nvim_win_set_cursor(self.view.win, { row, 8 })
+        end
+      end
+
+      self.state.plugin = open and selected or nil
       self:update()
     end
-  end)
+  end, "Details")
+
+  self:on_key(ViewConfig.keys.next, function()
+    local cursor = vim.api.nvim_win_get_cursor(self.view.win)
+    for l = 1, #self.render.locations, 1 do
+      local loc = self.render.locations[l]
+      if loc.from > cursor[1] then
+        vim.api.nvim_win_set_cursor(self.view.win, { loc.from, 8 })
+        return
+      end
+    end
+  end, "Next Plugin")
+
+  self:on_key(ViewConfig.keys.prev, function()
+    local cursor = vim.api.nvim_win_get_cursor(self.view.win)
+    for l = #self.render.locations, 1, -1 do
+      local loc = self.render.locations[l]
+      if loc.from < cursor[1] then
+        vim.api.nvim_win_set_cursor(self.view.win, { loc.from, 8 })
+        return
+      end
+    end
+  end, "Prev Plugin")
 
   self:on_key(ViewConfig.keys.profile_sort, function()
     if self.state.mode == "profile" then
       self.state.profile.sort_time_taken = not self.state.profile.sort_time_taken
       self:update()
     end
-  end)
+  end, "Sort Profile")
 
   self:on_key(ViewConfig.keys.profile_filter, function()
     if self.state.mode == "profile" then
@@ -119,16 +159,18 @@ function M.create()
         end
       end)
     end
-  end)
+  end, "Filter Profile")
 
-  for key, handler in pairs(Config.options.ui.custom_keys) do
-    if handler then
-      self:on_key(key, function()
+  for lhs, rhs in pairs(Config.options.ui.custom_keys) do
+    if rhs then
+      local handler = type(rhs) == "table" and rhs[1] or rhs
+      local desc = type(rhs) == "table" and rhs.desc or nil
+      self:on_key(lhs, function()
         local plugin = self.render:get_plugin()
         if plugin then
           handler(plugin)
         end
-      end)
+      end, desc)
     end
   end
 
@@ -139,9 +181,7 @@ end
 
 function M:update()
   if self.buf and vim.api.nvim_buf_is_valid(self.buf) then
-    vim.bo[self.buf].modifiable = true
     self.render:update()
-    vim.bo[self.buf].modifiable = false
     vim.cmd.redraw()
   end
 end
@@ -180,17 +220,17 @@ function M:setup_patterns()
     ["(https?://%S+)"] = function(url)
       Util.open(url)
     end,
-  }, self.hover)
+  }, self.hover, "Hover")
   self:on_pattern(ViewConfig.keys.diff, {
     [commit_pattern] = function(hash)
       self:diff({ commit = hash })
     end,
-  }, self.diff)
+  }, self.diff, "Diff")
   self:on_pattern(ViewConfig.commands.restore.key_plugin, {
     [commit_pattern] = function(hash)
       self:restore({ commit = hash })
     end,
-  }, self.restore)
+  }, self.restore, "Restore")
 end
 
 ---@param opts? {commit:string}
@@ -208,13 +248,13 @@ function M:restore(opts)
 end
 
 function M:hover()
-  if self:diff({ browser = true }) then
+  if self:diff({ browser = true, hover = true }) then
     return
   end
   self:open_url("")
 end
 
----@param opts? {commit?:string, browser:boolean}
+---@param opts? {commit?:string, browser:boolean, hover:boolean}
 function M:diff(opts)
   opts = opts or {}
   local plugin = self.render:get_plugin()
@@ -228,6 +268,9 @@ function M:diff(opts)
       local info = assert(Git.info(plugin.dir))
       local target = assert(Git.get_target(plugin))
       diff = { from = info.commit, to = target.commit }
+      if opts.hover and diff.from == diff.to then
+        return
+      end
     end
 
     if not diff then
@@ -252,7 +295,8 @@ end
 ---@param key string
 ---@param patterns table<string, fun(str:string)>
 ---@param fallback? fun(self)
-function M:on_pattern(key, patterns, fallback)
+---@param desc? string
+function M:on_pattern(key, patterns, fallback, desc)
   self:on_key(key, function()
     local line = vim.api.nvim_get_current_line()
     local pos = vim.api.nvim_win_get_cursor(0)
@@ -274,7 +318,7 @@ function M:on_pattern(key, patterns, fallback)
     if fallback then
       fallback(self)
     end
-  end)
+  end, desc)
 end
 
 function M:setup_modes()
@@ -291,11 +335,28 @@ function M:setup_modes()
     end
     if m.key_plugin and name ~= "restore" then
       self:on_key(m.key_plugin, function()
-        local plugin = self.render:get_plugin()
-        if plugin then
-          Commands.cmd(name, { plugins = { plugin } })
+        local esc = vim.api.nvim_replace_termcodes("<esc>", true, true, true)
+        vim.api.nvim_feedkeys(esc, "n", false)
+        local plugins = {}
+        if vim.api.nvim_get_mode().mode:lower() == "v" then
+          local f, t = vim.fn.line("."), vim.fn.line("v")
+          if f > t then
+            f, t = t, f
+          end
+          for i = f, t do
+            local plugin = self.render:get_plugin(i)
+            if plugin then
+              plugins[plugin.name] = plugin
+            end
+          end
+          plugins = vim.tbl_values(plugins)
+        else
+          plugins[1] = self.render:get_plugin()
         end
-      end, m.desc_plugin)
+        if #plugins > 0 then
+          Commands.cmd(name, { plugins = plugins })
+        end
+      end, m.desc_plugin, { "n", "x" })
     end
   end
 end

lua/lazy/view/render.lua

@@ -1,9 +1,10 @@
 local Config = require("lazy.core.config")
-local Util = require("lazy.util")
-local Sections = require("lazy.view.sections")
-local Handler = require("lazy.core.handler")
 local Git = require("lazy.manage.git")
+local Handler = require("lazy.core.handler")
+local Keys = require("lazy.core.handler.keys")
 local Plugin = require("lazy.core.plugin")
+local Sections = require("lazy.view.sections")
+local Util = require("lazy.util")
 local ViewConfig = require("lazy.view.config")
 
 local Text = require("lazy.view.text")
@@ -50,7 +51,7 @@ function M:update()
     if plugin._.tasks then
       for _, task in ipairs(plugin._.tasks) do
         self.progress.total = self.progress.total + 1
-        if not task:is_running() then
+        if not task:running() then
           self.progress.done = self.progress.done + 1
         end
       end
@@ -73,7 +74,17 @@ function M:update()
   end
 
   self:trim()
+
+  vim.bo[self.view.buf].modifiable = true
+  local view = vim.api.nvim_win_call(self.view.win, vim.fn.winsaveview)
+
   self:render(self.view.buf)
+
+  vim.api.nvim_win_call(self.view.win, function()
+    vim.fn.winrestview(view)
+  end)
+  vim.bo[self.view.buf].modifiable = false
+
   vim.diagnostic.set(
     Config.ns,
     self.view.buf,
@@ -83,7 +94,7 @@ function M:update()
       diag.lnum = diag.row - 1
       return diag
     end, self._diagnostics),
-    { signs = false, virtual_text = true }
+    { signs = false, virtual_text = true, underline = false, virtual_lines = false }
   )
 end
 
@@ -111,6 +122,15 @@ function M:get_plugin(row)
   end
 end
 
+---@param selected {name:string, kind?: LazyPluginKind}
+function M:get_row(selected)
+  for _, loc in ipairs(self.locations) do
+    if loc.kind == selected.kind and loc.name == selected.name then
+      return loc.from
+    end
+  end
+end
+
 function M:title()
   self:nl()
   local modes = vim.tbl_filter(function(c)
@@ -123,9 +143,7 @@ function M:title()
       local title = " " .. mode.name:sub(1, 1):upper() .. mode.name:sub(2) .. " (" .. mode.key .. ") "
       if mode.name == "home" then
         if self.view.state.mode == "home" then
-          title = " lazy.nvim  " .. Config.options.ui.icons.lazy
-        else
-          title = " lazy.nvim (H) "
+          title = " lazy.nvim " .. Config.options.ui.icons.lazy
         end
       end
 
@@ -181,7 +199,15 @@ function M:help()
     :nl()
   self:append("or the plugin was just updated. Otherwise the plugin webpage will open."):nl():nl()
 
-  self:append("Use "):append("<d>", "LazySpecial"):append(" on a commit or plugin to open the diff view"):nl()
+  self:append("Use "):append("<d>", "LazySpecial"):append(" on a commit or plugin to open the diff view"):nl():nl()
+  self
+    :append("Use ")
+    :append("<]]>", "LazySpecial")
+    :append(" and ")
+    :append("<[[>", "LazySpecial")
+    :append(" to navigate between plugins")
+    :nl()
+    :nl()
   self:nl()
 
   self:append("Keyboard Shortcuts", "LazyH2"):nl()
@@ -209,6 +235,14 @@ function M:help()
       self:append(" " .. (mode.desc_plugin or mode.desc)):nl()
     end
   end
+  for lhs, rhs in pairs(Config.options.ui.custom_keys) do
+    if type(rhs) == "table" and rhs.desc then
+      self:append("- ", "LazySpecial", { indent = 2 })
+      self:append("Custom key ", "Title")
+      self:append(lhs, "LazyProp")
+      self:append(" " .. rhs.desc):nl()
+    end
+  end
 end
 
 function M:progressbar()
@@ -319,23 +353,17 @@ function M:reason(reason, opts)
   end
   for _, key in ipairs(keys) do
     local value = reason[key]
-    if type(key) == "number" then
-    elseif key == "require" then
-    elseif key ~= "time" then
+    local skip = type(key) == "number" or key == "time"
+    if not skip then
       if first then
         first = false
       else
         self:append(" ")
       end
-      if key == "event" then
-        value = value:match("User (.*)") or value
-      end
-      if key == "keys" then
-        value = type(value) == "string" and value or value.lhs or value[1]
-      end
       local hl = "LazyReason" .. key:sub(1, 1):upper() .. key:sub(2)
       local icon = Config.options.ui.icons[key]
       if icon then
+        icon = icon:gsub("%s*$", "")
         self:append(icon .. " ", hl)
         self:append(value, hl)
       else
@@ -351,7 +379,37 @@ end
 
 ---@param plugin LazyPlugin
 function M:diagnostics(plugin)
-  if plugin._.updated then
+  local skip = false
+  for _, task in ipairs(plugin._.tasks or {}) do
+    if task:running() then
+      self:diagnostic({
+        severity = vim.diagnostic.severity.WARN,
+        message = task.name .. (task:status() and (": " .. task:status()) or ""),
+      })
+      skip = true
+    elseif task:has_errors() then
+      self:diagnostic({
+        message = task.name .. " failed",
+        severity = vim.diagnostic.severity.ERROR,
+      })
+      skip = true
+    elseif task:has_warnings() then
+      self:diagnostic({
+        message = task.name .. " warning",
+        severity = vim.diagnostic.severity.WARN,
+      })
+      skip = true
+    end
+  end
+  if skip then
+    return
+  end
+  if plugin._.build then
+    self:diagnostic({
+      message = "needs build",
+      severity = vim.diagnostic.severity.WARN,
+    })
+  elseif plugin._.updated then
     if plugin._.updated.from == plugin._.updated.to then
       self:diagnostic({
         message = "already up to date",
@@ -380,19 +438,6 @@ function M:diagnostics(plugin)
       })
     end
   end
-  for _, task in ipairs(plugin._.tasks or {}) do
-    if task:is_running() then
-      self:diagnostic({
-        severity = vim.diagnostic.severity.WARN,
-        message = task.name .. (task.status == "" and "" or (": " .. task.status)),
-      })
-    elseif task.error then
-      self:diagnostic({
-        message = task.name .. " failed",
-        severity = vim.diagnostic.severity.ERROR,
-      })
-    end
-  end
 end
 
 ---@param plugin LazyPlugin
@@ -407,27 +452,18 @@ function M:plugin(plugin)
   end
   local plugin_start = self:row()
   if plugin._.loaded then
+    -- When the plugin is loaded, only show the loading reason
     self:reason(plugin._.loaded)
   else
+    -- otherwise show all lazy handlers
     self:append(" ")
-    local reason = {}
-    if plugin._.kind ~= "disabled" then
-      for handler in pairs(Handler.types) do
-        if plugin[handler] then
-          local trigger = {}
-          for _, value in ipairs(plugin[handler]) do
-            table.insert(trigger, type(value) == "table" and value[1] or value)
-          end
-          reason[handler] = table.concat(trigger, " ")
-        end
-      end
-    end
+    self:handlers(plugin)
     for _, other in pairs(Config.plugins) do
       if vim.tbl_contains(other.dependencies or {}, plugin.name) then
-        reason.plugin = other.name
+        self:reason({ plugin = other.name })
+        self:append(" ")
       end
     end
-    self:reason(reason)
   end
   self:diagnostics(plugin)
   self:nl()
@@ -440,6 +476,22 @@ function M:plugin(plugin)
     { name = plugin.name, from = plugin_start, to = self:row() - 1, kind = plugin._.kind }
 end
 
+---@param str string
+---@param hl? string|Extmark
+---@param opts? {indent?: number, prefix?: string, wrap?: boolean}
+function M:markdown(str, hl, opts)
+  local lines = vim.split(str, "\n")
+  for _, line in ipairs(lines) do
+    self:append(line, hl, opts):highlight({
+      ["`.-`"] = "@markup.raw.markdown_inline",
+      ["%*.-%*"] = "LazyItalic",
+      ["%*%*.-%*%*"] = "LazyBold",
+      ["^%s*-"] = "Special",
+    })
+    self:nl()
+  end
+end
+
 ---@param plugin LazyPlugin
 function M:tasks(plugin)
   for _, task in ipairs(plugin._.tasks or {}) do
@@ -448,46 +500,56 @@ function M:tasks(plugin)
       self:append(" " .. math.floor((task:time()) * 100) / 100 .. "ms", "Bold")
       self:nl()
     end
-    if task.error then
-      self:append(vim.trim(task.error), "LazyTaskError", { indent = 6 })
-      self:nl()
-    elseif task.name == "log" then
+
+    if not task:has_warnings() and task.name == "log" then
       self:log(task)
-    elseif self.view:is_selected(plugin) and task.output ~= "" and task.output ~= task.error then
-      self:append(vim.trim(task.output), "LazyTaskOutput", { indent = 6 })
-      self:nl()
+    else
+      local hls = {
+        [vim.log.levels.ERROR] = "LazyError",
+        [vim.log.levels.WARN] = "LazyWarning",
+        [vim.log.levels.INFO] = "LazyInfo",
+      }
+      for _, msg in ipairs(task:get_log()) do
+        if task:has_warnings() or self.view:is_selected(plugin) then
+          self:markdown(msg.msg, hls[msg.level] or "LazyTaskOutput", { indent = 6 })
+        end
+      end
     end
   end
 end
 
 ---@param task LazyTask
 function M:log(task)
-  local log = vim.trim(task.output)
+  local log = vim.trim(task:output())
   if log ~= "" then
     local lines = vim.split(log, "\n")
     for _, line in ipairs(lines) do
       local ref, msg, time = line:match("^(%w+) (.*) (%(.*%))$")
-      if msg:find("^%S+!:") then
-        self:diagnostic({ message = "Breaking Changes", severity = vim.diagnostic.severity.WARN })
-      end
-      self:append(ref:sub(1, 7) .. " ", "LazyCommit", { indent = 6 })
-
-      local dimmed = false
-      for _, dim in ipairs(ViewConfig.dimmed_commits) do
-        if msg:find("^" .. dim) then
-          dimmed = true
+      if msg then
+        if msg:find("^%S+!:") then
+          self:diagnostic({ message = "Breaking Changes", severity = vim.diagnostic.severity.WARN })
         end
+        self:append(ref:sub(1, 7) .. " ", "LazyCommit", { indent = 6 })
+
+        local dimmed = false
+        for _, dim in ipairs(ViewConfig.dimmed_commits) do
+          if msg:find("^" .. dim) then
+            dimmed = true
+          end
+        end
+        self:append(vim.trim(msg), dimmed and "LazyDimmed" or nil):highlight({
+          ["#%d+"] = "LazyCommitIssue",
+          ["^%S+:"] = dimmed and "Bold" or "LazyCommitType",
+          ["^%S+(%(.*%))!?:"] = "LazyCommitScope",
+          ["`.-`"] = "@markup.raw.markdown_inline",
+          ["%*.-%*"] = "Italic",
+          ["%*%*.-%*%*"] = "Bold",
+        })
+        self:append(" " .. time, "LazyComment")
+        self:nl()
+        -- else
+        --   self:append(line, "LazyTaskOutput", { indent = 6 }):nl()
       end
-      self:append(vim.trim(msg), dimmed and "LazyDimmed" or nil):highlight({
-        ["#%d+"] = "LazyCommitIssue",
-        ["^%S+:"] = dimmed and "Bold" or "LazyCommitType",
-        ["^%S+(%(.*%)):"] = "LazyCommitScope",
-        ["`.-`"] = "@text.literal.markdown_inline",
-        ["%*.-%*"] = "Italic",
-        ["%*%*.-%*%*"] = "Bold",
-      })
-      self:append(" " .. time, "LazyComment")
-      self:nl()
     end
     self:nl()
   end
@@ -517,6 +579,11 @@ function M:details(plugin)
       table.insert(props, { "commit", git.commit:sub(1, 7), "LazyCommit" })
     end
   end
+  local rocks = require("lazy.pkg.rockspec").deps(plugin)
+  if rocks then
+    table.insert(props, { "rocks", vim.inspect(rocks) })
+  end
+
   if Util.file_exists(plugin.dir .. "/README.md") then
     table.insert(props, { "readme", "README.md" })
   end
@@ -530,24 +597,36 @@ function M:details(plugin)
     end
   end)
 
-  for handler in pairs(Handler.types) do
-    if plugin[handler] then
-      table.insert(props, {
-        handler,
-        function()
-          for _, value in ipairs(plugin[handler]) do
-            self:reason({ [handler] = value })
-            self:append(" ")
-          end
-        end,
-      })
-    end
+  for handler in pairs(plugin._.handlers or {}) do
+    table.insert(props, {
+      handler,
+      function()
+        self:handlers(plugin, handler)
+      end,
+    })
   end
   self:props(props, { indent = 6 })
 
   self:nl()
 end
 
+---@param plugin LazyPlugin
+---@param types? LazyHandlerTypes[]|LazyHandlerTypes
+function M:handlers(plugin, types)
+  if not plugin._.handlers then
+    return
+  end
+  types = type(types) == "string" and { types } or types
+  types = types and types or vim.tbl_keys(Handler.types)
+  for _, t in ipairs(types) do
+    for id, value in pairs(plugin._.handlers[t] or {}) do
+      value = t == "keys" and Keys.to_string(value) or id
+      self:reason({ [t] = value })
+      self:append(" ")
+    end
+  end
+end
+
 ---@alias LazyProps {[1]:string, [2]:string|fun(), [3]?:string}[]
 ---@param props LazyProps
 ---@param opts? {indent: number}
@@ -576,7 +655,7 @@ function M:profile()
     self:append("Based on the actual CPU time of the Neovim process till "):append("UIEnter", "LazySpecial")
     self:append("."):nl()
     self:append("This is more accurate than ")
-    self:append("`nvim --startuptime`", "@text.literal.markdown_inline")
+    self:append("`nvim --startuptime`", "@markup.raw.markdown_inline")
     self:append(".")
   else
     self:append("An accurate startuptime based on the actual CPU time of the Neovim process is not available."):nl()
@@ -676,16 +755,15 @@ function M:debug()
 
   Util.foreach(require("lazy.core.handler").handlers, function(handler_type, handler)
     Util.foreach(handler.active, function(value, plugins)
-      value = type(value) == "table" and value[1] or value
       if not vim.tbl_isempty(plugins) then
         ---@type string[]
         plugins = vim.tbl_values(plugins)
         table.sort(plugins)
-        self:append("● ", "LazySpecial", { indent = 2 })
+        self:append(Config.options.ui.icons.debug, "LazySpecial", { indent = 2 })
         if handler_type == "keys" then
-          for k, v in pairs(Handler.handlers.keys:values(Config.plugins[plugins[1]])) do
+          for k, v in pairs(Config.plugins[plugins[1]]._.handlers.keys) do
             if k == value then
-              value = v
+              value = Keys.to_string(v)
               break
             end
           end

lua/lazy/view/sections.lua

@@ -17,27 +17,35 @@ return {
   {
     filter = function(plugin)
       return has_task(plugin, function(task)
-        return task.error ~= nil
+        return task:has_errors()
       end)
     end,
     title = "Failed",
   },
   {
     filter = function(plugin)
+      if plugin._.working then
+        return true
+      end
       return has_task(plugin, function(task)
-        return task:is_running()
+        return task:running()
       end)
     end,
     title = "Working",
   },
+  {
+    filter = function(plugin)
+      return plugin._.build
+    end,
+    title = "Build",
+  },
   {
     filter = function(plugin)
       return has_task(plugin, function(task)
         if task.name ~= "log" then
           return
         end
-        local lines = vim.split(task.output, "\n")
-        for _, line in ipairs(lines) do
+        for _, line in ipairs(vim.split(task:output(), "\n")) do
           if line:find("^%w+ %S+!:") then
             return true
           end
@@ -47,14 +55,12 @@ return {
     title = "Breaking Changes",
   },
   {
-    ---@param plugin LazyPlugin
     filter = function(plugin)
       return plugin._.updated and plugin._.updated.from ~= plugin._.updated.to
     end,
     title = "Updated",
   },
   {
-    ---@param plugin LazyPlugin
     filter = function(plugin)
       return plugin._.cloned
     end,
@@ -63,14 +69,14 @@ return {
   {
     ---@param plugin LazyPlugin
     filter = function(plugin)
-      return plugin._.updates
+      return plugin._.updates ~= nil
     end,
     title = "Updates",
   },
   {
     filter = function(plugin)
       return has_task(plugin, function(task)
-        return task.name == "log" and vim.trim(task.output) ~= ""
+        return task.name == "log" and vim.trim(task:output()) ~= ""
       end)
     end,
     title = "Log",
@@ -89,7 +95,13 @@ return {
   },
   {
     filter = function(plugin)
-      return plugin._.loaded
+      return plugin._.outdated
+    end,
+    title = "Outdated",
+  },
+  {
+    filter = function(plugin)
+      return plugin._.loaded ~= nil
     end,
     title = "Loaded",
   },

lua/lazy/view/text.lua

@@ -11,9 +11,7 @@ local Util = require("lazy.util")
 local Text = {}
 
 function Text.new()
-  local self = setmetatable({}, {
-    __index = Text,
-  })
+  local self = setmetatable({}, { __index = Text })
   self._lines = {}
 
   return self

scripts/test

@@ -0,0 +1,3 @@
+#!/bin/env bash
+
+nvim -l tests/minit.lua --minitest

selene.toml

@@ -1 +1,4 @@
 std="vim"
+
+[lints]
+mixed_table="allow"

stylua.toml

@@ -1,3 +1,6 @@
 indent_type = "Spaces"
 indent_width = 2
-column_width = 120
+column_width = 120
+[sort_requires]
+enabled = true
+

tests/core/e2e_spec.lua

@@ -1,39 +0,0 @@
-local Git = require("lazy.manage.git")
-
-describe("lazy", function()
-  before_each(function()
-    vim.g.lazy_did_setup = false
-    vim.go.loadplugins = true
-    for modname in pairs(package.loaded) do
-      if modname:find("lazy") == 1 then
-        package.loaded[modname] = nil
-      end
-    end
-  end)
-
-  local root = ".tests/data/nvim/lazy"
-
-  it("installs plugins", function()
-    local Lazy = require("lazy")
-    local Config = require("lazy.core.config")
-
-    local neodev = false
-    Lazy.setup({
-      {
-        "folke/neodev.nvim",
-        config = function()
-          neodev = true
-        end,
-      },
-      "folke/paint.nvim",
-    }, { install_missing = true, defaults = { lazy = true } })
-    assert(3 == vim.tbl_count(Config.plugins))
-    assert(vim.loop.fs_stat(root .. "/paint.nvim/README.md"))
-    assert(vim.loop.fs_stat(root .. "/neodev.nvim/README.md"))
-    assert(not neodev)
-    assert(Config.plugins["neodev.nvim"]._.installed)
-    assert(not Config.plugins["neodev.nvim"]._.is_local)
-    assert.equal("https://github.com/folke/neodev.nvim.git", Git.get_origin(Config.plugins["neodev.nvim"].dir))
-    assert.equal("https://github.com/folke/paint.nvim.git", Git.get_origin(Config.plugins["paint.nvim"].dir))
-  end)
-end)

tests/core/init_spec.lua

@@ -1,7 +1,10 @@
+local Util = require("lazy.core.util")
+
 describe("init", function()
   it("has correct environment for tests", function()
-    for _, path in ipairs({ "config", "data", "cache", "state" }) do
-      assert(vim.fn.stdpath(path):find(".tests/" .. path))
+    for _, name in ipairs({ "config", "data", "cache", "state" }) do
+      local path = Util.norm(vim.fn.stdpath(name) --[[@as string]])
+      assert(path:find(".tests/" .. name, 1, true), path .. " not in .tests")
     end
   end)
 end)

tests/core/plugin_spec.lua

@@ -1,23 +1,33 @@
 local Config = require("lazy.core.config")
+local Handler = require("lazy.core.handler")
 local Plugin = require("lazy.core.plugin")
 
-local assert = require("luassert")
+local function inspect(obj)
+  return vim.inspect(obj):gsub("%s+", " ")
+end
 
-Config.setup()
+---@param plugin LazyPlugin
+local function resolve(plugin)
+  local meta = getmetatable(plugin)
+  local ret = meta and type(meta.__index) == "table" and resolve(meta.__index) or {}
+  for k, v in pairs(plugin) do
+    ret[k] = v
+  end
+  return ret
+end
 
----@param plugins LazyPlugin[]|LazyPlugin
+---@param plugins LazyPlugin[]
 local function clean(plugins)
-  local p = plugins
-  plugins = type(plugins) == "table" and plugins or { plugins }
-  for _, plugin in pairs(plugins) do
-    plugin._.fid = nil
-    plugin._.fpid = nil
-    plugin._.fdeps = nil
+  return vim.tbl_map(function(plugin)
+    plugin = resolve(plugin)
+    plugin[1] = nil
+    plugin._.frags = nil
     if plugin._.dep == false then
       plugin._.dep = nil
     end
-  end
-  return p
+    plugin._.top = nil
+    return plugin
+  end, plugins)
 end
 
 describe("plugin spec url/name", function()
@@ -27,8 +37,16 @@ describe("plugin spec url/name", function()
     { { "foo/bar" }, { [1] = "foo/bar", name = "bar", url = "https://github.com/foo/bar.git" } },
     { { "https://foo.bar" }, { [1] = "https://foo.bar", name = "foo.bar", url = "https://foo.bar" } },
     { { "foo/bar", name = "foobar" }, { [1] = "foo/bar", name = "foobar", url = "https://github.com/foo/bar.git" } },
-    { { "foo/bar", url = "123" }, { [1] = "foo/bar", name = "123", url = "123" } },
+    { { "foo/bar", url = "123" }, { [1] = "foo/bar", name = "bar", url = "123" } },
     { { url = "https://foobar" }, { name = "foobar", url = "https://foobar" } },
+    {
+      { { url = "https://foo", name = "foobar" }, { url = "https://foo" } },
+      { name = "foobar", url = "https://foo" },
+    },
+    {
+      { { url = "https://foo" }, { url = "https://foo", name = "foobar" } },
+      { name = "foobar", url = "https://foo" },
+    },
     { { url = "ssh://foobar" }, { name = "foobar", url = "ssh://foobar" } },
     { "foo/bar", { [1] = "foo/bar", name = "bar", url = "https://github.com/foo/bar.git" } },
     { { { { "foo/bar" } } }, { [1] = "foo/bar", name = "bar", url = "https://github.com/foo/bar.git" } },
@@ -36,20 +54,98 @@ describe("plugin spec url/name", function()
 
   for _, test in ipairs(tests) do
     test[2]._ = {}
-    it("parses " .. vim.inspect(test[1]):gsub("%s+", " "), function()
+    it("parses " .. inspect(test[1]), function()
       if not test[2].dir then
         test[2].dir = Config.options.root .. "/" .. test[2].name
       end
       local spec = Plugin.Spec.new(test[1])
-      local plugins = vim.tbl_values(spec.plugins)
-      plugins[1]._ = {}
-      assert(#spec.notifs == 0)
-      assert.equal(1, #plugins)
+      local all = vim.deepcopy(spec.plugins)
+      local plugins = vim.tbl_values(all)
+      plugins = vim.tbl_map(function(plugin)
+        plugin._ = {}
+        return plugin
+      end, plugins)
+      local notifs = vim.tbl_filter(function(notif)
+        return notif.level > 3
+      end, spec.notifs)
+      assert(#notifs == 0, vim.inspect(spec.notifs))
+      assert.equal(1, #plugins, vim.inspect(all))
+      plugins[1]._.super = nil
       assert.same(test[2], plugins[1])
     end)
   end
 end)
 
+describe("plugin spec dir", function()
+  local tests = {
+    {
+      "~/projects/gitsigns.nvim",
+      { "lewis6991/gitsigns.nvim", opts = {}, dev = true },
+      { "lewis6991/gitsigns.nvim" },
+    },
+    {
+      "~/projects/gitsigns.nvim",
+      { "lewis6991/gitsigns.nvim", opts = {}, dev = true },
+      { "gitsigns.nvim" },
+    },
+    {
+      "~/projects/gitsigns.nvim",
+      { "lewis6991/gitsigns.nvim", opts = {} },
+      { "lewis6991/gitsigns.nvim", dev = true },
+    },
+    {
+      "~/projects/gitsigns.nvim",
+      { "lewis6991/gitsigns.nvim", opts = {} },
+      { "gitsigns.nvim", dev = true },
+    },
+  }
+
+  for _, test in ipairs(tests) do
+    local dir = vim.fn.expand(test[1])
+    local input = vim.list_slice(test, 2)
+    it("parses dir " .. inspect(input), function()
+      local spec = Plugin.Spec.new(input)
+      local plugins = vim.tbl_values(spec.plugins)
+      assert(spec:report() == 0)
+      assert.equal(1, #plugins)
+      assert.same(dir, plugins[1].dir)
+    end)
+  end
+end)
+
+describe("plugin dev", function()
+  local tests = {
+    {
+      { "lewis6991/gitsigns.nvim", opts = {}, dev = true },
+      { "lewis6991/gitsigns.nvim" },
+    },
+    {
+      { "lewis6991/gitsigns.nvim", opts = {}, dev = true },
+      { "gitsigns.nvim" },
+    },
+    {
+      { "lewis6991/gitsigns.nvim", opts = {} },
+      { "lewis6991/gitsigns.nvim", dev = true },
+    },
+    {
+      { "lewis6991/gitsigns.nvim", opts = {} },
+      { "gitsigns.nvim", dev = true },
+    },
+  }
+
+  for _, test in ipairs(tests) do
+    local dir = vim.fn.expand("~/projects/gitsigns.nvim")
+    local input = test
+    it("parses dir " .. inspect(input), function()
+      local spec = Plugin.Spec.new(input)
+      local plugins = vim.tbl_values(spec.plugins)
+      assert(spec:report() == 0)
+      assert.equal(1, #plugins)
+      assert.same(dir, plugins[1].dir)
+    end)
+  end
+end)
+
 describe("plugin spec opt", function()
   it("handles dependencies", function()
     Config.options.defaults.lazy = false
@@ -76,16 +172,14 @@ describe("plugin spec opt", function()
       for _, plugin in pairs(spec.plugins) do
         plugin.dir = nil
       end
-      assert.same(clean(spec.plugins), {
+      assert.same({
         bar = {
-          "foo/bar",
           _ = {},
           dependencies = { "dep1", "dep2" },
           name = "bar",
           url = "https://github.com/foo/bar.git",
         },
         dep1 = {
-          "foo/dep1",
           _ = {
             dep = true,
           },
@@ -93,25 +187,27 @@ describe("plugin spec opt", function()
           url = "https://github.com/foo/dep1.git",
         },
         dep2 = {
-          "foo/dep2",
           _ = {
             dep = true,
           },
           name = "dep2",
           url = "https://github.com/foo/dep2.git",
         },
-      })
+      }, clean(spec.plugins))
     end
   end)
 
   describe("deps", function()
-    it("handles dep names", function()
-      Config.options.defaults.lazy = false
-      local tests = {
-        { { "foo/bar", dependencies = { { "dep1" }, "foo/dep2" } }, "foo/dep1" },
-        { "foo/dep1", { "foo/bar", dependencies = { { "dep1" }, "foo/dep2" } } },
-      }
-      for _, test in ipairs(tests) do
+    before_each(function()
+      Handler.init()
+    end)
+    Config.options.defaults.lazy = false
+    local tests = {
+      { { "foo/bar", dependencies = { { "dep1" }, "foo/dep2" } }, "foo/dep1" },
+      { "foo/dep1", { "foo/bar", dependencies = { { "dep1" }, "foo/dep2" } } },
+    }
+    for _, test in ipairs(tests) do
+      it("handles dep names " .. inspect(test), function()
         local spec = Plugin.Spec.new(vim.deepcopy(test))
         assert(#spec.notifs == 0)
         Config.plugins = spec.plugins
@@ -120,31 +216,74 @@ describe("plugin spec opt", function()
         for _, plugin in pairs(spec.plugins) do
           plugin.dir = nil
         end
-        assert.same(clean(spec.plugins), {
+        assert.same({
           bar = {
-            "foo/bar",
             _ = {},
             dependencies = { "dep1", "dep2" },
             name = "bar",
             url = "https://github.com/foo/bar.git",
           },
           dep1 = {
-            "foo/dep1",
             _ = {},
             name = "dep1",
             url = "https://github.com/foo/dep1.git",
           },
           dep2 = {
-            "foo/dep2",
             _ = {
               dep = true,
             },
             name = "dep2",
             url = "https://github.com/foo/dep2.git",
           },
-        })
-      end
-    end)
+        }, clean(spec.plugins))
+      end)
+    end
+
+    Config.options.defaults.lazy = false
+    local tests = {
+      {
+        { "foo/baz", name = "bar" },
+        { "foo/fee", dependencies = { "foo/baz" } },
+      },
+      {
+        { "foo/fee", dependencies = { "foo/baz" } },
+        { "foo/baz", name = "bar" },
+      },
+      -- {
+      --   { "foo/baz", name = "bar" },
+      --   { "foo/fee", dependencies = { "baz" } },
+      -- },
+      {
+        { "foo/baz", name = "bar" },
+        { "foo/fee", dependencies = { "bar" } },
+      },
+    }
+    for _, test in ipairs(tests) do
+      it("handles dep names " .. inspect(test), function()
+        local spec = Plugin.Spec.new(vim.deepcopy(test))
+        assert(#spec.notifs == 0)
+        Config.plugins = spec.plugins
+        Plugin.update_state()
+        spec = Plugin.Spec.new(test)
+        spec.meta:rebuild()
+        for _, plugin in pairs(spec.plugins) do
+          plugin.dir = nil
+        end
+        assert.same({
+          bar = {
+            _ = {},
+            name = "bar",
+            url = "https://github.com/foo/baz.git",
+          },
+          fee = {
+            _ = {},
+            name = "fee",
+            url = "https://github.com/foo/fee.git",
+            dependencies = { "bar" },
+          },
+        }, clean(spec.plugins))
+      end)
+    end
 
     it("handles opt from dep", function()
       Config.options.defaults.lazy = false
@@ -200,10 +339,13 @@ describe("plugin spec opt", function()
         local spec = Plugin.Spec.new(test)
         assert(#spec.notifs == 0)
         assert(vim.tbl_count(spec.plugins) == 1)
-        assert(type(spec.plugins.bar.event) == "table")
-        assert(#spec.plugins.bar.event == 2)
-        assert(vim.tbl_contains(spec.plugins.bar.event, "mod1"))
-        assert(vim.tbl_contains(spec.plugins.bar.event, "mod2"))
+        Handler.resolve(spec.plugins.bar)
+        -- vim.print(spec.plugins.bar._.handlers)
+        local events = vim.tbl_keys(spec.plugins.bar._.handlers.event or {})
+        assert(type(events) == "table")
+        assert(#events == 2)
+        assert(vim.tbl_contains(events, "mod1"))
+        assert(vim.tbl_contains(events, "mod2"))
       end
     end)
   end)
@@ -259,13 +401,16 @@ describe("plugin spec opt", function()
       { { "foo/bar", event = "mod1" }, { "foo/bar", event = { "mod2" } } },
     }
     for _, test in ipairs(tests) do
+      Handler.init()
       local spec = Plugin.Spec.new(test)
       assert(#spec.notifs == 0)
       assert(vim.tbl_count(spec.plugins) == 1)
-      assert(type(spec.plugins.bar.event) == "table")
-      assert(#spec.plugins.bar.event == 2)
-      assert(vim.tbl_contains(spec.plugins.bar.event, "mod1"))
-      assert(vim.tbl_contains(spec.plugins.bar.event, "mod2"))
+      Handler.resolve(spec.plugins.bar)
+      local events = spec.plugins.bar._.handlers.event
+      assert(type(events) == "table")
+      assert(vim.tbl_count(events) == 2)
+      assert(events["mod1"])
+      assert(events["mod2"])
     end
   end)
 
@@ -310,45 +455,45 @@ describe("plugin spec opt", function()
 end)
 
 describe("plugin opts", function()
-  it("correctly parses opts", function()
-    ---@type {spec:LazySpec, opts:table}[]
-    local tests = {
-      {
-        spec = { { "foo/foo", opts = { a = 1, b = 1 } }, { "foo/foo", opts = { a = 2 } } },
-        opts = { a = 2, b = 1 },
-      },
-      {
-        spec = { { "foo/foo", config = { a = 1, b = 1 } }, { "foo/foo", opts = { a = 2 } } },
-        opts = { a = 2, b = 1 },
-      },
-      {
-        spec = { { "foo/foo", opts = { a = 1, b = 1 } }, { "foo/foo", config = { a = 2 } } },
-        opts = { a = 2, b = 1 },
-      },
-      {
-        spec = { { "foo/foo", config = { a = 1, b = 1 } }, { "foo/foo", config = { a = 2 } } },
-        opts = { a = 2, b = 1 },
-      },
-      {
-        spec = { { "foo/foo", config = { a = 1, b = 1 } }, { "foo/foo", config = { a = vim.NIL } } },
-        opts = { b = 1 },
-      },
-      {
-        spec = { { "foo/foo", config = { a = 1, b = 1 } }, { "foo/foo" } },
-        opts = { a = 1, b = 1 },
-      },
-      {
-        spec = { { "foo/foo" }, { "foo/foo" } },
-        opts = {},
-      },
-    }
+  ---@type {spec:LazySpec, opts:table}[]
+  local tests = {
+    {
+      spec = { { "foo/foo", opts = { a = 1, b = 1 } }, { "foo/foo", opts = { a = 2 } } },
+      opts = { a = 2, b = 1 },
+    },
+    {
+      spec = { { "foo/foo", config = { a = 1, b = 1 } }, { "foo/foo", opts = { a = 2 } } },
+      opts = { a = 2, b = 1 },
+    },
+    {
+      spec = { { "foo/foo", opts = { a = 1, b = 1 } }, { "foo/foo", config = { a = 2 } } },
+      opts = { a = 2, b = 1 },
+    },
+    {
+      spec = { { "foo/foo", config = { a = 1, b = 1 } }, { "foo/foo", config = { a = 2 } } },
+      opts = { a = 2, b = 1 },
+    },
+    {
+      spec = { { "foo/foo", config = { a = 1, b = 1 } }, { "foo/foo", config = { a = vim.NIL } } },
+      opts = { b = 1 },
+    },
+    {
+      spec = { { "foo/foo", config = { a = 1, b = 1 } }, { "foo/foo" } },
+      opts = { a = 1, b = 1 },
+    },
+    {
+      spec = { { "foo/foo" }, { "foo/foo" } },
+      opts = {},
+    },
+  }
 
-    for _, test in ipairs(tests) do
+  for _, test in ipairs(tests) do
+    it("correctly parses opts for " .. inspect(test.spec), function()
       local spec = Plugin.Spec.new(test.spec)
       assert(spec.plugins.foo)
       assert.same(test.opts, Plugin.values(spec.plugins.foo, "opts"))
-    end
-  end)
+    end)
+  end
 end)
 
 describe("plugin spec", function()

tests/core/util_spec.lua

@@ -1,10 +1,11 @@
-local Util = require("lazy.util")
 local Cache = require("lazy.core.cache")
 local Helpers = require("tests.helpers")
+local Util = require("lazy.util")
 
 describe("util", function()
   local rtp = vim.opt.rtp:get()
   before_each(function()
+    ---@type vim.Option
     vim.opt.rtp = rtp
     for k, v in pairs(package.loaded) do
       if k:find("^foobar") then
@@ -12,7 +13,7 @@ describe("util", function()
       end
     end
     Helpers.fs_rm("")
-    assert(not vim.loop.fs_stat(Helpers.path("")), "fs root should be deleted")
+    assert(not vim.uv.fs_stat(Helpers.path("")), "fs root should be deleted")
   end)
 
   it("lsmod lists all mods in dir", function()
@@ -85,7 +86,7 @@ describe("util", function()
     assert.same(Helpers.path("old/lua/foobar"), root)
 
     Helpers.fs_rm("old")
-    assert(not vim.loop.fs_stat(Helpers.path("old/lua/foobar")), "old/lua/foobar should not exist")
+    assert(not vim.uv.fs_stat(Helpers.path("old/lua/foobar")), "old/lua/foobar should not exist")
 
     -- vim.opt.rtp = rtp
     vim.opt.rtp:append(Helpers.path("new"))
@@ -101,6 +102,22 @@ describe("util", function()
         input = { { a = 1 }, { b = 2 } },
         output = { a = 1, b = 2 },
       },
+      {
+        input = { nil, { a = 1 }, { b = 2 } },
+        output = { a = 1, b = 2 },
+      },
+      {
+        input = { { a = 1 }, { b = 2 }, nil },
+        output = { a = 1, b = 2 },
+      },
+      {
+        input = { { a = 1 }, nil, { b = 2 } },
+        output = { a = 1, b = 2 },
+      },
+      {
+        input = { nil, { a = 1 }, nil, { b = 2 }, nil },
+        output = { a = 1, b = 2 },
+      },
       {
         input = { { a = 1 }, { a = 2 } },
         output = { a = 2 },
@@ -120,7 +137,11 @@ describe("util", function()
     }
 
     for _, test in ipairs(tests) do
-      assert.same(test.output, Util.merge(unpack(test.input)))
+      local n = 0
+      for i in pairs(test.input) do
+        n = math.max(n, i)
+      end
+      assert.same(test.output, Util.merge(unpack(test.input, 1, n)))
     end
   end)
 end)

tests/helpers.lua

@@ -26,12 +26,12 @@ function M.fs_rm(dir)
   dir = Util.norm(M.fs_root .. "/" .. dir)
   Util.walk(dir, function(path, _, type)
     if type == "directory" then
-      vim.loop.fs_rmdir(path)
+      vim.uv.fs_rmdir(path)
     else
-      vim.loop.fs_unlink(path)
+      vim.uv.fs_unlink(path)
     end
   end)
-  vim.loop.fs_rmdir(dir)
+  vim.uv.fs_rmdir(dir)
 end
 
 return M

tests/init.lua

@@ -1,36 +0,0 @@
-local M = {}
-
-function M.root(root)
-  local f = debug.getinfo(1, "S").source:sub(2)
-  return vim.fn.fnamemodify(f, ":p:h:h") .. "/" .. (root or "")
-end
-
----@param plugin string
-function M.load(plugin)
-  local name = plugin:match(".*/(.*)")
-  local package_root = M.root(".tests/site/pack/deps/start/")
-  if not vim.loop.fs_stat(package_root .. name) then
-    print("Installing " .. plugin)
-    vim.fn.mkdir(package_root, "p")
-    vim.fn.system({
-      "git",
-      "clone",
-      "--depth=1",
-      "https://github.com/" .. plugin .. ".git",
-      package_root .. "/" .. name,
-    })
-  end
-end
-
-function M.setup()
-  vim.cmd([[set runtimepath=$VIMRUNTIME]])
-  vim.opt.runtimepath:append(M.root())
-  vim.opt.packpath = { M.root(".tests/site") }
-  M.load("nvim-lua/plenary.nvim")
-  vim.env.XDG_CONFIG_HOME = M.root(".tests/config")
-  vim.env.XDG_DATA_HOME = M.root(".tests/data")
-  vim.env.XDG_STATE_HOME = M.root(".tests/state")
-  vim.env.XDG_CACHE_HOME = M.root(".tests/cache")
-end
-
-M.setup()

tests/manage/process_spec.lua

@@ -0,0 +1,19 @@
+local Async = require("lazy.async")
+local Process = require("lazy.manage.process")
+
+describe("process", function()
+  it("runs sync", function()
+    local lines = Process.exec({ "echo", "-n", "hello" })
+    assert.are.same({ "hello" }, lines)
+  end)
+
+  it("runs sync from async context", function()
+    local lines ---@type string[]
+    local async = Async.new(function()
+      lines = Process.exec({ "echo", "-n", "hello" })
+    end)
+    async:wait()
+
+    assert.are.same({ "hello" }, lines)
+  end)
+end)

tests/manage/runner_spec.lua

@@ -1,3 +1,4 @@
+local Async = require("lazy.async")
 local Runner = require("lazy.manage.runner")
 
 describe("runner", function()
@@ -30,11 +31,11 @@ describe("runner", function()
       end,
     }
     package.loaded["lazy.manage.task.test"]["async" .. i] = {
+      ---@async
       ---@param task LazyTask
       run = function(task)
-        task:schedule(function()
-          table.insert(runs, { plugin = task.plugin.name, task = task.name })
-        end)
+        Async.yield()
+        table.insert(runs, { plugin = task.plugin.name, task = task.name })
       end,
     }
   end
@@ -64,7 +65,7 @@ describe("runner", function()
     local runner = Runner.new({ plugins = plugins, pipeline = { "test.test1", "test.skip", "test.test2" } })
     runner:start()
     runner:wait()
-    assert.equal(4, #runs)
+    assert.equal(4, #runs, runs)
   end)
 
   it("handles opts", function()

tests/manage/semver_spec.lua

@@ -14,6 +14,7 @@ describe("semver version", function()
     ["1.2.3+build"] = { major = 1, minor = 2, patch = 3, build = "build" },
   }
   for input, output in pairs(tests) do
+    output.input = input
     it("correctly parses " .. input, function()
       assert.same(output, v(input))
     end)

tests/manage/task_spec.lua

@@ -1,96 +1,82 @@
 --# selene:allow(incorrect_standard_library_use)
+local Async = require("lazy.async")
 local Task = require("lazy.manage.task")
 
 describe("task", function()
   local plugin = { name = "test", _ = {} }
 
-  local done = false
-  ---@type string?
-  local error
+  ---@type {done?:boolean, error:string?}
+  local task_result = {}
 
   local opts = {
+    ---@param task LazyTask
     on_done = function(task)
-      done = true
-      error = task.error
+      task_result = { done = true, error = task.error }
     end,
   }
 
   before_each(function()
-    done = false
-    error = nil
+    task_result = {}
   end)
 
   it("simple function", function()
     local task = Task.new(plugin, "test", function() end, opts)
-    assert(not task:has_started())
-    assert(not task:is_running())
-    task:start()
-    assert(not task:is_running())
-    assert(task:is_done())
-    assert(done)
+    assert(task:running())
+    task:wait()
+    assert(not task:running())
+    assert(task_result.done)
   end)
 
   it("detects errors", function()
     local task = Task.new(plugin, "test", function()
       error("test")
     end, opts)
-    assert(not task:has_started())
-    assert(not task:is_running())
-    task:start()
-    assert(task:is_done())
-    assert(not task:is_running())
-    assert(done)
-    assert(error)
-    assert(task.error and task.error:find("test"))
+    assert(task:running())
+    task:wait()
+    assert(not task:running())
+    assert(task_result.done)
+    assert(task_result.error)
+    assert(task:has_errors() and task:output(vim.log.levels.ERROR):find("test"))
   end)
 
-  it("schedule", function()
-    local running = false
-    local task = Task.new(plugin, "test", function(task)
-      running = true
-      task:schedule(function()
-        running = false
-      end)
+  it("async", function()
+    local running = true
+    ---@async
+    local task = Task.new(plugin, "test", function()
+      Async.yield()
+      running = false
     end, opts)
-    assert(not task:is_running())
-    assert(not task:has_started())
-    task:start()
+    assert(task:running())
     assert(running)
-    assert(#task._running == 1)
-    assert(task:is_running())
-    assert(not task:is_done())
+    assert(task:running())
     task:wait()
-    assert(task:is_done())
-    assert(not task:is_running())
-    assert(done)
-    assert(not task.error)
+    assert(not running)
+    assert(not task:running())
+    assert(task_result.done)
+    assert(not task:has_errors())
   end)
 
   it("spawn errors", function()
-    local task = Task.new(plugin, "test", function(task)
+    local task = Task.new(plugin, "spawn_errors", function(task)
       task:spawn("foobar")
     end, opts)
-    assert(not task:is_running())
-    task:start()
-    assert(not task:is_running())
-    assert(done)
-    assert(task.error and task.error:find("Failed to spawn"))
+    assert(task:running())
+    task:wait()
+    assert(not task:running())
+    assert(task_result.done)
+    assert(task:has_errors() and task:output(vim.log.levels.ERROR):find("Failed to spawn"), task:output())
   end)
 
   it("spawn", function()
     local task = Task.new(plugin, "test", function(task)
       task:spawn("echo", { args = { "foo" } })
     end, opts)
-    assert(not task:is_running())
-    assert(not task:has_started())
-    task:start()
-    assert(task:has_started())
-    assert(task:is_running())
+    assert(task:running())
+    assert(task:running())
     task:wait()
-    assert(task:is_done())
-    assert.same(task.output, "foo\n")
-    assert(done)
-    assert(not task.error)
+    assert.same(task:output(), "foo")
+    assert(task_result.done)
+    assert(not task:has_errors())
   end)
 
   it("spawn 2x", function()
@@ -98,12 +84,11 @@ describe("task", function()
       task:spawn("echo", { args = { "foo" } })
       task:spawn("echo", { args = { "bar" } })
     end, opts)
-    assert(not task:is_running())
-    task:start()
-    assert(task:is_running())
+    assert(task:running())
+    assert(task:running())
     task:wait()
-    assert(task.output == "foo\nbar\n" or task.output == "bar\nfoo\n")
-    assert(done)
-    assert(not task.error)
+    assert(task:output() == "foo\nbar" or task:output() == "bar\nfoo", task:output())
+    assert(task_result.done)
+    assert(not task:has_errors())
   end)
 end)

tests/minit.lua

@@ -0,0 +1,12 @@
+#!/usr/bin/env -S nvim -l
+
+vim.env.LAZY_STDPATH = ".tests"
+
+vim.opt.rtp:prepend(".")
+
+-- Setup lazy.nvim
+require("lazy.minit").setup({
+  spec = {
+    { dir = vim.uv.cwd() },
+  },
+})

tests/run

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-nvim --headless -u tests/init.lua -c "PlenaryBustedDirectory tests {minimal_init = 'tests//init.lua', sequential = true}"

vim.toml

@@ -8,42 +8,14 @@ any = true
 [jit]
 any = true
 
-[[describe.args]]
-type = "string"
-[[describe.args]]
-type = "function"
-
-[[it.args]]
-type = "string"
-[[it.args]]
-type = "function"
-
-[[before_each.args]]
-type = "function"
-[[after_each.args]]
-type = "function"
-
-[assert.is_not]
+[assert]
 any = true
 
-[[assert.equals.args]]
-type = "any"
-[[assert.equals.args]]
-type = "any"
-[[assert.equals.args]]
-type = "any"
-required = false
+[describe]
+any = true
 
-[[assert.same.args]]
-type = "any"
-[[assert.same.args]]
-type = "any"
+[it]
+any = true
 
-[[assert.truthy.args]]
-type = "any"
-
-[[assert.spy.args]]
-type = "any"
-
-[[assert.stub.args]]
-type = "any"
+[before_each.args]
+any = true