2025-06-28 11:24:14 +00:00
75 changed files with 1115 additions and 122046 deletions
--- a/.busted
+++ b/.busted
@ -1,11 +0,0 @@
 return {
  _all = {
    coverage = false,
  },
  default = {
    verbose = true,
  },
  tests = {
    verbose = true,
  },
 }
--- a/.editorconfig
+++ b/.editorconfig
@ -1,7 +0,0 @@
 root = true
 [*]
 insert_final_newline = true
 indent_style = space
 indent_size = 2
 charset = utf-8
--- a/.github/.release-please-manifest.json
+++ b/.github/.release-please-manifest.json
@ -1,3 +1,3 @@
 {
-  ".": "11.17.1"
+  ".": "11.1.0"
 }
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@ -6,10 +6,7 @@ body:
  - type: markdown
    attributes:
      value: |
-        **Before** reporting an issue, make sure to read the [documentation](https://github.com/folke/lazy.nvim)
+        **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.
        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?
@ -17,8 +14,6 @@ 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
@ -62,14 +57,32 @@ body:
      label: Repro
      description: Minimal `init.lua` to reproduce this issue. Save as `repro.lua` and run with `nvim -u repro.lua`
      value: |
-        vim.env.LAZY_STDPATH = ".repro"
+        -- DO NOT change the paths and don't remove the colorscheme
-        load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))()
+        local root = vim.fn.fnamemodify("./.repro", ":p")
-        require("lazy.minit").repro({
+        -- set stdpaths to use .repro
-          spec = {
+        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",
        })
-      render: lua
+
        vim.cmd.colorscheme("tokyonight")
        -- add anything else here
      render: Lua
    validations:
      required: false
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@ -1,5 +0,0 @@
 blank_issues_enabled: false
 contact_links:
  - name: Ask a question
    url: https://github.com/folke/lazy.nvim/discussions
    about: Use Github discussions instead
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,16 +0,0 @@
 ## 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. -->
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@ -1,6 +1,11 @@
 # To get started with Dependabot version updates, you'll need to specify which
 # package ecosystems to update and where the package manifests are located.
 # Please see the documentation for all configuration options:
 # https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
 version: 2
 updates:
-  - package-ecosystem: "github-actions"
+  - package-ecosystem: "github-actions" # See documentation for possible values
-    directory: "/"
+    directory: "/" # Location of package manifests
    schedule:
      interval: "weekly"
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,15 +1,51 @@
 name: CI
 on:
  push:
    branches: [main, master]
  pull_request:
 jobs:
-  ci:
+  tests:
-    uses: folke/github/.github/workflows/ci.yml@main
+    strategy:
-    secrets: inherit
+      matrix:
        # os: [ubuntu-latest, windows-latest]
        os: [ubuntu-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - 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}"
  release:
    name: release
    if: ${{ github.ref == 'refs/heads/main' }}
    needs:
      - tests
    runs-on: ubuntu-latest
    steps:
      - uses: googleapis/release-please-action@v4
        id: release
        with:
-      plugin: lazy.nvim
+          config-file: .github/release-please-config.json
-      repo: folke/lazy.nvim
+          manifest-file: .github/.release-please-manifest.json
-      docs: false
+      - uses: actions/checkout@v4
      - 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
--- a/.github/workflows/community.yml
+++ b/.github/workflows/community.yml
@ -1,30 +0,0 @@
 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>"
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@ -1,19 +0,0 @@
 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
--- a/.github/workflows/labeler.yml
+++ b/.github/workflows/labeler.yml
@ -1,8 +0,0 @@
 name: "PR Labeler"
 on:
  - pull_request_target
 jobs:
  labeler:
    uses: folke/github/.github/workflows/labeler.yml@main
    secrets: inherit
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@ -1,18 +0,0 @@
 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
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@ -1,11 +0,0 @@
 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
--- a/.github/workflows/update.yml
+++ b/.github/workflows/update.yml
@ -1,13 +0,0 @@
 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
--- a/.gitignore
+++ b/.gitignore
@ -1,9 +1,8 @@
 *.log
 /.repro
 /.tests
 /build
 /debug
 /doc/tags
 foo.*
 node_modules
 tt.*
 .tests
 doc/tags
 debug
 .repro
 foo.*
 *.log
 data
--- a/.styluaignore
+++ b/.styluaignore
@ -1 +0,0 @@
 lua/lazy/community/_generated.lua
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,406 +1,5 @@
 # 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 -&gt; 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)
--- a/bootstrap.lua
+++ b/bootstrap.lua
@ -1,51 +0,0 @@
 -- 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
--- a/doc/lazy.nvim.txt
+++ b/doc/lazy.nvim.txt
@ -39,7 +39,6 @@ Table of Contents                                *lazy.nvim-table-of-contents*
 8. 🔥 Developers                                 |lazy.nvim-🔥-developers|
  - Best Practices                  |lazy.nvim-🔥-developers-best-practices|
  - Building                              |lazy.nvim-🔥-developers-building|
  - Minit (Minimal Init)      |lazy.nvim-🔥-developers-minit-(minimal-init)|
 9. Links                                                     |lazy.nvim-links|
 ==============================================================================
@ -157,16 +156,7 @@ STRUCTURED SETUP             *lazy.nvim-🛠️-installation-structured-setup*
    local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
    if not (vim.uv or vim.loop).fs_stat(lazypath) then
      local lazyrepo = "https://github.com/folke/lazy.nvim.git"
-      local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
+      vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
      if vim.v.shell_error ~= 0 then
        vim.api.nvim_echo({
          { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
          { out, "WarningMsg" },
          { "\nPress any key to exit..." },
        }, true, {})
        vim.fn.getchar()
        os.exit(1)
      end
    end
    vim.opt.rtp:prepend(lazypath)
@ -205,16 +195,7 @@ SINGLE FILE SETUP           *lazy.nvim-🛠️-installation-single-file-setup*
    local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
    if not (vim.uv or vim.loop).fs_stat(lazypath) then
      local lazyrepo = "https://github.com/folke/lazy.nvim.git"
-      local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
+      vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
      if vim.v.shell_error ~= 0 then
        vim.api.nvim_echo({
          { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
          { out, "WarningMsg" },
          { "\nPress any key to exit..." },
        }, true, {})
        vim.fn.getchar()
        os.exit(1)
      end
    end
    vim.opt.rtp:prepend(lazypath)
@ -291,39 +272,31 @@ SPEC LOADING                         *lazy.nvim-🔌-plugin-spec-spec-loading*
 SPEC SETUP                             *lazy.nvim-🔌-plugin-spec-spec-setup*
-  --------------------------------------------------------------------------------------------------
+  ----------------------------------------------------------------------------------------------------
  Property   Type                          Description
-  ---------- ----------------------------- ---------------------------------------------------------
+  ---------- ----------------------------- -----------------------------------------------------------
-  init       fun(LazyPlugin)               init functions are always executed during startup. Mostly
+  init       fun(LazyPlugin)               init functions are always executed during startup
                                           useful for setting vim.g.* configuration used by Vim
                                           plugins startup
-  opts       table or                      opts should be a table (will be merged with parent
+  opts       table or                      opts should be a table (will be merged with parent specs),
-             fun(LazyPlugin, opts:table)   specs), return a table (replaces parent specs) or should
+             fun(LazyPlugin, opts:table)   return a table (replaces parent specs) or should change a
-                                           change a table. The table will be passed to the
+                                           table. The table will be passed to the Plugin.config()
-                                           Plugin.config() function. Setting this value will imply
+                                           function. Setting this value will imply Plugin.config()
                                           Plugin.config()
  config     fun(LazyPlugin, opts:table)   config is executed when the plugin loads. The default
             or true                       implementation will automatically run
-                                           require(MAIN).setup(opts) if opts or config = true is
+                                           require(MAIN).setup(opts) if opts or config = true is set.
-                                           set. Lazy uses several heuristics to determine the
+                                           Lazy uses several heuristics to determine the plugin’s MAIN
-                                           plugin’s MAIN module automatically based on the plugin’s
+                                           module automatically based on the plugin’s name. See also
-                                           name. (opts is the recommended way to configure plugins).
+                                           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.
+                                           opts(), in case it can not be determined automatically. See
-                                           See config()
+                                           config()
  build      fun(LazyPlugin) or string or  build is executed when a plugin is installed or updated.
-             false or a list of build      See Building for more information.
+             a list of build commands      See Building for more information.
-             commands                      
+  ----------------------------------------------------------------------------------------------------
  --------------------------------------------------------------------------------------------------
 Always use `opts` instead of `config` when possible. `config` is almost never
 needed.
 SPEC LAZY LOADING               *lazy.nvim-🔌-plugin-spec-spec-lazy-loading*
@ -540,7 +513,9 @@ function.
        keys = {
          { "<leader>ft", "<cmd>Neotree toggle<cr>", desc = "NeoTree" },
        },
-        opts = {},
+        config = function()
          require("neo-tree").setup()
        end,
    }
 <
@ -644,42 +619,24 @@ will be added to the plugin’s spec.
        -- 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",
        versions = true, -- Honor versions in pkg sources
        -- 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
+          "rockspec",
          "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. If a function is used,
+        ---@type string | fun(plugin: LazyPlugin): string directory where you store your local plugin projects
        -- 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"}
@ -706,7 +663,6 @@ will be added to the plugin’s spec.
        icons = {
          cmd = " ",
          config = "",
          debug = "● ",
          event = " ",
          favorite = " ",
          ft = " ",
@ -732,7 +688,7 @@ will be added to the plugin’s spec.
        -- 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 = 1000 / 30, -- how frequently should the ui process render events
+        throttle = 20, -- how frequently should the ui process render events
        custom_keys = {
          -- You can define custom key maps here. If present, the description will
          -- be shown in the help menu.
@ -747,16 +703,6 @@ will be added to the plugin’s spec.
            desc = "Open lazygit log",
          },
          ["<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, {
@ -767,17 +713,6 @@ will be added to the plugin’s spec.
          },
        },
      },
      -- 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,
@ -829,7 +764,7 @@ will be added to the plugin’s spec.
        enabled = true,
        root = vim.fn.stdpath("state") .. "/lazy/readme",
        files = { "README.md", "lua/**/README.md" },
-        -- only generate markdown helptags for plugins that don't have docs
+        -- 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
@ -875,8 +810,6 @@ If you don’t want to use a Nerd Font, you can replace the icons with Unicode s
  -----------------------------------------------------------------------
  Highlight Group         Default Group           Description
  ----------------------- ----------------------- -----------------------
  LazyBold                { bold = true }         
  LazyButton              CursorLine              
  LazyButtonActive        Visual                  
@ -897,16 +830,10 @@ If you don’t want to use a Nerd Font, you can replace the icons with Unicode s
  LazyDir                 @markup.link            directory
  LazyError               DiagnosticError         task errors
  LazyH1                  IncSearch               home button
  LazyH2                  Bold                    titles
  LazyInfo                DiagnosticInfo          task errors
  LazyItalic              { italic = true }       
  LazyLocal               Constant                
  LazyNoCond              DiagnosticWarn          unloaded icon for a
@ -943,13 +870,13 @@ If you don’t want to use a Nerd Font, you can replace the icons with Unicode s
  LazySpecial             @punctuation.special    
  LazyTaskError           ErrorMsg                task errors
  LazyTaskOutput          MsgArea                 task output
  LazyUrl                 @markup.link            url
  LazyValue               @string                 value of a property
  LazyWarning             DiagnosticWarn          task errors
  -----------------------------------------------------------------------
 ==============================================================================
@ -1294,13 +1221,11 @@ BEST PRACTICES                      *lazy.nvim-🔥-developers-best-practices*
    >lua
        { "nvim-lua/plenary.nvim", lazy = true }
    <
 - Always use `opts` instead of `config` when possible. `config` is almost never
    needed.
 - Only use `dependencies` if a plugin needs the dep to be installed **AND**
    loaded. Lua plugins/libraries are automatically loaded when they are
    `require()`d, so they don’t need to be in `dependencies`.
 - Inside a `build` function or `*.lua` build file, use
-    `coroutine.yield(msg:string|LazyMsg)` to show progress.
+    `coroutine.yield(status_msg)` to show progress.
 - Don’t change the `cwd` in your build function, since builds run in parallel
    and changing the `cwd` will affect other builds.
@ -1319,104 +1244,10 @@ The spec **build** property can be one of the following:
 - if no `build` is specified, but a `build.lua` file exists, that will be used instead.
 Build functions and `*.lua` files run asynchronously in a coroutine. Use
-`coroutine.yield(msg:string|LazyMsg)` to show progress.
+`coroutine.yield(status_msg)` to show progress. Yielding will also schedule the
 next `coroutine.resume()` to run in the next tick, so you can do long-running
 tasks without blocking Neovim.
 Yielding will also schedule the next `coroutine.resume()` to run in the next
 tick, so you can do long-running tasks without blocking Neovim.
 >lua
    ---@class LazyMsg
    ---@field msg string
    ---@field level? number vim.log.levels.XXX
 <
 Use `vim.log.levels.TRACE` to only show the message as a **status** message for
 the task.
 MINIT (MINIMAL INIT)          *lazy.nvim-🔥-developers-minit-(minimal-init)*
 **lazy.nvim** comes with some built-in functionality to help you create a
 minimal init for your plugin.
 I mainly use this for testing and for users to create a `repro.lua`.
 When running in **headless** mode, **lazy.nvim** will log any messages to the
 terminal. See `opts.headless` for more info.
 **minit** will install/load all your specs and will always run an update as
 well.
 BOOTSTRAP ~
 >lua
    -- setting this env will override all XDG paths
    vim.env.LAZY_STDPATH = ".tests"
    -- this will install lazy in your stdpath
    load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))()
 <
 TESTING WITH BUSTED ~
 This will add `"lunarmodules/busted"`, configure `hererocks` and run `busted`.
 Below is an example of how I use **minit** to run tests with busted
 <https://olivinelabs.com/busted/> in **LazyVim**.
 >lua
    #!/usr/bin/env -S nvim -l
    vim.env.LAZY_STDPATH = ".tests"
    load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))()
    -- Setup lazy.nvim
    require("lazy.minit").busted({
      spec = {
        "LazyVim/starter",
        "williamboman/mason-lspconfig.nvim",
        "williamboman/mason.nvim",
        "nvim-treesitter/nvim-treesitter",
      },
    })
 <
 To use this, you can run:
 >sh
    nvim -l ./tests/busted.lua tests
 <
 If you want to inspect the test environment, run:
 >sh
    nvim -u ./tests/busted.lua
 <
 REPRO.LUA ~
 >lua
    vim.env.LAZY_STDPATH = ".repro"
    load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))()
    require("lazy.minit").repro({
      spec = {
        "stevearc/conform.nvim",
        "nvim-neotest/nvim-nio",
      },
    })
    -- do anything else you need to do to reproduce the issue
 <
 Then run it with:
 >sh
    nvim -u repro.lua
 <
 ==============================================================================
 9. Links                                                     *lazy.nvim-links*
--- a/lua/lazy/async.lua
+++ b/lua/lazy/async.lua
@ -1,222 +0,0 @@
 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
--- a/lua/lazy/build.lua
+++ b/lua/lazy/build.lua
@ -1,100 +0,0 @@
 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
--- a/lua/lazy/community/_generated.lua
+++ b/lua/lazy/community/_generated.lua
--- a/lua/lazy/community/init.lua
+++ b/lua/lazy/community/init.lua
@ -1,28 +0,0 @@
 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
--- a/lua/lazy/community/specs.lua
+++ b/lua/lazy/community/specs.lua
@ -1,7 +0,0 @@
 ---@type table<string, LazySpec>
 return {
  ["plenary.nvim"] = {
    "nvim-lua/plenary.nvim",
    lazy = true,
  },
 }
--- a/lua/lazy/core/config.lua
+++ b/lua/lazy/core/config.lua
@ -34,17 +34,6 @@ M.defaults = {
    -- 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,
@ -60,16 +49,9 @@ M.defaults = {
    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. If a function is used,
+    ---@type string | fun(plugin: LazyPlugin): string directory where you store your local plugin projects
    -- 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"}
@ -96,7 +78,6 @@ M.defaults = {
    icons = {
      cmd = " ",
      config = "",
      debug = "● ",
      event = " ",
      favorite = " ",
      ft = " ",
@ -122,7 +103,7 @@ 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 = 1000 / 30, -- how frequently should the ui process render events
+    throttle = 20, -- how frequently should the ui process render events
    custom_keys = {
      -- You can define custom key maps here. If present, the description will
      -- be shown in the help menu.
@ -137,16 +118,6 @@ M.defaults = {
        desc = "Open lazygit log",
      },
      ["<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, {
@ -157,17 +128,6 @@ M.defaults = {
      },
    },
  },
  -- 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,
@ -219,7 +179,7 @@ M.defaults = {
    enabled = true,
    root = vim.fn.stdpath("state") .. "/lazy/readme",
    files = { "README.md", "lua/**/README.md" },
-    -- only generate markdown helptags for plugins that don't have docs
+    -- 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
@ -235,14 +195,7 @@ M.defaults = {
  debug = false,
 }
-function M.hererocks()
+M.version = "11.1.0" -- x-release-please-version
  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")
@ -267,10 +220,8 @@ M.mapleader = nil
 ---@type string
 M.maplocalleader = nil
 M.suspended = false
 function M.headless()
-  return not M.suspended and #vim.api.nvim_list_uis() == 0
+  return #vim.api.nvim_list_uis() == 0
 end
 ---@param opts? LazyConfig
@ -298,9 +249,6 @@ 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 = {
@ -308,7 +256,7 @@ function M.setup(opts)
      vim.fn.stdpath("data") .. "/site",
      M.me,
      vim.env.VIMRUNTIME,
-      lib,
+      vim.fn.fnamemodify(vim.v.progpath, ":p:h:h") .. "/lib/nvim",
      vim.fn.stdpath("config") .. "/after",
    }
  end
@ -322,6 +270,10 @@ function M.setup(opts)
  M.mapleader = vim.g.mapleader
  M.maplocalleader = vim.g.maplocalleader
  if M.headless() then
    require("lazy.view.commands").setup()
  end
  vim.api.nvim_create_autocmd("UIEnter", {
    once = true,
    callback = function()
@ -329,9 +281,6 @@ function M.setup(opts)
    end,
  })
  if M.headless() then
    require("lazy.view.commands").setup()
  else
  vim.api.nvim_create_autocmd("User", {
    pattern = "VeryLazy",
    once = true,
@ -350,21 +299,15 @@ function M.setup(opts)
      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/")
+          require("lazy").pkg({
-            if plugin then
+            plugins = {
-              require("lazy").pkg({ plugins = { plugin } })
+              require("lazy.core.plugin").find(vim.uv.cwd() .. "/lua/"),
-            end
+            },
          end,
          })
        vim.api.nvim_create_autocmd({ "VimSuspend", "VimResume" }, {
          callback = function(ev)
            M.suspended = ev.event == "VimSuspend"
        end,
      })
    end,
  })
  end
  Util.very_lazy()
 end
--- a/lua/lazy/core/fragments.lua
+++ b/lua/lazy/core/fragments.lua
@ -124,7 +124,7 @@ function M:add(plugin)
  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
+  if not fragment.name then
    return self.spec:error("Invalid plugin spec " .. vim.inspect(plugin))
  end
--- a/lua/lazy/core/handler/event.lua
+++ b/lua/lazy/core/handler/event.lua
@ -75,9 +75,7 @@ function M:_add(event)
      end
      -- HACK: work-around for https://github.com/neovim/neovim/issues/25526
      done = true
      if event.id ~= "VeryLazy" then
      Util.track({ [self.type] = event.id })
      end
      local state = M.get_state(ev.event, ev.buf, ev.data)
@ -88,9 +86,7 @@ function M:_add(event)
      for _, s in ipairs(state) do
        M.trigger(s)
      end
      if event.id ~= "VeryLazy" then
      Util.track()
      end
    end,
  })
 end
--- a/lua/lazy/core/handler/init.lua
+++ b/lua/lazy/core/handler/init.lua
@ -5,7 +5,7 @@ local Util = require("lazy.core.util")
 ---@field type LazyHandlerTypes
 ---@field extends? LazyHandler
 ---@field active table<string,table<string,string>>
---@field managed table<string,string> mapping handler keys to plugin names
+---@field managed table<string,string>
 ---@field super LazyHandler
 local M = {}
@ -114,7 +114,7 @@ function M:add(plugin)
    if not self.active[key] then
      self.active[key] = {}
      self:_add(value)
-      self.managed[key] = plugin.name
+      self.managed[key] = key
    end
    self.active[key][plugin.name] = plugin.name
  end
--- a/lua/lazy/core/handler/keys.lua
+++ b/lua/lazy/core/handler/keys.lua
@ -11,7 +11,7 @@ local Util = require("lazy.core.util")
 ---@class LazyKeysSpec: LazyKeysBase
 ---@field [1] string lhs
---@field [2]? string|fun():string?|false rhs
+---@field [2]? string|fun()|false rhs
 ---@field mode? string|string[]
 ---@class LazyKeys: LazyKeysBase
--- a/lua/lazy/core/loader.lua
+++ b/lua/lazy/core/loader.lua
@ -161,7 +161,7 @@ function M.get_start_plugins()
  ---@type LazyPlugin[]
  local start = {}
  for _, plugin in pairs(Config.plugins) do
-    if not plugin._.loaded and (plugin._.rtp_loaded or plugin.lazy == false) then
+    if plugin.lazy == false and not plugin._.loaded then
      start[#start + 1] = plugin
    end
  end
@ -341,9 +341,7 @@ function M._load(plugin, reason, opts)
  Util.track({ plugin = plugin.name, start = reason.start })
  Handler.disable(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)
@ -355,9 +353,7 @@ function M._load(plugin, reason, opts)
    end, "Failed to load deps for " .. plugin.name)
  end
  if not plugin.virtual then
  M.packadd(plugin.dir)
  end
  if plugin.config or plugin.opts then
    M.config(plugin)
  end
@ -468,8 +464,10 @@ 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 Util.is_win then
+    if is_win then
      path = Util.norm(path)
    end
    if path == Config.me then
@ -497,11 +495,8 @@ 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)
@ -529,8 +524,8 @@ function M.colorscheme(name)
 end
 function M.auto_load(modname, modpath)
-  local plugin = Plugin.find(modpath, { fast = not M.did_handlers })
+  local plugin = Plugin.find(modpath)
-  if plugin then
+  if plugin and modpath:find(plugin.dir, 1, true) == 1 then
    plugin._.rtp_loaded = true
    -- don't load if:
    -- * handlers haven't been setup yet
@ -550,17 +545,9 @@ end
 ---@param modname string
 function M.loader(modname)
-  local paths, cached = Util.get_unloaded_rtp(modname, { cache = true })
+  local paths = Util.get_unloaded_rtp(modname)
  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
--- a/lua/lazy/core/meta.lua
+++ b/lua/lazy/core/meta.lua
@ -34,17 +34,14 @@ function M:load_pkgs()
    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
+      -- tag all package fragments 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
@ -92,7 +89,7 @@ function M:add(plugin)
  table.insert(meta._.frags, fragment.id)
-  if meta._ and meta._.rtp_loaded and meta.dir then
+  if meta._ and meta._.rtp_loaded then
    local old_dir = meta.dir
    self:_rebuild(meta.name)
    local new_dir = meta.dir
@ -120,14 +117,6 @@ 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
@ -154,9 +143,6 @@ function M:rebuild()
  for n, _ in pairs(self.dirty) do
    self:_rebuild(n)
  end
  if Config.options.debug then
    Util.track()
  end
 end
 --- Rebuild a single plugin.
@ -164,10 +150,6 @@ end
 --- 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
@ -179,7 +161,6 @@ function M:_rebuild(name)
  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)
@ -196,14 +177,10 @@ function M:_rebuild(name)
      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]
+        table.insert(plugin.dependencies, self.fragments:get(dep).name)
        if dep_meta then
          table.insert(plugin.dependencies, dep_meta.name)
        end
      end
    end
  end
@ -215,8 +192,6 @@ function M:_rebuild(name)
  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
@ -250,6 +225,7 @@ function M:_rebuild(name)
  setmetatable(plugin, { __index = super })
  self.dirty[plugin.name] = nil
  return plugin
 end
@ -304,26 +280,13 @@ 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
  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
--- a/lua/lazy/core/plugin.lua
+++ b/lua/lazy/core/plugin.lua
@ -21,7 +21,7 @@ M.Spec = Spec
 M.LOCAL_SPEC = ".lazy.lua"
 ---@param spec? LazySpec
---@param opts? {optional?:boolean, pkg?:boolean}
+---@param opts? {optional?:boolean}
 function Spec.new(spec, opts)
  local self = setmetatable({}, Spec)
  self.meta = Meta.new(self)
@ -30,9 +30,7 @@ function Spec.new(spec, opts)
  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
@ -146,43 +144,30 @@ function Spec:import(spec)
  local imported = 0
-  ---@type {modname: string, load: fun():(LazyPluginSpec?, string?)}[]
+  ---@type (string|(fun():LazyPluginSpec))[]
  local modspecs = {}
  if type(import) == "string" then
-    Util.lsmod(import, function(modname, modpath)
+    Util.lsmod(import, function(modname)
-      modspecs[#modspecs + 1] = {
+      modspecs[#modspecs + 1] = modname
        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)
    table.sort(modspecs)
  else
-    modspecs = { { modname = import_name, load = spec.import } }
+    modspecs = { spec.import }
  end
  for _, modspec in ipairs(modspecs) do
    imported = imported + 1
-    local modname = modspec.modname
+    local modname = type(modspec) == "string" and modspec or import_name
    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, err = modspec.load()
+      local mod = type(modspec) == "function" and modspec() or require(modspec)
-      if err then
+      if type(mod) ~= "table" then
-        self:error("Failed to load `" .. modname .. "`:\n" .. err)
+        self.importing = nil
      elseif type(mod) ~= "table" then
        return self:error(
          "Invalid spec module: `"
            .. modname
@ -190,20 +175,21 @@ 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)
      end,
    })
        self.importing = nil
        Util.track()
      end,
    })
  end
  if imported == 0 then
-    self:error("No specs found for module " .. vim.inspect(spec.import))
+    self:error("No specs found for module " .. spec.import)
  end
 end
@ -237,15 +223,12 @@ function M.update_state()
        or plugin.cmd
      plugin.lazy = lazy and true or false
    end
-    if plugin.virtual then
+    if plugin.dir:find(Config.options.root, 1, true) == 1 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 = vim.fn.isdirectory(plugin.dir) == 1
+      plugin._.installed = true -- local plugins are managed by the user
    end
  end
@ -281,19 +264,28 @@ function M.update_rocks_state()
  end)
  for _, plugin in pairs(Config.plugins) do
-    if plugin.build == "rockspec" or plugin.name == "hererocks" then
+    if plugin._.pkg and plugin._.pkg.source == "rockspec" and plugin.build == "rockspec" then
      plugin._.build = not installed[plugin.name]
    end
  end
 end
 ---@param path string
 function M.local_spec(path)
  local file = vim.secure.read(path)
  if file then
    return loadstring(file)()
  end
  return {}
 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
+  while path ~= "" do
    local file = path .. "/" .. M.LOCAL_SPEC
    if vim.fn.filereadable(file) == 1 then
      return {
@ -301,7 +293,7 @@ function M.find_local_spec()
        import = function()
          local data = vim.secure.read(file)
          if data then
-            return loadstring(data, M.LOCAL_SPEC)()
+            return loadstring(data)()
          end
          return {}
        end,
@ -341,20 +333,6 @@ 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
@ -384,24 +362,17 @@ end
 -- Finds the plugin that has this path
 ---@param path string
---@param opts? {fast?:boolean}
+function M.find(path)
 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)
-      if name then
+      return name and Config.plugins[name] or Config.spec.plugins[name] or nil
        if opts.fast then
          return Config.spec.meta.plugins[name]
        end
        return Config.spec.plugins[name]
      end
    end
  end
 end
@ -409,7 +380,7 @@ end
 ---@param plugin LazyPlugin
 function M.has_errors(plugin)
  for _, task in ipairs(plugin._.tasks or {}) do
-    if task:has_errors() then
+    if task.error then
      return true
    end
  end
--- a/lua/lazy/core/util.lua
+++ b/lua/lazy/core/util.lua
@ -5,7 +5,6 @@ local M = {}
 ---@type LazyProfile[]
 M._profiles = { { name = "lazy" } }
 M.is_win = jit.os:find("Windows")
 ---@param data (string|{[string]:string})?
 ---@param time number?
@ -29,10 +28,6 @@ function M.track(data, time)
  end
 end
 function M.exiting()
  return vim.v.exiting ~= vim.NIL
 end
 ---@generic T
 ---@param list T[]
 ---@param fn fun(v: T):boolean?
@ -66,7 +61,7 @@ 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
@ -171,9 +166,7 @@ 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
@ -245,33 +238,18 @@ function M.walkmods(root, fn, modname)
 end
 ---@param modname string
---@return string
+function M.get_unloaded_rtp(modname)
-function M.topmod(modname)
+  modname = modname:gsub("/", ".")
-  return modname:match("^[^./]+") or modname
+  local idx = modname:find(".", 1, true)
-end
+  local topmod = idx and modname:sub(1, idx - 1) or modname
  topmod = M.normname(topmod)
 ---@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 or plugin.virtual) then
+      if not (plugin._.loaded or plugin.module == false) then
-        if norm == M.normname(plugin.name) then
+        if topmod == M.normname(plugin.name) then
          table.insert(rtp, 1, plugin.dir)
        else
          table.insert(rtp, plugin.dir)
@ -279,45 +257,31 @@ function M.get_unloaded_rtp(modname, opts)
      end
    end
  end
-  M.unloaded_cache[topmod] = rtp
+  return 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 = paths,
+    paths = M.get_unloaded_rtp(modname),
-    patterns = { ".lua", "" },
+    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
-    return ret.modpath:gsub("%.lua$", ""), ret.modpath
+    local root = ret.modpath:gsub("/init%.lua$", ""):gsub("%.lua$", "")
    return root
  end
 end
 ---@param modname string
 ---@param fn fun(modname:string, modpath:string)
 function M.lsmod(modname, fn)
-  local root, match = M.find_root(modname)
+  local root = M.find_root(modname)
  if not root then
    return
  end
-  if match:sub(-4) == ".lua" then
+  if vim.uv.fs_stat(root .. ".lua") then
-    fn(modname, match)
+    fn(modname, root .. ".lua")
    if not vim.uv.fs_stat(root) then
      return
    end
  end
  M.ls(root, function(path, name, type)
@ -374,7 +338,6 @@ function M.notify(msg, opts)
  local lang = opts.lang or "markdown"
  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")
--- a/lua/lazy/docs.lua
+++ b/lua/lazy/docs.lua
@ -131,8 +131,7 @@ function M.colors(opts)
    { "---", "---", "---" },
  }
  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 "" }
    lines[#lines + 1] = { "**" .. opts.name .. group .. "**", link, comments[group] or "" }
  end)
  return { content = M.table(lines) }
 end
--- a/lua/lazy/health.lua
+++ b/lua/lazy/health.lua
@ -1,5 +1,4 @@
 local Config = require("lazy.core.config")
 local Process = require("lazy.manage.process")
 local uv = vim.uv or vim.loop
 local M = {}
@ -9,67 +8,23 @@ 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 .. "`")
-  M.have("git")
+  if vim.fn.executable("git") == 1 then
    ok("'git' installed")
  else
    error("'git' not installed?")
  end
  if Config.options.rocks.enabled then
    if vim.fn.executable("luarocks") == 1 then
      ok("'luarocks' installed")
    else
      error("'luarocks' not installed. Either install it or set opts.rocks.enabled = false")
    end
  end
  local sites = vim.opt.packpath:get()
  local default_site = vim.fn.stdpath("data") .. "/site"
@ -90,7 +45,7 @@ function M.check()
    ok("no existing packages found by other package managers")
  end
-  for _, name in ipairs({ "packer", "plugged", "paq", "pckr", "mini.deps" }) do
+  for _, name in ipairs({ "packer", "plugged", "paq" }) 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 .. "`")
@ -127,47 +82,6 @@ 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
--- a/lua/lazy/manage/checker.lua
+++ b/lua/lazy/manage/checker.lua
@ -35,9 +35,7 @@ end
 function M.fast_check(opts)
  opts = opts or {}
  for _, plugin in pairs(Config.plugins) do
-    -- don't check local plugins here, since we mark them as needing updates
+    if not plugin.pin and not plugin.dev and plugin._.installed then
    -- 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)
--- a/lua/lazy/manage/git.lua
+++ b/lua/lazy/manage/git.lua
@ -116,12 +116,6 @@ 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
@ -150,6 +144,7 @@ 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
@ -189,12 +184,7 @@ function M.get_tag_refs(repo, tagref)
  tagref = tagref or "--tags"
  ---@type table<string,string>
  local tags = {}
-  local ok, lines = pcall(function()
+  local lines = Process.exec({ "git", "show-ref", "-d", tagref }, { cwd = repo })
    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
--- a/lua/lazy/manage/init.lua
+++ b/lua/lazy/manage/init.lua
@ -80,23 +80,20 @@ 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",
-        ---@param runner Runner
+        sync = function()
        sync = function(runner)
          require("lazy.pkg").update()
          Plugin.load()
          runner:update()
        end,
      },
      "plugin.build",
    },
    plugins = function(plugin)
-      return not (plugin._.installed and not plugin._.build)
+      return plugin.url and not (plugin._.installed and not plugin._.build)
    end,
  }, opts):wait(function()
    require("lazy.manage.lock").update()
@ -109,7 +106,6 @@ function M.update(opts)
  opts = M.opts(opts, { mode = "update" })
  return M.run({
    pipeline = {
      "plugin.exists",
      "git.origin",
      "git.branch",
      "git.fetch",
@ -118,11 +114,9 @@ function M.update(opts)
      "plugin.docs",
      {
        "wait",
-        ---@param runner Runner
+        sync = function()
        sync = function(runner)
          require("lazy.pkg").update()
          Plugin.load()
          runner:update()
        end,
      },
      "plugin.build",
@ -149,7 +143,6 @@ function M.check(opts)
  opts = opts or {}
  return M.run({
    pipeline = {
      "plugin.exists",
      { "git.origin", check = true },
      "git.fetch",
      "git.status",
@ -239,7 +232,7 @@ function M.clear(plugins)
    if plugin._.tasks then
      ---@param task LazyTask
      plugin._.tasks = vim.tbl_filter(function(task)
-        return task:running() or task:has_errors()
+        return task:is_running() or task.error
      end, plugin._.tasks)
    end
  end
--- a/lua/lazy/manage/lock.lua
+++ b/lua/lazy/manage/lock.lua
@ -3,53 +3,50 @@ local Git = require("lazy.manage.git")
 local M = {}
---@alias LazyLockfile table<string, {commit:string, branch:string}>
+---@type 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, "wb"))
  f:write("{\n")
  M.lock = {}
-  -- keep disabled and cond plugins
+  ---@param plugin LazyPlugin
-  for name in pairs(M.lock) do
+  local plugins = vim.tbl_filter(function(plugin)
-    if not (Config.spec.disabled[name] or Config.spec.ignore_installed[name]) then
+    return not plugin._.is_local and plugin._.installed
-      M.lock[name] = nil
+  end, Config.plugins)
    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_keys(M.lock)
+  local names = vim.tbl_map(function(plugin)
    return plugin.name
  end, plugins)
  table.sort(names)
  for n, name in ipairs(names) do
-    local info = M.lock[name]
+    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
    end
-  f:write("\n}\n")
+  end
  f:write("\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")
@ -67,7 +64,9 @@ end
 ---@param plugin LazyPlugin
 ---@return {commit:string, branch:string}
 function M.get(plugin)
  if not M._loaded then
    M.load()
  end
  return M.lock[plugin.name]
 end
--- a/lua/lazy/manage/process.lua
+++ b/lua/lazy/manage/process.lua
@ -1,133 +1,66 @@
 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.uv
 ---@class ProcessOpts
 ---@field args string[]
 ---@field cwd? string
---@field on_line? fun(line:string)
+---@field on_line? fun(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>
 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)
+---@param cmd string
-  local self = setmetatable({}, { __index = Process })
+function M.spawn(cmd, opts)
  ---@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(), self.opts.env or {})
+  }, uv.os_environ(), opts.env or {})
  env.GIT_DIR = nil
  env.GIT_WORK_TREE = nil
  env.GIT_TERMINAL_PROMPT = "0"
@ -138,102 +71,128 @@ function Process:env()
  for k, v in pairs(env) do
    env_flat[#env_flat + 1] = k .. "=" .. v
  end
  return env_flat
 end
---@param signals uv.aliases.signals|uv.aliases.signals[]|nil
+  local stdout = assert(uv.new_pipe())
-function Process:kill(signals)
+  local stderr = assert(uv.new_pipe())
-  if not self.handle or self.handle:is_closing() then
+
-    return
+  local output = ""
-  end
+  ---@type uv_process_t?
-  signals = signals or { "sigterm", "sigkill" }
+  local handle = nil
-  signals = type(signals) == "table" and signals or { signals }
+
-  ---@cast signals uv.aliases.signals[]
+  ---@type uv_timer_t
-  local timer = assert(uv.new_timer())
+  local timeout
-  timer:start(0, 1000, function()
+  local killed = false
-    if self.handle and not self.handle:is_closing() and #signals > 0 then
+  if opts.timeout then
-      self.handle:kill(table.remove(signals, 1))
+    timeout = assert(uv.new_timer())
-    else
+    timeout:start(opts.timeout, 0, function()
-      timer:stop()
+      if M.kill(handle) then
        killed = true
      end
    end)
  end
---@param err? string
+  -- make sure the cwd is valid
---@param data? string
+  if not opts.cwd and type(uv.cwd()) ~= "string" then
---@param is_stderr? boolean
+    opts.cwd = uv.os_homedir()
-function Process:on_data(err, data, is_stderr)
+  end
-  assert(not err, err)
+
-  if not data then
+  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 self.opts.on_data then
+      if opts.on_exit then
-    self.opts.on_data(data, is_stderr)
+        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
  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
+        vim.schedule(function()
-    self.opts.on_line(lines[#lines])
+          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
-M.signals = {
+  uv.read_start(stdout, on_output)
-  "hup",
+  uv.read_start(stderr, on_output)
  "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[]
+  return handle
---@param opts? ProcessOpts
+end
-function M.spawn(cmd, opts)
+
-  return Process.new(cmd, opts)
+function M.kill(handle)
  if handle and not handle:is_closing() then
    M.running[handle] = nil
    uv.process_kill(handle, "sigint")
    return true
  end
 end
 function M.abort()
-  for _, proc in pairs(M.running) do
+  for handle in pairs(M.running) do
-    proc:kill()
+    M.kill(handle)
  end
 end
---@async
+---@param cmd string[]
---@param cmd string|string[]
+---@param opts? {cwd:string, env:table}
 ---@param opts? ProcessOpts
 function M.exec(cmd, opts)
  opts = opts or {}
-  local proc = M.spawn(cmd, opts)
+  ---@type string[]
-  proc:wait()
+  local lines
-  return vim.split(proc.data, "\n"), proc.code
+  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
 end
 return M
--- a/lua/lazy/manage/runner.lua
+++ b/lua/lazy/manage/runner.lua
@ -1,23 +1,23 @@
 local Async = require("lazy.async")
 local Config = require("lazy.core.config")
 local Task = require("lazy.manage.task")
 local Util = require("lazy.util")
 ---@class RunnerOpts
 ---@field pipeline (string|{[1]:string, [string]:any})[]
 ---@field plugins? LazyPlugin[]|fun(plugin:LazyPlugin):any?
 ---@field concurrency? number
 ---@class RunnerTask
 ---@field task? LazyTask
 ---@field step number
 ---@alias PipelineStep {task:string, opts?:TaskOptions}
 ---@alias LazyRunnerTask {co:thread, status: {task?:LazyTask, waiting?:boolean}, plugin: string}
 ---@class Runner
 ---@field _plugins table<string,LazyPlugin>
 ---@field _running LazyRunnerTask[]
 ---@field _pipeline PipelineStep[]
 ---@field _sync PipelineStep[]
 ---@field _on_done fun()[]
 ---@field _syncing boolean
 ---@field _opts RunnerOpts
 ---@field _running? Async
 local Runner = {}
 ---@param opts RunnerOpts
@ -37,161 +37,171 @@ function Runner.new(opts)
  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)
    return type(step) == "string" and { task = step } or { task = step[1], opts = step }
  end, self._opts.pipeline)
  self._sync = vim.tbl_filter(function(step)
    return step.task == "wait"
  end, self._pipeline)
  return self
 end
 function Runner:plugin(name)
-  return self._plugins[name]
+  return Config.plugins[name] or self._plugins[name]
 end
--- Update plugins
+---@param entry LazyRunnerTask
-function Runner:update()
+function Runner:_resume(entry)
-  for name in pairs(self._plugins) do
+  if entry.status.task and not entry.status.task:is_done() then
-    self._plugins[name] = Config.plugins[name] or self._plugins[name]
+    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
 end
 function Runner:resume(waiting)
  if self._syncing then
    return true
  end
  if waiting then
    local sync = self._sync[1]
    table.remove(self._sync, 1)
    if sync then
      self._syncing = true
      vim.schedule(function()
        if sync.opts and type(sync.opts.sync) == "function" then
          sync.opts.sync(self)
        end
        for _, entry in ipairs(self._running) do
          if entry.status then
            if entry.status.waiting then
              entry.status.waiting = false
              local plugin = self:plugin(entry.plugin)
              if plugin then
                plugin._.working = true
              end
            end
          end
        end
        self._syncing = false
      end)
    end
  end
  local running = 0
  for _, entry in ipairs(self._running) do
    if entry.status then
      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
  end
  return self._syncing or running > 0 or (not waiting and self:resume(true))
 end
 function Runner:start()
-  ---@async
+  ---@type string[]
-  self._running = Async.new(function()
+  local names = vim.tbl_keys(self._plugins)
-    self:_start()
+  table.sort(names)
  for _, name in pairs(names) do
    local co = coroutine.create(self.run_pipeline)
    local ok, err = coroutine.resume(co, self, name)
    if ok then
      table.insert(self._running, { co = co, status = {}, plugin = name })
    else
      Util.error("Could not start tasks for " .. name .. "\n" .. err)
    end
  end
  local check = vim.uv.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 = {}
  end)
 end
 ---@async
-function Runner:_start()
+---@param name string
-  ---@type string[]
+function Runner:run_pipeline(name)
  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
+  plugin._.working = true
-        if s.step == #self._pipeline then
+  coroutine.yield()
-          -- done
+  for _, step in ipairs(self._pipeline) do
          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
+      coroutine.yield({ waiting = true })
            wait_step = s.step
            break
          else
            s.task = self:queue(plugin, step)
      plugin._.working = true
-            if s.task then
+    else
-              active = active + 1
+      plugin = self:plugin(name)
-              s.task:wake(false)
+      local task = self:queue(plugin, step.task, step.opts)
-              break
+      if task then
        coroutine.yield({ task = task })
        assert(task:is_done())
        if task.error then
          plugin._.working = false
          return
        end
      end
    end
  end
-    end
+  plugin._.working = false
  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 step PipelineStep
+---@param task_name string
 ---@param opts? TaskOptions
 ---@return LazyTask?
-function Runner:queue(plugin, step)
+function Runner:queue(plugin, task_name, opts)
-  assert(self._running and self._running:running(), "Runner is not running")
+  assert(self._running)
-  local def = vim.split(step.task, ".", { plain = true })
+  local def = vim.split(task_name, ".", { plain = true })
  ---@type LazyTaskDef
  local task_def = require("lazy.manage.task." .. def[1])[def[2]]
-  assert(task_def, "Task not found: " .. step.task)
+  assert(task_def)
-  local opts = step.opts or {}
+  opts = opts or {}
  if not (task_def.skip and task_def.skip(plugin, opts)) then
-    return Task.new(plugin, def[2], task_def.run, opts)
+    local task = Task.new(plugin, def[2], task_def.run, opts)
    task:start()
    return task
  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 not self:is_running() then
+  if #self._running == 0 then
    if cb then
      cb()
    end
    return self
  end
  if cb then
-    self._running:on("done", cb)
+    table.insert(self._on_done, cb)
  else
-    self._running:wait()
+    -- sync wait
    while #self._running > 0 do
      vim.wait(10)
    end
  end
  return self
 end
--- a/lua/lazy/manage/semver.lua
+++ b/lua/lazy/manage/semver.lua
@ -9,7 +9,6 @@ local M = {}
 ---@field patch number
 ---@field prerelease? string
 ---@field build? string
 ---@field input? string
 local Semver = {}
 Semver.__index = Semver
@ -91,7 +90,6 @@ 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
--- a/lua/lazy/manage/task/fs.lua
+++ b/lua/lazy/manage/task/fs.lua
@ -21,23 +21,16 @@ M.clean = {
  skip = function(plugin)
    return plugin._.is_local
  end,
-  ---@param opts? {rocks_only?:boolean}
+  run = function(self)
  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!")
    rm(dir)
    local rock_root = Config.options.rocks.root .. "/" .. self.plugin.name
    if vim.uv.fs_stat(rock_root) then
      rm(rock_root)
    end
    if opts.rocks_only then
      return
    end
    rm(dir)
    self.plugin._.installed = false
  end,
 }
--- a/lua/lazy/manage/task/git.lua
+++ b/lua/lazy/manage/task/git.lua
@ -1,54 +1,8 @@
 local Async = require("lazy.async")
 local Config = require("lazy.core.config")
 local Git = require("lazy.manage.git")
 local Lock = require("lazy.manage.lock")
 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 = {}
@ -64,10 +18,8 @@ M.log = {
    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)",
@ -78,13 +30,11 @@ 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
-      info = assert(Git.info(self.plugin.dir))
+      local info = assert(Git.info(self.plugin.dir))
-      target = assert(Git.get_target(self.plugin))
+      local target = assert(Git.get_target(self.plugin))
      if not target.commit then
        for k, v in pairs(target) do
          error(k .. " '" .. v .. "' not found")
@ -92,7 +42,6 @@ M.log = {
        error("no target commit found")
      end
      assert(target.commit, self.plugin.name .. " " .. target.branch)
      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)
@ -103,7 +52,6 @@ M.log = {
      else
        self.plugin._.updates = { from = info, to = target }
      end
      end
      table.insert(args, info.commit .. ".." .. target.commit)
    else
      vim.list_extend(args, opts.args or Config.options.git.log)
@ -113,14 +61,6 @@ 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,
 }
@ -128,9 +68,7 @@ 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,
@ -189,9 +127,8 @@ M.branch = {
      return true
    end
    local branch = assert(Git.get_branch(plugin))
-    return Git.get_commit(plugin.dir, branch, true)
+    return Git.get_commit(plugin.dir, branch)
  end,
  ---@async
  run = function(self)
    local args = {
      "remote",
@ -217,17 +154,14 @@ 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({
+      self.error = "Origin has changed:\n"
-        "Origin has changed:",
+      self.error = self.error .. "  * old: " .. origin .. "\n"
-        "  * old: " .. origin,
+      self.error = self.error .. "  * new: " .. self.plugin.url .. "\n"
-        "  * new: " .. self.plugin.url,
+      self.error = self.error .. "Please run update to fix"
        "Please run update to fix",
      })
      return
    end
    require("lazy.manage.task.fs").clean.run(self, opts)
@ -239,7 +173,6 @@ 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" },
@ -247,7 +180,6 @@ M.status = {
      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
@ -258,13 +190,12 @@ M.status = {
            return line ~= ""
          end, lines)
          if #lines > 0 then
-            local msg = { "You have local changes in `" .. self.plugin.dir .. "`:" }
+            self.error = "You have local changes in `" .. self.plugin.dir .. "`:\n"
            for _, line in ipairs(lines) do
-              msg[#msg + 1] = "  * " .. line
+              self.error = self.error .. "  * " .. line .. "\n"
            end
-            msg[#msg + 1] = "Please remove them to update."
+            self.error = self.error .. "Please remove them to update.\n"
-            msg[#msg + 1] = "You can also press `x` to remove the plugin and then `I` to install it again."
+            self.error = self.error .. "You can also press `x` to remove the plugin and then `I` to install it again."
            self:error(msg)
          end
        end
      end,
@ -275,12 +206,10 @@ M.status = {
 -- fetches all needed origin branches
 M.fetch = {
  skip = function(plugin)
-    return not plugin._.installed or plugin._.is_local or cooldown(plugin)
+    return not plugin._.installed or plugin._.is_local
  end,
  ---@async
  run = function(self)
    throttle.wait()
    local args = {
      "fetch",
      "--recurse-submodules",
@ -296,11 +225,6 @@ 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,
 }
@ -312,10 +236,8 @@ 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))
@ -335,7 +257,7 @@ M.checkout = {
      end
    end
-    -- don't run checkout if target is already reached.
+    -- dont 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 = {
--- a/lua/lazy/manage/task/init.lua
+++ b/lua/lazy/manage/task/init.lua
@ -1,29 +1,23 @@
 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 async fun(task:LazyTask, opts:TaskOptions)
+---@field run fun(task:LazyTask, opts:TaskOptions)
---@alias LazyTaskFn async fun(task:LazyTask, opts:TaskOptions)
+---@alias LazyTaskState fun():boolean?
---@class LazyMsg
+---@class LazyTask
 ---@field msg string
 ---@field level? number
 ---@class LazyTask: Async
 ---@field plugin LazyPlugin
 ---@field name string
---@field private _log LazyMsg[]
+---@field output string
---@field private _started number
+---@field status string
 ---@field error? string
 ---@field private _task fun(task:LazyTask)
 ---@field private _running LazyPluginState[]
 ---@field private _started? number
 ---@field private _ended? number
 ---@field private _opts TaskOptions
---@field private _level number
+local Task = {}
 local Task = setmetatable({}, { __index = Async.Async })
 ---@class TaskOptions: {[string]:any}
 ---@field on_done? fun(task:LazyTask)
@ -31,210 +25,172 @@ local Task = setmetatable({}, { __index = Async.Async })
 ---@param plugin LazyPlugin
 ---@param name string
 ---@param opts? TaskOptions
---@param task LazyTaskFn
+---@param task fun(task:LazyTask)
 function Task.new(plugin, name, task, opts)
-  local self = setmetatable({}, { __index = Task })
+  local self = setmetatable({}, {
-  ---@async
+    __index = Task,
-  Task.init(self, function()
+  })
    self:_run(task)
  end)
  self:set_level()
  self._opts = opts or {}
-  self._log = {}
+  self._running = {}
  self._task = task
  self._started = nil
  self.plugin = plugin
  self.name = name
-  self._started = vim.uv.hrtime()
+  self.output = ""
  self.status = ""
  plugin._.tasks = plugin._.tasks or {}
  ---@param other LazyTask
  plugin._.tasks = vim.tbl_filter(function(other)
-    return other.name ~= name or other:running()
+    return other.name ~= name or other:is_running()
-  end, plugin._.tasks or {})
+  end, plugin._.tasks)
  table.insert(plugin._.tasks, self)
  self:render()
  return self
 end
---@param level? number
+function Task:has_started()
---@return LazyMsg[]
+  return self._started ~= nil
 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
---@param level? number
+function Task:is_done()
-function Task:output(level)
+  return self:has_started() and not self:is_running()
  return table.concat(
    ---@param m LazyMsg
    vim.tbl_map(function(m)
      return m.msg
    end, self:get_log(level)),
    "\n"
  )
 end
-function Task:status()
+function Task:is_running()
-  local ret = self._log[#self._log]
+  return self:has_started() and self._ended == nil
  local msg = ret and vim.trim(ret.msg) or ""
  return msg ~= "" and msg or nil
 end
-function Task:has_errors()
+function Task:start()
-  return self._level >= vim.log.levels.ERROR
+  if vim.in_fast_event() then
-end
+    return vim.schedule(function()
-
+      self:start()
 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)
+  end
-      self:error(err)
+  self._started = vim.uv.hrtime()
-    end)
+  ---@type boolean, string|any
-    :on("yield", function(msg)
+  local ok, err = pcall(self._task, self, self._opts)
-      self:log(msg)
+  if not ok then
-    end)
+    self.error = err or "failed"
-  task(self, self._opts)
+  end
  self:_check()
 end
---@param msg string|string[]|LazyMsg
+---@param fn async fun()
---@param level? number
+function Task:async(fn)
-function Task:log(msg, level)
+  local co = coroutine.create(fn)
-  if type(msg) == "table" and msg.msg then
+  local check = vim.uv.new_check()
-    level = msg.level or level
+  check:start(vim.schedule_wrap(function()
-    msg = msg.msg
+    local status = coroutine.status(co)
-  end
+    if status == "dead" then
-  level = level or vim.log.levels.DEBUG
+      check:stop()
-  self._level = math.max(self._level or 0, level or 0)
+      self:_check()
-  msg = type(msg) == "table" and table.concat(msg, "\n") or msg
+    elseif status == "suspended" then
-  ---@cast msg string
+      local ok, res = coroutine.resume(co)
-  table.insert(self._log, { msg = msg, level = level })
+      if not ok then
-  self:render()
+        error(res)
-  if Config.headless() then
+      elseif res then
-    self:headless()
+        self.status = res
-  end
+        self.output = self.output .. "\n" .. res
 end
 function Task:render()
  vim.schedule(function()
        vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
      end
    end
  end))
  table.insert(self._running, function()
    return check:is_active()
  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:_done()
+function Task:_check()
-  if Config.headless() and Config.options.headless.task then
+  for _, state in ipairs(self._running) do
-    local ms = math.floor(self:time() + 0.5)
+    if state() then
-    self:log("Finished task " .. self.name .. " in " .. ms .. "ms", vim.log.levels.INFO)
+      return
    end
  end
  self._ended = vim.uv.hrtime()
  if self._opts.on_done then
    self._opts.on_done(self)
  end
-  self:render()
+  vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
  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()
-  return ((self._ended or vim.uv.hrtime()) - self._started) / 1e6
+  if not self:has_started() then
    return 0
  end
  if not self:is_done() then
    return (vim.uv.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)
 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)
-    if not headless then
+    self.status = line
      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
-  if headless then
+  ---@param output string
-    opts.on_data = function(data)
+  function opts.on_exit(ok, output)
-      -- prefix with plugin name
+    self.output = self.output .. output
-      io.write(Terminal.prefix(data, self:prefix()))
+    if not ok then
      self.error = self.error and (self.error .. "\n" .. output) or output
    end
    if on_exit then
      pcall(on_exit, ok, output)
    end
    self:_check()
  end
  local proc = Process.spawn(cmd, opts)
-  proc:wait()
+  table.insert(self._running, function()
-
+    return proc and not proc:is_closing()
-  local ok = proc.code == 0 and proc.signal == 0
+  end)
  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
-  if opts.on_exit then
+---@param tasks (LazyTask?)[]
-    pcall(opts.on_exit, ok, proc.data)
+function Task.all_done(tasks)
  for _, task in ipairs(tasks) do
    if task and not task:is_done() then
      return false
    end
-  return ok
+  end
  return true
 end
-function Task:prefix()
+function Task:wait()
-  local plugin = "[" .. self.plugin.name .. "] "
+  while self:is_running() do
-  local task = string.rep(" ", 20 - #(self.name .. self.plugin.name)) .. self.name
+    vim.wait(10)
-
+  end
  return colors and Terminal.magenta(plugin) .. Terminal.cyan(task) .. Terminal.bright_black(" | ")
    or plugin .. " " .. task .. " | "
 end
 return Task
--- a/lua/lazy/manage/task/plugin.lua
+++ b/lua/lazy/manage/task/plugin.lua
@ -1,5 +1,5 @@
 local Config = require("lazy.core.config")
 local Loader = require("lazy.core.loader")
 local Rocks = require("lazy.pkg.rockspec")
 local Util = require("lazy.util")
 ---@type table<string, LazyTaskDef>
@ -17,16 +17,32 @@ end
 local B = {}
 ---@param task LazyTask
---@param build string
+function B.rockspec(task)
-function B.cmd(task, build)
+  local root = Config.options.rocks.root .. "/" .. task.plugin.name
-  if task.plugin.build ~= "rockspec" then
+  vim.fn.mkdir(root, "p")
-    Loader.load(task.plugin, { task = "build" })
+  task:spawn("luarocks", {
-  end
+    args = {
-  local cmd = vim.api.nvim_parse_cmd(build:sub(2), {}) --[[@as vim.api.keyset.cmd]]
+      "--tree",
-  task:log(vim.api.nvim_cmd(cmd, { output = true }))
+      root,
      "--server",
      Config.options.rocks.server,
      "--dev",
      "--lua-version",
      "5.1",
      "make",
      "--force-fast",
    },
    cwd = task.plugin.dir,
  })
 end
 ---@param task LazyTask
 ---@param build string
 function B.cmd(task, build)
  local cmd = vim.api.nvim_parse_cmd(build:sub(2), {}) --[[@as vim.api.keyset.cmd]]
  task.output = vim.api.nvim_cmd(cmd, { output = true })
 end
 ---@async
 ---@param task LazyTask
 ---@param build string
 function B.shell(task, build)
@ -47,10 +63,13 @@ M.build = {
    end
    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]])
    if self.plugin.build ~= "rockspec" then
      Loader.load(self.plugin, { task = "build" })
    end
    local builders = self.plugin.build
    -- Skip if `build` is set to `false`
@ -65,9 +84,11 @@ M.build = {
      ---@cast builders (string|fun(LazyPlugin))[]
      for _, build in ipairs(builders) do
        if type(build) == "function" then
          self:async(function()
            build(self.plugin)
          end)
        elseif build == "rockspec" then
-          Rocks.build(self)
+          B.rockspec(self)
        elseif build:sub(1, 1) == ":" then
          B.cmd(self, build)
        elseif build:match("%.lua$") then
@ -76,7 +97,7 @@ M.build = {
          if not chunk or err then
            error(err)
          end
-          chunk()
+          self:async(chunk)
        else
          B.shell(self, build)
        end
@ -87,23 +108,12 @@ M.build = {
 M.docs = {
  skip = function(plugin)
-    return not plugin._.is_local and not plugin._.dirty
+    return 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:log(vim.api.nvim_cmd({ cmd = "helptags", args = { docs } }, { output = true }))
+      self.output = 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,
 }
--- a/lua/lazy/minit.lua
+++ b/lua/lazy/minit.lua
@ -1,214 +0,0 @@
 ---@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
--- a/lua/lazy/pkg/init.lua
+++ b/lua/lazy/pkg/init.lua
@ -1,8 +1,8 @@
 local Config = require("lazy.core.config")
-local Util = require("lazy.core.util")
+local Util = require("lazy.util")
 local M = {}
-M.VERSION = 12
+M.VERSION = 10
 M.dirty = false
 ---@class LazyPkg
@ -14,7 +14,6 @@ M.dirty = false
 ---@class LazyPkgSpec
 ---@field file string
 ---@field source? string
 ---@field spec? LazySpec
 ---@field code? string
@ -55,7 +54,7 @@ function M.update()
          local pkg = {
            name = plugin.name,
            dir = plugin.dir,
-            source = spec.source or source.name,
+            source = source.name,
            file = spec.file,
            spec = spec.spec or {},
          }
@ -71,10 +70,9 @@ function M.update()
  table.sort(ret.pkgs, function(a, b)
    return a.name < b.name
  end)
-  local U = require("lazy.util")
+  local code = "return " .. Util.dump(ret)
  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)
+  Util.write_file(Config.options.pkg.cache, code)
  M.dirty = false
  M.cache = nil
 end
--- a/lua/lazy/pkg/rockspec.lua
+++ b/lua/lazy/pkg/rockspec.lua
@ -1,328 +1,81 @@
 --# 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")
 local M = {}
 M.dev_suffix = "-1.rockspec"
 M.skip = { "lua" }
 ---@param plugin LazyPlugin
 function M.deps(plugin)
  local root = Config.options.rocks.root .. "/" .. plugin.name
  local manifest_file = root .. "/lib/luarocks/rocks-5.1/manifest"
  local manifest = {}
  pcall(function()
    local load, err = loadfile(manifest_file, "t", manifest)
    if not load then
      error(err)
    end
    load()
  end)
  return vim.tbl_keys(manifest.repository or {})
 end
 ---@class RockSpec
 ---@field rockspec_format string
 ---@field package string
 ---@field version string
 ---@field dependencies string[]
---@field build? {type?: string, modules?: any[]}
+---@field build? {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
+  local rockspec_file ---@type string?
-    return {
+  Util.ls(plugin.dir, function(path, name, t)
-      file = "community",
+    if t == "file" and name:sub(-#M.dev_suffix) == M.dev_suffix then
-      source = "lazy",
+      rockspec_file = path
-      spec = Community.get_spec(plugin.name),
+      return false
-    }
+    end
  end)
  if not rockspec_file then
    return
  end
-  local rockspec_file = M.find_rockspec(plugin)
+  ---@type RockSpec?
-  local rockspec = rockspec_file and M.rockspec(rockspec_file)
+  ---@diagnostic disable-next-line: missing-fields
  local rockspec = {}
  local load, err = loadfile(rockspec_file, "t", rockspec)
  if not load then
    error(err)
  end
  load()
  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 =
+  local use = not has_lua
    -- 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 (
-    or not M.is_simple_build(rockspec)
+      rockspec.build
      and rockspec.build.build_type
      and rockspec.build.build_type ~= "none"
      and not (rockspec.build.build_type == "builtin" and not rockspec.build.modules)
    )
  if not use then
-    -- community specs only
+    return
    return #specs > 0
        and {
          file = vim.fn.fnamemodify(rockspec_file, ":t"),
          spec = {
            plugin.name,
            specs = specs,
            build = false,
          },
        }
      or nil
  end
  local lazy = nil
@ -337,7 +90,7 @@ function M.get(plugin)
      build = "rockspec",
      lazy = lazy,
    },
-  }
+  } or nil
 end
 return M
--- a/lua/lazy/stats.lua
+++ b/lua/lazy/stats.lua
@ -21,7 +21,6 @@ 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
--- a/lua/lazy/terminal.lua
+++ b/lua/lazy/terminal.lua
@ -1,71 +0,0 @@
 ---@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
--- a/lua/lazy/types.lua
+++ b/lua/lazy/types.lua
@ -10,7 +10,6 @@
 ---@field dirty? boolean
 ---@field build? boolean
 ---@field frags? number[]
 ---@field top? boolean
 ---@field handlers? LazyPluginHandlers
 ---@field installed? boolean
 ---@field is_local? boolean
@ -21,7 +20,6 @@
 ---@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
@ -31,7 +29,7 @@
 ---@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? false|string|async fun(self:LazyPlugin)|(string|async fun(self:LazyPlugin))[]
+---@field build? string|async fun(self:LazyPlugin)|(string|async fun(self:LazyPlugin))[]
 ---@field opts? PluginOpts
 ---@class LazyPluginHandlers
@ -61,7 +59,6 @@
 ---@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[]
@ -76,8 +73,6 @@
 ---@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[]
--- a/lua/lazy/util.lua
+++ b/lua/lazy/util.lua
@ -73,24 +73,28 @@ end
 ---@param fn F
 ---@return F
 function M.throttle(ms, fn)
-  ---@type Async
+  local timer = vim.uv.new_timer()
-  local async
+  local running = false
-  local pending = false
+  local first = true
-  return function()
+  return function(...)
-    if async and async:running() then
+    local args = { ... }
-      pending = true
+    local wrapped = function()
-      return
+      fn(unpack(args))
    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)
-      until not pending
+      timer:start(ms, 0, function()
        running = false
        vim.schedule(wrapped)
      end)
      running = true
    end
  end
 end
@ -162,21 +166,12 @@ 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
@ -236,6 +231,18 @@ function M.markdown(msg, opts)
  )
 end
 ---@async
 ---@param ms number
 function M.sleep(ms)
  local continue = false
  vim.defer_fn(function()
    continue = true
  end, ms)
  while not continue do
    coroutine.yield()
  end
 end
 function M._dump(value, result)
  local t = type(value)
  if t == "number" or t == "boolean" then
--- a/lua/lazy/view/colors.lua
+++ b/lua/lazy/view/colors.lua
@ -30,22 +30,19 @@ M.colors = {
  Button = "CursorLine",
  ButtonActive = "Visual",
  TaskOutput = "MsgArea", -- task output
-  Error = "DiagnosticError", -- task errors
+  TaskError = "ErrorMsg", -- 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
-    local hl = type(link) == "table" and link or { link = link }
+    vim.api.nvim_set_hl(0, "Lazy" .. hl_group, {
-    hl.default = true
+      link = link,
-    vim.api.nvim_set_hl(0, "Lazy" .. hl_group, hl)
+      default = true,
    })
  end
 end
@ -57,11 +54,6 @@ 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()
--- a/lua/lazy/view/commands.lua
+++ b/lua/lazy/view/commands.lua
@ -146,7 +146,7 @@ end
 ---@return string, string[]
 function M.parse(args)
  local parts = vim.split(vim.trim(args), "%s+")
-  if vim.startswith("Lazy", parts[1]) then
+  if parts[1]:find("Lazy") then
    table.remove(parts, 1)
  end
  if args:sub(-1) == " " then
--- a/lua/lazy/view/config.lua
+++ b/lua/lazy/view/config.lua
@ -34,8 +34,6 @@ M.keys = {
  profile_sort = "<C-s>",
  profile_filter = "<C-f>",
  abort = "<C-c>",
  next = "]]",
  prev = "[[",
 }
 ---@type table<string,LazyViewCommand>
--- a/lua/lazy/view/float.lua
+++ b/lua/lazy/view/float.lua
@ -166,7 +166,7 @@ function M:mount()
    self:augroup(true)
  end, { win = true })
  self:focus()
-  self:on_key(ViewConfig.keys.close, self.close, "Close")
+  self:on_key(ViewConfig.keys.close, self.close)
  self:on({ "BufDelete", "BufHidden" }, self.close)
  if vim.bo[self.buf].buftype == "" then
@ -295,7 +295,6 @@ function M:close(opts)
      vim.diagnostic.reset(Config.ns, buf)
      vim.api.nvim_buf_delete(buf, { force = true })
    end
    vim.cmd.redraw()
  end)
 end
--- a/lua/lazy/view/init.lua
+++ b/lua/lazy/view/init.lua
@ -67,10 +67,7 @@ function M.create()
  self.state = vim.deepcopy(default_state)
  self.render = Render.new(self)
-  local update = self.update
+  self.update = Util.throttle(Config.options.ui.throttle, 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()
@ -83,11 +80,8 @@ function M.create()
  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, desc = "Abort" })
+  end, { silent = true, buffer = self.buf, expr = true })
  vim.keymap.set("n", "gx", "K", { buffer = self.buf, remap = true })
  -- plugin details
  self:on_key(ViewConfig.keys.details, function()
@ -97,49 +91,17 @@ 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, "Details")
+  end)
  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, "Sort Profile")
+  end)
  self:on_key(ViewConfig.keys.profile_filter, function()
    if self.state.mode == "profile" then
@ -159,18 +121,17 @@ function M.create()
        end
      end)
    end
-  end, "Filter Profile")
+  end)
  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, desc)
+      end)
    end
  end
@ -181,7 +142,9 @@ 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
@ -220,17 +183,17 @@ function M:setup_patterns()
    ["(https?://%S+)"] = function(url)
      Util.open(url)
    end,
-  }, self.hover, "Hover")
+  }, self.hover)
  self:on_pattern(ViewConfig.keys.diff, {
    [commit_pattern] = function(hash)
      self:diff({ commit = hash })
    end,
-  }, self.diff, "Diff")
+  }, self.diff)
  self:on_pattern(ViewConfig.commands.restore.key_plugin, {
    [commit_pattern] = function(hash)
      self:restore({ commit = hash })
    end,
-  }, self.restore, "Restore")
+  }, self.restore)
 end
 ---@param opts? {commit:string}
@ -295,8 +258,7 @@ end
 ---@param key string
 ---@param patterns table<string, fun(str:string)>
 ---@param fallback? fun(self)
---@param desc? string
+function M:on_pattern(key, patterns, fallback)
 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)
@ -318,7 +280,7 @@ function M:on_pattern(key, patterns, fallback, desc)
    if fallback then
      fallback(self)
    end
-  end, desc)
+  end)
 end
 function M:setup_modes()
--- a/lua/lazy/view/render.lua
+++ b/lua/lazy/view/render.lua
@ -51,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:running() then
+        if not task:is_running() then
          self.progress.done = self.progress.done + 1
        end
      end
@ -74,17 +74,7 @@ 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,
@ -94,7 +84,7 @@ function M:update()
      diag.lnum = diag.row - 1
      return diag
    end, self._diagnostics),
-    { signs = false, virtual_text = true, underline = false, virtual_lines = false }
+    { signs = false, virtual_text = true, underline = false }
  )
 end
@ -122,15 +112,6 @@ 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)
@ -144,6 +125,8 @@ function M:title()
      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) "
        end
      end
@ -199,15 +182,7 @@ 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():nl()
+  self:append("Use "):append("<d>", "LazySpecial"):append(" on a commit or plugin to open the diff view"):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()
@ -379,37 +354,7 @@ end
 ---@param plugin LazyPlugin
 function M:diagnostics(plugin)
-  local skip = false
+  if plugin._.updated then
  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",
@ -438,6 +383,19 @@ 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
@ -476,22 +434,6 @@ 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
@ -500,32 +442,25 @@ function M:tasks(plugin)
      self:append(" " .. math.floor((task:time()) * 100) / 100 .. "ms", "Bold")
      self:nl()
    end
-
+    if task.error then
-    if not task:has_warnings() and task.name == "log" then
+      self:append(vim.trim(task.error), "LazyTaskError", { indent = 6 })
      self:nl()
    elseif task.name == "log" then
      self:log(task)
-    else
+    elseif self.view:is_selected(plugin) and task.output ~= "" and task.output ~= task.error then
-      local hls = {
+      self:append(vim.trim(task.output), "LazyTaskOutput", { indent = 6 })
-        [vim.log.levels.ERROR] = "LazyError",
+      self:nl()
        [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 then
      if msg:find("^%S+!:") then
        self:diagnostic({ message = "Breaking Changes", severity = vim.diagnostic.severity.WARN })
      end
@ -547,9 +482,6 @@ function M:log(task)
      })
      self:append(" " .. time, "LazyComment")
      self:nl()
        -- else
        --   self:append(line, "LazyTaskOutput", { indent = 6 }):nl()
      end
    end
    self:nl()
  end
@ -580,7 +512,7 @@ function M:details(plugin)
    end
  end
  local rocks = require("lazy.pkg.rockspec").deps(plugin)
-  if rocks then
+  if not vim.tbl_isempty(rocks) then
    table.insert(props, { "rocks", vim.inspect(rocks) })
  end
@ -759,7 +691,7 @@ function M:debug()
        ---@type string[]
        plugins = vim.tbl_values(plugins)
        table.sort(plugins)
-        self:append(Config.options.ui.icons.debug, "LazySpecial", { indent = 2 })
+        self:append("● ", "LazySpecial", { indent = 2 })
        if handler_type == "keys" then
          for k, v in pairs(Config.plugins[plugins[1]]._.handlers.keys) do
            if k == value then
--- a/lua/lazy/view/sections.lua
+++ b/lua/lazy/view/sections.lua
@ -17,7 +17,7 @@ return {
  {
    filter = function(plugin)
      return has_task(plugin, function(task)
-        return task:has_errors()
+        return task.error ~= nil
      end)
    end,
    title = "Failed",
@ -28,24 +28,19 @@ return {
        return true
      end
      return has_task(plugin, function(task)
-        return task:running()
+        return task:is_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
-        for _, line in ipairs(vim.split(task:output(), "\n")) do
+        local lines = vim.split(task.output, "\n")
        for _, line in ipairs(lines) do
          if line:find("^%w+ %S+!:") then
            return true
          end
@ -76,7 +71,7 @@ return {
  {
    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",
--- a/lua/lazy/view/text.lua
+++ b/lua/lazy/view/text.lua
@ -11,7 +11,9 @@ local Util = require("lazy.util")
 local Text = {}
 function Text.new()
-  local self = setmetatable({}, { __index = Text })
+  local self = setmetatable({}, {
    __index = Text,
  })
  self._lines = {}
  return self
--- a/116407
+++ b/116407
--- a/scripts/test
+++ b/scripts/test
@ -1,3 +0,0 @@
 #!/bin/env bash
 nvim -l tests/minit.lua --minitest
--- a/tests/core/e2e_spec.lua
+++ b/tests/core/e2e_spec.lua
@ -0,0 +1,39 @@
 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.uv.fs_stat(root .. "/paint.nvim/README.md"))
    assert(vim.uv.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)
--- a/tests/core/init_spec.lua
+++ b/tests/core/init_spec.lua
@ -1,10 +1,7 @@
 local Util = require("lazy.core.util")
 describe("init", function()
  it("has correct environment for tests", function()
-    for _, name in ipairs({ "config", "data", "cache", "state" }) do
+    for _, path in ipairs({ "config", "data", "cache", "state" }) do
-      local path = Util.norm(vim.fn.stdpath(name) --[[@as string]])
+      assert(vim.fn.stdpath(path):find(".tests/" .. path))
      assert(path:find(".tests/" .. name, 1, true), path .. " not in .tests")
    end
  end)
 end)
--- a/tests/core/plugin_spec.lua
+++ b/tests/core/plugin_spec.lua
@ -2,32 +2,28 @@ local Config = require("lazy.core.config")
 local Handler = require("lazy.core.handler")
 local Plugin = require("lazy.core.plugin")
 local assert = require("luassert")
 Config.setup()
 local function inspect(obj)
  return vim.inspect(obj):gsub("%s+", " ")
 end
---@param plugin LazyPlugin
+---@param plugins LazyPlugin[]|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[]
 local function clean(plugins)
-  return vim.tbl_map(function(plugin)
+  local p = plugins
-    plugin = resolve(plugin)
+  plugins = type(plugins) == "table" and plugins or { plugins }
-    plugin[1] = nil
+  for _, plugin in pairs(plugins) do
    plugin._.fid = nil
    plugin._.fpid = nil
    plugin._.fdeps = nil
    plugin._.frags = nil
    if plugin._.dep == false then
      plugin._.dep = nil
    end
-    plugin._.top = nil
+  end
-    return plugin
+  return p
  end, plugins)
 end
 describe("plugin spec url/name", function()
@ -174,12 +170,14 @@ describe("plugin spec opt", function()
      end
      assert.same({
        bar = {
          "foo/bar",
          _ = {},
          dependencies = { "dep1", "dep2" },
          name = "bar",
          url = "https://github.com/foo/bar.git",
        },
        dep1 = {
          "foo/dep1",
          _ = {
            dep = true,
          },
@ -187,6 +185,7 @@ describe("plugin spec opt", function()
          url = "https://github.com/foo/dep1.git",
        },
        dep2 = {
          "foo/dep2",
          _ = {
            dep = true,
          },
@ -201,13 +200,13 @@ describe("plugin spec opt", function()
    before_each(function()
      Handler.init()
    end)
    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
      it("handles dep names " .. inspect(test), function()
        local spec = Plugin.Spec.new(vim.deepcopy(test))
        assert(#spec.notifs == 0)
        Config.plugins = spec.plugins
@ -216,74 +215,31 @@ describe("plugin spec opt", function()
        for _, plugin in pairs(spec.plugins) do
          plugin.dir = nil
        end
-        assert.same({
+        assert.same(clean(spec.plugins), {
          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",
          },
-        }, clean(spec.plugins))
+        })
      end
    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
@ -340,7 +296,7 @@ describe("plugin spec opt", function()
        assert(#spec.notifs == 0)
        assert(vim.tbl_count(spec.plugins) == 1)
        Handler.resolve(spec.plugins.bar)
-        -- vim.print(spec.plugins.bar._.handlers)
+        vim.print(spec.plugins.bar._.handlers)
        local events = vim.tbl_keys(spec.plugins.bar._.handlers.event or {})
        assert(type(events) == "table")
        assert(#events == 2)
--- a/tests/handlers/keys_spec.lua
+++ b/tests/handlers/keys_spec.lua
@ -1,3 +1,4 @@
 ---@module 'luassert'
 local Keys = require("lazy.core.handler.keys")
 describe("keys", function()
--- a/tests/init.lua
+++ b/tests/init.lua
@ -0,0 +1,36 @@
 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.uv.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()
--- a/tests/manage/process_spec.lua
+++ b/tests/manage/process_spec.lua
@ -1,19 +0,0 @@
 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)
--- a/tests/manage/runner_spec.lua
+++ b/tests/manage/runner_spec.lua
@ -1,4 +1,3 @@
 local Async = require("lazy.async")
 local Runner = require("lazy.manage.runner")
 describe("runner", function()
@ -31,11 +30,11 @@ describe("runner", function()
      end,
    }
    package.loaded["lazy.manage.task.test"]["async" .. i] = {
      ---@async
      ---@param task LazyTask
      run = function(task)
-        Async.yield()
+        task:schedule(function()
          table.insert(runs, { plugin = task.plugin.name, task = task.name })
        end)
      end,
    }
  end
@ -65,7 +64,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, runs)
+    assert.equal(4, #runs)
  end)
  it("handles opts", function()
--- a/tests/manage/semver_spec.lua
+++ b/tests/manage/semver_spec.lua
@ -14,7 +14,6 @@ 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)
--- a/tests/manage/task_spec.lua
+++ b/tests/manage/task_spec.lua
@ -1,82 +1,96 @@
 --# selene:allow(incorrect_standard_library_use)
 local Async = require("lazy.async")
 local Task = require("lazy.manage.task")
 describe("task", function()
  local plugin = { name = "test", _ = {} }
-  ---@type {done?:boolean, error:string?}
+  local done = false
-  local task_result = {}
+  ---@type string?
  local error
  local opts = {
    ---@param task LazyTask
    on_done = function(task)
-      task_result = { done = true, error = task.error }
+      done = true
      error = task.error
    end,
  }
  before_each(function()
-    task_result = {}
+    done = false
    error = nil
  end)
  it("simple function", function()
    local task = Task.new(plugin, "test", function() end, opts)
-    assert(task:running())
+    assert(not task:has_started())
-    task:wait()
+    assert(not task:is_running())
-    assert(not task:running())
+    task:start()
-    assert(task_result.done)
+    assert(not task:is_running())
    assert(task:is_done())
    assert(done)
  end)
  it("detects errors", function()
    local task = Task.new(plugin, "test", function()
      error("test")
    end, opts)
-    assert(task:running())
+    assert(not task:has_started())
-    task:wait()
+    assert(not task:is_running())
-    assert(not task:running())
+    task:start()
-    assert(task_result.done)
+    assert(task:is_done())
-    assert(task_result.error)
+    assert(not task:is_running())
-    assert(task:has_errors() and task:output(vim.log.levels.ERROR):find("test"))
+    assert(done)
    assert(error)
    assert(task.error and task.error:find("test"))
  end)
-  it("async", function()
+  it("schedule", function()
-    local running = true
+    local running = false
-    ---@async
+    local task = Task.new(plugin, "test", function(task)
-    local task = Task.new(plugin, "test", function()
+      running = true
-      Async.yield()
+      task:schedule(function()
        running = false
      end)
    end, opts)
-    assert(task:running())
+    assert(not task:is_running())
    assert(not task:has_started())
    task:start()
    assert(running)
-    assert(task:running())
+    assert(#task._running == 1)
    assert(task:is_running())
    assert(not task:is_done())
    task:wait()
-    assert(not running)
+    assert(task:is_done())
-    assert(not task:running())
+    assert(not task:is_running())
-    assert(task_result.done)
+    assert(done)
-    assert(not task:has_errors())
+    assert(not task.error)
  end)
  it("spawn errors", function()
-    local task = Task.new(plugin, "spawn_errors", function(task)
+    local task = Task.new(plugin, "test", function(task)
      task:spawn("foobar")
    end, opts)
-    assert(task:running())
+    assert(not task:is_running())
-    task:wait()
+    task:start()
-    assert(not task:running())
+    assert(not task:is_running())
-    assert(task_result.done)
+    assert(done)
-    assert(task:has_errors() and task:output(vim.log.levels.ERROR):find("Failed to spawn"), task:output())
+    assert(task.error and task.error:find("Failed to spawn"))
  end)
  it("spawn", function()
    local task = Task.new(plugin, "test", function(task)
      task:spawn("echo", { args = { "foo" } })
    end, opts)
-    assert(task:running())
+    assert(not task:is_running())
-    assert(task:running())
+    assert(not task:has_started())
    task:start()
    assert(task:has_started())
    assert(task:is_running())
    task:wait()
-    assert.same(task:output(), "foo")
+    assert(task:is_done())
-    assert(task_result.done)
+    assert.same(task.output, "foo\n")
-    assert(not task:has_errors())
+    assert(done)
    assert(not task.error)
  end)
  it("spawn 2x", function()
@ -84,11 +98,12 @@ describe("task", function()
      task:spawn("echo", { args = { "foo" } })
      task:spawn("echo", { args = { "bar" } })
    end, opts)
-    assert(task:running())
+    assert(not task:is_running())
-    assert(task:running())
+    task:start()
    assert(task:is_running())
    task:wait()
-    assert(task:output() == "foo\nbar" or task:output() == "bar\nfoo", task:output())
+    assert(task.output == "foo\nbar\n" or task.output == "bar\nfoo\n", task.output)
-    assert(task_result.done)
+    assert(done)
-    assert(not task:has_errors())
+    assert(not task.error)
  end)
 end)
--- a/tests/minit.lua
+++ b/tests/minit.lua
@ -1,12 +0,0 @@
 #!/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() },
  },
 })
--- a/tests/run
+++ b/tests/run
@ -0,0 +1,3 @@
 #!/bin/sh
 nvim --headless -u tests/init.lua -c "PlenaryBustedDirectory tests {minimal_init = 'tests//init.lua', sequential = true}"
--- a/vim.toml
+++ b/vim.toml
@ -8,14 +8,42 @@ any = true
 [jit]
 any = true
-[assert]
+[[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]
 any = true
-[describe]
+[[assert.equals.args]]
-any = true
+type = "any"
 [[assert.equals.args]]
 type = "any"
 [[assert.equals.args]]
 type = "any"
 required = false
-[it]
+[[assert.same.args]]
-any = true
+type = "any"
 [[assert.same.args]]
 type = "any"
-[before_each.args]
+[[assert.truthy.args]]
-any = true
+type = "any"
 [[assert.spy.args]]
 type = "any"
 [[assert.stub.args]]
 type = "any"
		`@ -1,3 +0,0 @@`
			`#!/bin/env bash`

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

							`nvim --headless -u tests/init.lua -c "PlenaryBustedDirectory tests {minimal_init = 'tests//init.lua', sequential = true}"`