From 6ede63c170b25af745949c58915b50c9dac0897c Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:55:37 +0200
Subject: [PATCH 01/70] flake: add lz.n and lzn-auto-require

---
 flake.lock | 35 +++++++++++++++++++++++++++++++++++
 flake.nix  | 11 +++++++++++
 2 files changed, 46 insertions(+)

diff --git a/flake.lock b/flake.lock
index 3e26731..aa5763e 100644
--- a/flake.lock
+++ b/flake.lock
@@ -828,6 +828,39 @@
         "type": "github"
       }
     },
+    "plugin-lz-n": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1727574854,
+        "narHash": "sha256-qDWNleR2NHFkiEKE/+LNVOBRwEeskMC4dWTl5BTyZuE=",
+        "owner": "nvim-neorocks",
+        "repo": "lz.n",
+        "rev": "470173e3cbef763c6d1b918f3f129b67db75e1f8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nvim-neorocks",
+        "repo": "lz.n",
+        "type": "github"
+      }
+    },
+    "plugin-lzn-auto-require": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1727636949,
+        "narHash": "sha256-BAOzN+XOrFAJwHmsF8JtZ2EyjP9283FD/I2TbFqGSEw=",
+        "owner": "horriblename",
+        "repo": "lzn-auto-require",
+        "rev": "55ecd60831dac8c01d6f3dcb63a30a63a1690eb8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "horriblename",
+        "ref": "require-rewrite",
+        "repo": "lzn-auto-require",
+        "type": "github"
+      }
+    },
     "plugin-mind-nvim": {
       "flake": false,
       "locked": {
@@ -1859,6 +1892,8 @@
         "plugin-lspkind": "plugin-lspkind",
         "plugin-lspsaga": "plugin-lspsaga",
         "plugin-lualine": "plugin-lualine",
+        "plugin-lz-n": "plugin-lz-n",
+        "plugin-lzn-auto-require": "plugin-lzn-auto-require",
         "plugin-mind-nvim": "plugin-mind-nvim",
         "plugin-minimap-vim": "plugin-minimap-vim",
         "plugin-modes-nvim": "plugin-modes-nvim",
diff --git a/flake.nix b/flake.nix
index c4a1a2a..994477a 100644
--- a/flake.nix
+++ b/flake.nix
@@ -113,6 +113,17 @@
     };
 
     ## Plugins
+    # Lazy loading
+    plugin-lz-n = {
+      url = "github:nvim-neorocks/lz.n";
+      flake = false;
+    };
+
+    plugin-lzn-auto-require = {
+      url = "github:horriblename/lzn-auto-require/require-rewrite";
+      flake = false;
+    };
+
     # LSP plugins
     plugin-nvim-lspconfig = {
       url = "github:neovim/nvim-lspconfig";

From 937d0f22af142021bfa92c5e03b83d34e81a4b85 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:56:31 +0200
Subject: [PATCH 02/70] lazy: init module

---
 modules/modules.nix              |   1 +
 modules/wrapper/lazy/config.nix  |  76 ++++++++++++
 modules/wrapper/lazy/default.nix |   6 +
 modules/wrapper/lazy/lazy.nix    | 207 +++++++++++++++++++++++++++++++
 4 files changed, 290 insertions(+)
 create mode 100644 modules/wrapper/lazy/config.nix
 create mode 100644 modules/wrapper/lazy/default.nix
 create mode 100644 modules/wrapper/lazy/lazy.nix

diff --git a/modules/modules.nix b/modules/modules.nix
index 1204e43..784c413 100644
--- a/modules/modules.nix
+++ b/modules/modules.nix
@@ -50,6 +50,7 @@
       "build"
       "rc"
       "warnings"
+      "lazy"
     ];
 
     # Extra modules, such as deprecation warnings
diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
new file mode 100644
index 0000000..9ee15e7
--- /dev/null
+++ b/modules/wrapper/lazy/config.nix
@@ -0,0 +1,76 @@
+{
+  lib,
+  config,
+  ...
+}: let
+  inherit (builtins) toJSON typeOf head length tryEval filter;
+  inherit (lib.modules) mkIf;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.strings) optionalString;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.dag) entryBefore;
+  cfg = config.vim.lazy;
+
+  toLuaLznKeySpec = keySpec:
+    (removeAttrs keySpec ["key" "lua" "action"])
+    // {
+      "@1" = keySpec.key;
+      "@2" =
+        if keySpec.lua
+        then mkLuaInline keySpec.action
+        else keySpec.action;
+    };
+
+  toLuaLznSpec = spec: let
+    name =
+      if typeOf spec.package == "string"
+      then spec.package
+      else if (spec.package ? pname && (tryEval spec.package.pname).success)
+      then spec.package.pname
+      else spec.package.name;
+  in
+    (removeAttrs spec ["package" "setupModule" "setupOpts" "keys"])
+    // {
+      "@1" = name;
+      before =
+        if spec.before != null
+        then
+          mkLuaInline ''
+            function()
+              ${spec.before}
+            end
+          ''
+        else null;
+
+      after =
+        if spec.setupModule == null && spec.after == null
+        then null
+        else
+          mkLuaInline ''
+            function()
+              ${
+              optionalString (spec.setupModule != null)
+              "require(${toJSON spec.setupModule}).setup(${toLuaObject spec.setupOpts})"
+            }
+              ${optionalString (spec.after != null) spec.after}
+            end
+          '';
+
+      keys =
+        if typeOf spec.keys == "list" && length spec.keys > 0 && typeOf (head spec.keys) == "set"
+        then map toLuaLznKeySpec (filter (keySpec: keySpec.key != null) spec.keys)
+        # empty list or str or (listOf str)
+        else spec.keys;
+    };
+  lznSpecs = map toLuaLznSpec cfg.plugins;
+in {
+  config.vim = mkIf cfg.enable {
+    startPlugins = ["lz-n" "lzn-auto-require"];
+
+    optPlugins = map (plugin: plugin.package) cfg.plugins;
+
+    luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
+      require('lz.n').load(${toLuaObject lznSpecs})
+    '';
+  };
+}
diff --git a/modules/wrapper/lazy/default.nix b/modules/wrapper/lazy/default.nix
new file mode 100644
index 0000000..fa40127
--- /dev/null
+++ b/modules/wrapper/lazy/default.nix
@@ -0,0 +1,6 @@
+_: {
+  imports = [
+    ./lazy.nix
+    ./config.nix
+  ];
+}
diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
new file mode 100644
index 0000000..5f20c12
--- /dev/null
+++ b/modules/wrapper/lazy/lazy.nix
@@ -0,0 +1,207 @@
+{lib, ...}: let
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.types) enum listOf submodule nullOr str bool int attrsOf anything either oneOf;
+  inherit (lib.nvim.types) pluginType;
+  inherit (lib.nvim.config) mkBool;
+
+  lznKeysSpec = submodule {
+    options = {
+      key = mkOption {
+        type = nullOr str;
+        description = "Key to bind to. If key is null this entry is ignored.";
+      };
+
+      action = mkOption {
+        type = nullOr str;
+        default = null;
+        description = "Action to trigger.";
+      };
+      lua = mkBool false ''
+        If true, `action` is considered to be lua code.
+        Thus, it will not be wrapped in `""`.
+      '';
+
+      desc = mkOption {
+        description = "Description of the key map";
+        type = nullOr str;
+        default = null;
+      };
+
+      ft = mkOption {
+        description = "TBD";
+        type = nullOr (listOf str);
+        default = null;
+      };
+
+      mode = mkOption {
+        description = "Modes to bind in";
+        type = listOf str;
+        default = ["n" "x" "s" "o"];
+      };
+
+      silent = mkBool true "Whether this mapping should be silent. Equivalent to adding <silent> to a map.";
+      nowait = mkBool false "Whether to wait for extra input on ambiguous mappings. Equivalent to adding <nowait> to a map.";
+      script = mkBool false "Equivalent to adding <script> to a map.";
+      expr = mkBool false "Means that the action is actually an expression. Equivalent to adding <expr> to a map.";
+      unique = mkBool false "Whether to fail if the map is already defined. Equivalent to adding <unique> to a map.";
+      noremap = mkBool true "Whether to use the 'noremap' variant of the command, ignoring any custom mappings on the defined action. It is highly advised to keep this on, which is the default.";
+    };
+  };
+
+  lznPluginType = submodule {
+    options = {
+      package = mkOption {
+        type = pluginType;
+        description = "Plugin package";
+      };
+
+      setupModule = mkOption {
+        type = nullOr str;
+        description = "Lua module to run setup function on.";
+        default = null;
+      };
+
+      setupOpts = mkOption {
+        type = submodule {freeformType = attrsOf anything;};
+        description = "Options to pass to the setup function";
+        default = {};
+      };
+
+      # lz.n options
+
+      enabled = mkOption {
+        type = nullOr (either bool str);
+        description = "When false, or if the lua function returns false, this plugin will not be included in the spec";
+        default = null;
+      };
+
+      beforeAll = mkOption {
+        type = nullOr str;
+        description = "Lua code to run before any plugins are loaded. This will be wrapped in a function.";
+        default = null;
+      };
+
+      before = mkOption {
+        type = nullOr str;
+        description = "Lua code to run before plugin is loaded. This will be wrapped in a function.";
+        default = null;
+      };
+
+      after = mkOption {
+        type = nullOr str;
+        description = ''
+          Lua code to run after plugin is loaded. This will be wrapped in a function.
+
+          If {opt}`vim.plugins.*.setupModule` is provided, the setup will be ran before `after`.
+        '';
+        default = null;
+      };
+
+      event = mkOption {
+        description = "Lazy-load on event";
+        default = null;
+        type = let
+          event = submodule {
+            options = {
+              event = mkOption {
+                type = nullOr (either str (listOf str));
+                description = "Exact event name";
+                example = "BufEnter";
+              };
+              pattern = mkOption {
+                type = nullOr (either str (listOf str));
+                description = "Event pattern";
+                example = "BufEnter *.lua";
+              };
+            };
+          };
+        in
+          nullOr (oneOf [str (listOf str) event]);
+      };
+
+      cmd = mkOption {
+        description = "Lazy-load on command";
+        default = null;
+        type = nullOr (either str (listOf str));
+      };
+
+      ft = mkOption {
+        description = "Lazy-load on filetype";
+        default = null;
+        type = nullOr (either str (listOf str));
+      };
+
+      keys = mkOption {
+        description = "Lazy-load on key mapping";
+        default = null;
+        type = nullOr (oneOf [str (listOf lznKeysSpec) (listOf str)]);
+        example = ''
+          keys = [
+            {
+              mode = "n";
+              key = "<leader>s";
+              action = ":DapStepOver<cr>";
+              desc = "DAP Step Over";
+            }
+            {
+              mode = ["n", "x"];
+              key = "<leader>dc";
+              action = "function() require('dap').continue() end";
+              lua = true;
+              desc = "DAP Continue";
+            }
+          ]
+        '';
+      };
+
+      colorscheme = mkOption {
+        description = "Lazy-load on colorscheme.";
+        type = nullOr (either str (listOf str));
+        default = null;
+      };
+
+      priority = mkOption {
+        type = nullOr int;
+        description = "Only useful for stat plugins (not lazy-loaded) to force loading certain plugins first.";
+        default = null;
+      };
+
+      load = mkOption {
+        type = nullOr str;
+        default = null;
+        description = ''
+          Lua code to override the `vim.g.lz_n.load()` function for a single plugin.
+
+          This will be wrapped in a function
+        '';
+      };
+    };
+  };
+in {
+  options.vim.lazy = {
+    enable = mkEnableOption "plugin lazy-loading" // {default = true;};
+    loader = mkOption {
+      description = "Lazy loader to use";
+      type = enum ["lz.n"];
+      default = "lz.n";
+    };
+
+    plugins = mkOption {
+      default = [];
+      type = listOf lznPluginType;
+      description = "list of plugins to lazy load";
+      example = ''
+        [
+          {
+            package = "toggleterm-nvim";
+            setupModule = "toggleterm";
+            setupOpts = cfg.setupOpts;
+
+            after = "require('toggleterm').do_something()";
+            cmd = ["ToggleTerm"];
+          }
+        ]
+      '';
+    };
+  };
+}

From 3e48cea5361b0854c6a5036be7313e8214350194 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:57:03 +0200
Subject: [PATCH 03/70] lzn-auto-require: add init lua code

---
 modules/wrapper/rc/config.nix | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/modules/wrapper/rc/config.nix b/modules/wrapper/rc/config.nix
index 6f9ed1c..25fc9bc 100644
--- a/modules/wrapper/rc/config.nix
+++ b/modules/wrapper/rc/config.nix
@@ -4,8 +4,8 @@
   ...
 }: let
   inherit (builtins) map mapAttrs filter;
-  inherit (lib.attrsets) mapAttrsToList filterAttrs;
-  inherit (lib.strings) concatLines concatMapStringsSep;
+  inherit (lib.attrsets) mapAttrsToList;
+  inherit (lib.strings) concatLines concatMapStringsSep optionalString;
   inherit (lib.trivial) showWarnings;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryAfter mkLuarcSection resolveDag entryAnywhere;
@@ -55,6 +55,8 @@ in {
         pluginConfigs = entryAfter ["optionsScript"] pluginConfigs;
         extraPluginConfigs = entryAfter ["pluginConfigs"] extraPluginConfigs;
         mappings = entryAfter ["extraPluginConfigs"] keymaps;
+        # FIXME: put this somewhere less stupid
+        footer = entryAfter ["mappings"] (optionalString config.vim.lazy.enable "require('lzn-auto-require').enable()");
       };
 
       builtLuaConfigRC = let

From 96954beeceec00d0a2310bd220fc2b183233cab4 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:57:36 +0200
Subject: [PATCH 04/70] wrapper: fix opt plugin format

---
 modules/default.nix | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/modules/default.nix b/modules/default.nix
index 6a95080..6306da9 100644
--- a/modules/default.nix
+++ b/modules/default.nix
@@ -84,10 +84,7 @@
 
   # built (or "normalized") plugins that are modified
   builtStartPlugins = buildConfigPlugins vimOptions.startPlugins;
-  builtOptPlugins = map (package: {
-    plugin = package;
-    optional = true;
-  }) (buildConfigPlugins vimOptions.optPlugins);
+  builtOptPlugins = map (package: package // {optional = true;}) (buildConfigPlugins vimOptions.optPlugins);
 
   # additional Lua and Python3 packages, mapped to their respective functions
   # to conform to the format mnw expects. end user should

From 7e144707d94a0455ee733ac3515a087df89fb373 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:06 +0200
Subject: [PATCH 05/70] lib.binds: add lz.n variant of bind functions

---
 lib/binds.nix | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/lib/binds.nix b/lib/binds.nix
index 8c9e9a6..298cd30 100644
--- a/lib/binds.nix
+++ b/lib/binds.nix
@@ -67,6 +67,30 @@
       mkLuaBinding binding.value action binding.description;
 
     pushDownDefault = attr: mapAttrs (_: mkDefault) attr;
+
+    mkLznBinding = mode: key: action: desc: {
+      inherit mode desc key action;
+    };
+
+    mkLznExprBinding = mode: key: action: desc: {
+      inherit mode desc key action;
+      lua = true;
+      silent = true;
+      expr = true;
+    };
+
+    mkSetLznBinding = binding: action: {
+      inherit action;
+      key = binding.value;
+      desc = binding.description;
+    };
+
+    mkSetLuaLznBinding = binding: action: {
+      inherit action;
+      key = binding.value;
+      lua = true;
+      desc = binding.description;
+    };
   };
 in
   binds

From bc6597c36a2743dd4395b9bb4f9f3dc857c4d65d Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:21 +0200
Subject: [PATCH 06/70] telescope: lazy load

---
 modules/plugins/utility/telescope/config.nix | 114 +++++++++----------
 1 file changed, 52 insertions(+), 62 deletions(-)

diff --git a/modules/plugins/utility/telescope/config.nix b/modules/plugins/utility/telescope/config.nix
index 68af964..f50e955 100644
--- a/modules/plugins/utility/telescope/config.nix
+++ b/modules/plugins/utility/telescope/config.nix
@@ -4,11 +4,11 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.binds) pushDownDefault;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) addDescriptionsToMappings;
+  inherit (lib.strings) optionalString;
+  inherit (lib.lists) optionals;
+  inherit (lib.nvim.binds) pushDownDefault mkSetLznBinding;
 
   cfg = config.vim.telescope;
   self = import ./telescope.nix {inherit pkgs lib;};
@@ -18,45 +18,58 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = [
-        "telescope"
-        "plenary-nvim"
-      ];
+      startPlugins = ["plenary-nvim"];
 
-      maps.normal = mkMerge [
-        (mkSetBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
-        (mkSetBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
-        (mkSetBinding mappings.buffers "<cmd> Telescope buffers<CR>")
-        (mkSetBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
-        (mkSetBinding mappings.open "<cmd> Telescope<CR>")
-        (mkSetBinding mappings.resume "<cmd> Telescope resume<CR>")
+      lazy.plugins = [
+        {
+          package = "telescope";
+          setupModule = "telescope";
+          inherit (cfg) setupOpts;
+          # FIXME: how do I deal with extensions? set all as deps?
+          after = ''
+            local telescope = require("telescope")
+            ${optionalString config.vim.ui.noice.enable "telescope.load_extension('noice')"}
+            ${optionalString config.vim.notify.nvim-notify.enable "telescope.load_extension('notify')"}
+            ${optionalString config.vim.projects.project-nvim.enable "telescope.load_extension('projects')"}
+          '';
 
-        (mkSetBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
-        (mkSetBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
-        (mkSetBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
-        (mkSetBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
-        (mkSetBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
+          cmd = ["Telescope"];
 
-        (mkIf config.vim.lsp.enable (mkMerge [
-          (mkSetBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
-          (mkSetBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
+          keys =
+            [
+              (mkSetLznBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
+              (mkSetLznBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
+              (mkSetLznBinding mappings.buffers "<cmd> Telescope buffers<CR>")
+              (mkSetLznBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
+              (mkSetLznBinding mappings.open "<cmd> Telescope<CR>")
 
-          (mkSetBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
-          (mkSetBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
-          (mkSetBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
-          (mkSetBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
-          (mkSetBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
-        ]))
+              (mkSetLznBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
+              (mkSetLznBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
+              (mkSetLznBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
+              (mkSetLznBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
+              (mkSetLznBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
+            ]
+            ++ (optionals config.vim.lsp.enable [
+              (mkSetLznBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
+              (mkSetLznBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
 
-        (
-          mkIf config.vim.treesitter.enable
-          (mkSetBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
-        )
-
-        (
-          mkIf config.vim.projects.project-nvim.enable
-          (mkSetBinding mappings.findProjects "<cmd> Telescope projects<CR>")
-        )
+              (mkSetLznBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
+              (mkSetLznBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
+              (mkSetLznBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
+              (mkSetLznBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
+              (mkSetLznBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
+            ])
+            ++ (
+              optionals config.vim.treesitter.enable [
+                (mkSetLznBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
+              ]
+            )
+            ++ (
+              optionals config.vim.projects.project-nvim.enable [
+                (mkSetLznBinding mappings.findProjects "<cmd Telescope projects<CR>")
+              ]
+            );
+        }
       ];
 
       binds.whichKey.register = pushDownDefault {
@@ -66,29 +79,6 @@ in {
         "<leader>fv" = "Telescope Git";
         "<leader>fvc" = "Commits";
       };
-
-      pluginRC.telescope = entryAnywhere ''
-        local telescope = require('telescope')
-        telescope.setup(${toLuaObject cfg.setupOpts})
-
-        ${
-          if config.vim.ui.noice.enable
-          then "telescope.load_extension('noice')"
-          else ""
-        }
-
-        ${
-          if config.vim.notify.nvim-notify.enable
-          then "telescope.load_extension('notify')"
-          else ""
-        }
-
-        ${
-          if config.vim.projects.project-nvim.enable
-          then "telescope.load_extension('projects')"
-          else ""
-        }
-      '';
     };
   };
 }

From edab575b52218a59afa3a4e5961ae92328b6e19e Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:38 +0200
Subject: [PATCH 07/70] nvim-tree: lazy load

---
 modules/plugins/filetree/nvimtree/config.nix | 32 +++++++++++---------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/modules/plugins/filetree/nvimtree/config.nix b/modules/plugins/filetree/nvimtree/config.nix
index b97b1e4..66a901b 100644
--- a/modules/plugins/filetree/nvimtree/config.nix
+++ b/modules/plugins/filetree/nvimtree/config.nix
@@ -5,10 +5,9 @@
   ...
 }: let
   inherit (lib.strings) optionalString;
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkBinding;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) mkLznBinding;
   inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.binds) pushDownDefault;
 
   cfg = config.vim.filetree.nvimTree;
@@ -16,19 +15,25 @@
   inherit (self.options.vim.filetree.nvimTree) mappings;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = ["nvim-tree-lua"];
-
-    vim.maps.normal = mkMerge [
-      (mkBinding cfg.mappings.toggle ":NvimTreeToggle<cr>" mappings.toggle.description)
-      (mkBinding cfg.mappings.refresh ":NvimTreeRefresh<cr>" mappings.refresh.description)
-      (mkBinding cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
-      (mkBinding cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
-    ];
-
     vim.binds.whichKey.register = pushDownDefault {
       "<leader>t" = "+NvimTree";
     };
 
+    vim.lazy.plugins = [
+      {
+        package = "nvim-tree-lua";
+        setupModule = "nvim-tree";
+        inherit (cfg) setupOpts;
+        cmd = ["NvimTreeClipboard" "NvimTreeClose" "NvimTreeCollapse" "NvimTreeCollapseKeepBuffers" "NvimTreeFindFile" "NvimTreeFindFileToggle" "NvimTreeFocus" "NvimTreeHiTest" "NvimTreeOpen" "NvimTreeRefresh" "NvimTreeResize" "NvimTreeToggle"];
+        keys = [
+          (mkLznBinding ["n"] cfg.mappings.toggle ":NvimTreeToggle<cr>" mappings.toggle.description)
+          (mkLznBinding ["n"] cfg.mappings.refresh ":NvimTreeRefresh<cr>" mappings.refresh.description)
+          (mkLznBinding ["n"] cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
+          (mkLznBinding ["n"] cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
+        ];
+      }
+    ];
+
     vim.pluginRC.nvimtreelua = entryAnywhere ''
       ${
         optionalString cfg.setupOpts.disable_netrw ''
@@ -38,10 +43,9 @@ in {
         ''
       }
 
-      require'nvim-tree'.setup(${toLuaObject cfg.setupOpts})
-
       ${
         optionalString cfg.openOnSetup ''
+          ${optionalString config.vim.lazy.enable ''require('lz.n').trigger_load("nvim-tree-lua")''}
           -- autostart behaviour
           -- Open on startup has been deprecated
           -- see https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup

From 0608e107cdba656c22b62d36bdd832f3957975f8 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:43 +0200
Subject: [PATCH 08/70] dapui: lazy load

---
 modules/plugins/debugger/nvim-dap/config.nix | 33 +++++++++++++-------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/modules/plugins/debugger/nvim-dap/config.nix b/modules/plugins/debugger/nvim-dap/config.nix
index 072ad9a..1c80ac4 100644
--- a/modules/plugins/debugger/nvim-dap/config.nix
+++ b/modules/plugins/debugger/nvim-dap/config.nix
@@ -6,7 +6,7 @@
   inherit (lib.strings) optionalString;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.attrsets) mapAttrs;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding mkSetLuaLznBinding;
   inherit (lib.nvim.dag) entryAnywhere entryAfter;
 
   cfg = config.vim.debugger.nvim-dap;
@@ -49,24 +49,33 @@ in {
       ];
     })
     (mkIf (cfg.enable && cfg.ui.enable) {
-      vim.startPlugins = ["nvim-dap-ui" "nvim-nio"];
+      vim.startPlugins = ["nvim-nio"];
 
-      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
-          local dapui = require("dapui")
-          dapui.setup()
-        ''
-        + optionalString cfg.ui.autoStart ''
+      vim.lazy.plugins = [
+        {
+          package = "nvim-dap-ui";
+          setupModule = "dapui";
+          setupOpts = {};
+
+          keys = [
+            (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
+          ];
+        }
+      ];
+
+      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (
+        optionalString cfg.ui.autoStart ''
           dap.listeners.after.event_initialized["dapui_config"] = function()
-            dapui.open()
+            require("dapui").open()
           end
           dap.listeners.before.event_terminated["dapui_config"] = function()
-            dapui.close()
+            require("dapui").close()
           end
           dap.listeners.before.event_exited["dapui_config"] = function()
-            dapui.close()
+            require("dapui").close()
           end
-        '');
-      vim.maps.normal = mkSetLuaBinding mappings.toggleDapUI "require('dapui').toggle";
+        ''
+      );
     })
   ];
 }

From 6c92f6cec5a69a99ebbbc6feac148a67cf0734be Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:48 +0200
Subject: [PATCH 09/70] trouble: lazy load

---
 modules/plugins/lsp/trouble/config.nix  | 33 +++++++++++++------------
 modules/plugins/lsp/trouble/trouble.nix |  3 +++
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/modules/plugins/lsp/trouble/config.nix b/modules/plugins/lsp/trouble/config.nix
index dd853e3..1a7eb46 100644
--- a/modules/plugins/lsp/trouble/config.nix
+++ b/modules/plugins/lsp/trouble/config.nix
@@ -3,9 +3,8 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding pushDownDefault;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLznBinding pushDownDefault;
 
   cfg = config.vim.lsp;
 
@@ -15,15 +14,22 @@
 in {
   config = mkIf (cfg.enable && cfg.trouble.enable) {
     vim = {
-      startPlugins = ["trouble"];
+      lazy.plugins = [
+        {
+          package = "trouble";
+          setupModule = "trouble";
+          inherit (cfg.trouble) setupOpts;
 
-      maps.normal = mkMerge [
-        (mkSetBinding mappings.toggle "<cmd>TroubleToggle<CR>")
-        (mkSetBinding mappings.workspaceDiagnostics "<cmd>TroubleToggle workspace_diagnostics<CR>")
-        (mkSetBinding mappings.documentDiagnostics "<cmd>TroubleToggle document_diagnostics<CR>")
-        (mkSetBinding mappings.lspReferences "<cmd>TroubleToggle lsp_references<CR>")
-        (mkSetBinding mappings.quickfix "<cmd>TroubleToggle quickfix<CR>")
-        (mkSetBinding mappings.locList "<cmd>TroubleToggle loclist<CR>")
+          cmd = "Trouble";
+          keys = [
+            (mkSetLznBinding mappings.toggle "<cmd>TroubleToggle<CR>")
+            (mkSetLznBinding mappings.workspaceDiagnostics "<cmd>TroubleToggle workspace_diagnostics<CR>")
+            (mkSetLznBinding mappings.documentDiagnostics "<cmd>TroubleToggle document_diagnostics<CR>")
+            (mkSetLznBinding mappings.lspReferences "<cmd>TroubleToggle lsp_references<CR>")
+            (mkSetLznBinding mappings.quickfix "<cmd>TroubleToggle quickfix<CR>")
+            (mkSetLznBinding mappings.locList "<cmd>TroubleToggle loclist<CR>")
+          ];
+        }
       ];
 
       binds.whichKey.register = pushDownDefault {
@@ -31,11 +37,6 @@ in {
         "<leader>x" = "+Trouble";
         "<leader>lw" = "Workspace";
       };
-
-      pluginRC.trouble = entryAnywhere ''
-        -- Enable trouble diagnostics viewer
-        require("trouble").setup {}
-      '';
     };
   };
 }
diff --git a/modules/plugins/lsp/trouble/trouble.nix b/modules/plugins/lsp/trouble/trouble.nix
index bd16c67..04bd506 100644
--- a/modules/plugins/lsp/trouble/trouble.nix
+++ b/modules/plugins/lsp/trouble/trouble.nix
@@ -1,11 +1,14 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.lsp = {
     trouble = {
       enable = mkEnableOption "trouble diagnostics viewer";
 
+      setupOpts = mkPluginSetupOption "Trouble" {};
+
       mappings = {
         toggle = mkMappingOption "Toggle trouble [trouble]" "<leader>xx";
         workspaceDiagnostics = mkMappingOption "Workspace diagnostics [trouble]" "<leader>lwd";

From bb2b3ff225cf41c47ba66a91dba2f17d615d2eae Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:54 +0200
Subject: [PATCH 10/70] toggleterm: lazy load

---
 .../plugins/terminal/toggleterm/config.nix    | 80 +++++++++----------
 1 file changed, 37 insertions(+), 43 deletions(-)

diff --git a/modules/plugins/terminal/toggleterm/config.nix b/modules/plugins/terminal/toggleterm/config.nix
index 07851e4..b416748 100644
--- a/modules/plugins/terminal/toggleterm/config.nix
+++ b/modules/plugins/terminal/toggleterm/config.nix
@@ -4,55 +4,49 @@
   ...
 }: let
   inherit (builtins) toJSON;
-  inherit (lib.lists) optionals;
-  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.strings) optionalString;
+  inherit (lib.modules) mkIf;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.binds) mkBinding;
-  inherit (lib.nvim.dag) entryAnywhere entryAfter;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.binds) mkLznBinding;
 
   cfg = config.vim.terminal.toggleterm;
+  lazygitMapDesc = "Open lazygit [toggleterm]";
 in {
-  config = mkMerge [
-    (
-      mkIf cfg.enable {
-        vim = {
-          startPlugins = [
-            "toggleterm-nvim"
+  config = mkIf cfg.enable {
+    vim = {
+      lazy.plugins = [
+        {
+          package = "toggleterm-nvim";
+          cmd = ["ToggleTerm" "ToggleTermSendCurrentLine" "ToggleTermSendVisualLines" "ToggleTermSendVisualSelection" "ToggleTermSetName" "ToggleTermToggleAll"];
+          keys = [
+            (mkLznBinding ["n"] cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal")
+            {
+              key = cfg.lazygit.mappings.open;
+              desc = lazygitMapDesc;
+            }
           ];
 
-          maps.normal = mkBinding cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal";
+          setupModule = "toggleterm";
+          inherit (cfg) setupOpts;
+          after = optionalString cfg.lazygit.enable ''
+            local terminal = require 'toggleterm.terminal'
+            local lazygit = terminal.Terminal:new({
+              cmd = '${
+              if (cfg.lazygit.package != null)
+              then getExe cfg.lazygit.package
+              else "lazygit"
+            }',
+              direction = '${cfg.lazygit.direction}',
+              hidden = true,
+              on_open = function(term)
+                vim.cmd("startinsert!")
+              end
+            })
 
-          pluginRC.toggleterm = entryAnywhere ''
-            require("toggleterm").setup(${toLuaObject cfg.setupOpts})
+            vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
           '';
-        };
-      }
-    )
-    (
-      mkIf (cfg.enable && cfg.lazygit.enable)
-      {
-        vim.startPlugins = optionals (cfg.lazygit.package != null) [
-          cfg.lazygit.package
-        ];
-        vim.pluginRC.toggleterm-lazygit = entryAfter ["toggleterm"] ''
-          local terminal = require 'toggleterm.terminal'
-          local lazygit = terminal.Terminal:new({
-            cmd = '${
-            if (cfg.lazygit.package != null)
-            then getExe cfg.lazygit.package
-            else "lazygit"
-          }',
-            direction = '${cfg.lazygit.direction}',
-            hidden = true,
-            on_open = function(term)
-              vim.cmd("startinsert!")
-            end
-          })
-
-          vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = 'Open lazygit [toggleterm]'})
-        '';
-      }
-    )
-  ];
+        }
+      ];
+    };
+  };
 }

From 127ae0200d7f9cb81973d45b5bc4a41758294759 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:00 +0200
Subject: [PATCH 11/70] cheatsheet: lazy load

---
 .../plugins/utility/binds/cheatsheet/config.nix   | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/modules/plugins/utility/binds/cheatsheet/config.nix b/modules/plugins/utility/binds/cheatsheet/config.nix
index 2848ddc..f7bfa44 100644
--- a/modules/plugins/utility/binds/cheatsheet/config.nix
+++ b/modules/plugins/utility/binds/cheatsheet/config.nix
@@ -4,15 +4,20 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.strings) optionalString;
 
   cfg = config.vim.binds.cheatsheet;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = ["cheatsheet-nvim"];
+    vim.lazy.plugins = [
+      {
+        package = "cheatsheet-nvim";
+        setupModule = "cheatsheet";
+        setupOpts = {};
+        cmd = ["Cheatsheet" "CheatsheetEdit"];
 
-    vim.pluginRC.cheaetsheet-nvim = entryAnywhere ''
-      require('cheatsheet').setup({})
-    '';
+        before = optionalString config.vim.lazy.enable "require('lz.n').trigger_load('telescope')";
+      }
+    ];
   };
 }

From a9ce2fe101f39bb4774eb6a5d2c3b7792c29a835 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:05 +0200
Subject: [PATCH 12/70] diffview: lazy load

---
 modules/plugins/utility/diffview/config.nix   | 15 +++++++++++----
 modules/plugins/utility/diffview/diffview.nix |  2 ++
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/modules/plugins/utility/diffview/config.nix b/modules/plugins/utility/diffview/config.nix
index 681a305..5ea51d7 100644
--- a/modules/plugins/utility/diffview/config.nix
+++ b/modules/plugins/utility/diffview/config.nix
@@ -8,9 +8,16 @@
   cfg = config.vim.utility.diffview-nvim;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = [
-      "diffview-nvim"
-      "plenary-nvim"
-    ];
+    vim = {
+      startPlugins = ["plenary-nvim"];
+      lazy.plugins = [
+        {
+          package = "diffview-nvim";
+          cmd = ["DiffviewClose" "DiffviewFileHistory" "DiffviewFocusFiles" "DiffviewLog" "DiffviewOpen" "DiffviewRefresh" "DiffviewToggleFiles"];
+          setupModule = "diffview";
+          inherit (cfg) setupOpts;
+        }
+      ];
+    };
   };
 }
diff --git a/modules/plugins/utility/diffview/diffview.nix b/modules/plugins/utility/diffview/diffview.nix
index 74ddd57..793666d 100644
--- a/modules/plugins/utility/diffview/diffview.nix
+++ b/modules/plugins/utility/diffview/diffview.nix
@@ -1,7 +1,9 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.utility.diffview-nvim = {
     enable = mkEnableOption "diffview-nvim: cycle through diffs for all modified files for any git rev";
+    setupOpts = mkPluginSetupOption "Fidget" {};
   };
 }

From fb36de0aac998c7cb2d45f80e01ffc0bde63097b Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:10 +0200
Subject: [PATCH 13/70] icon-picker: lazy load

---
 .../plugins/utility/icon-picker/config.nix    | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/modules/plugins/utility/icon-picker/config.nix b/modules/plugins/utility/icon-picker/config.nix
index 405f691..13fa45e 100644
--- a/modules/plugins/utility/icon-picker/config.nix
+++ b/modules/plugins/utility/icon-picker/config.nix
@@ -4,20 +4,22 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.utility.icon-picker;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = [
-      "icon-picker-nvim"
-      "dressing-nvim"
-    ];
+    vim.startPlugins = ["dressing-nvim"];
 
-    vim.pluginRC.icon-picker = entryAnywhere ''
-      require("icon-picker").setup({
-        disable_legacy_commands = true
-      })
-    '';
+    vim.lazy.plugins = [
+      {
+        package = "icon-picker-nvim";
+        setupModule = "icon-picker";
+        setupOpts = {
+          disable_legacy_commands = true;
+        };
+
+        cmd = ["IconPickerInsert" "IconPickerNormal" "IconPickerYank"];
+      }
+    ];
   };
 }

From f7b099e6f818fc1fe2f8933060d6d9199fe8e354 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:14 +0200
Subject: [PATCH 14/70] leap: lazy load

---
 .../plugins/utility/motion/leap/config.nix    | 110 ++++++++----------
 1 file changed, 49 insertions(+), 61 deletions(-)

diff --git a/modules/plugins/utility/motion/leap/config.nix b/modules/plugins/utility/motion/leap/config.nix
index 9ede98f..9e9cf40 100644
--- a/modules/plugins/utility/motion/leap/config.nix
+++ b/modules/plugins/utility/motion/leap/config.nix
@@ -3,71 +3,59 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkBinding;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) mkLznBinding;
 
   cfg = config.vim.utility.motion.leap;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = [
-      "leap-nvim"
-      "vim-repeat"
-    ];
+    vim = {
+      startPlugins = ["vim-repeat"];
+      lazy.plugins = [
+        {
+          package = "leap-nvim";
+          keys = [
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
+          ];
 
-    vim.maps.normal = mkMerge [
-      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-    ];
-
-    vim.maps.operator = mkMerge [
-      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-      (mkBinding cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
-      (mkBinding cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
-      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-    ];
-
-    vim.maps.visualOnly = mkMerge [
-      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-      (mkBinding cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
-      (mkBinding cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
-      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-    ];
-
-    vim.pluginRC.leap-nvim = entryAnywhere ''
-      require('leap').opts = {
-        max_phase_one_targets = nil,
-        highlight_unlabeled_phase_one_targets = false,
-        max_highlighted_traversal_targets = 10,
-        case_sensitive = false,
-        equivalence_classes = { ' \t\r\n', },
-        substitute_chars = {},
-        safe_labels = {
-          "s", "f", "n", "u", "t", "/",
-          "S", "F", "N", "L", "H", "M", "U", "G", "T", "?", "Z"
-        },
-        labels = {
-          "s", "f", "n",
-          "j", "k", "l", "h", "o", "d", "w", "e", "m", "b",
-          "u", "y", "v", "r", "g", "t", "c", "x", "/", "z",
-          "S", "F", "N",
-          "J", "K", "L", "H", "O", "D", "W", "E", "M", "B",
-          "U", "Y", "V", "R", "G", "T", "C", "X", "?", "Z"
-        },
-        special_keys = {
-          repeat_search = '<enter>',
-          next_phase_one_target = '<enter>',
-          next_target = {'<enter>', ';'},
-          prev_target = {'<tab>', ','},
-          next_group = '<space>',
-          prev_group = '<tab>',
-          multi_accept = '<enter>',
-          multi_revert = '<backspace>',
-        },
-      }
-    '';
+          after = ''
+            require('leap').opts = {
+              max_phase_one_targets = nil,
+              highlight_unlabeled_phase_one_targets = false,
+              max_highlighted_traversal_targets = 10,
+              case_sensitive = false,
+              equivalence_classes = { ' \t\r\n', },
+              substitute_chars = {},
+              safe_labels = {
+                "s", "f", "n", "u", "t", "/",
+                "S", "F", "N", "L", "H", "M", "U", "G", "T", "?", "Z"
+              },
+              labels = {
+                "s", "f", "n",
+                "j", "k", "l", "h", "o", "d", "w", "e", "m", "b",
+                "u", "y", "v", "r", "g", "t", "c", "x", "/", "z",
+                "S", "F", "N",
+                "J", "K", "L", "H", "O", "D", "W", "E", "M", "B",
+                "U", "Y", "V", "R", "G", "T", "C", "X", "?", "Z"
+              },
+              special_keys = {
+                repeat_search = '<enter>',
+                next_phase_one_target = '<enter>',
+                next_target = {'<enter>', ';'},
+                prev_target = {'<tab>', ','},
+                next_group = '<space>',
+                prev_group = '<tab>',
+                multi_accept = '<enter>',
+                multi_revert = '<backspace>',
+              },
+            }
+          '';
+        }
+      ];
+    };
   };
 }

From d649939b241b96edba1154bc64151a89f9ee45e1 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:19 +0200
Subject: [PATCH 15/70] fidget: lazy load

---
 modules/plugins/visuals/fidget/config.nix | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/modules/plugins/visuals/fidget/config.nix b/modules/plugins/visuals/fidget/config.nix
index 3ae3b6b..6e81e9d 100644
--- a/modules/plugins/visuals/fidget/config.nix
+++ b/modules/plugins/visuals/fidget/config.nix
@@ -4,16 +4,17 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.visuals.fidget-nvim;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = ["fidget-nvim"];
-
-    vim.pluginRC.fidget-nvim = entryAnywhere ''
-      require'fidget'.setup(${toLuaObject cfg.setupOpts})
-    '';
+    vim.lazy.plugins = [
+      {
+        package = "fidget-nvim";
+        setupModule = "fidget";
+        event = "LspAttach";
+        inherit (cfg) setupOpts;
+      }
+    ];
   };
 }

From f3a41aa2b4ef3cc6bd76d9f678a5eec173bb4117 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 16:34:28 +0200
Subject: [PATCH 16/70] docs: add section on lazy plugins

---
 docs/manual/hacking/additional-plugins.md | 59 +++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/docs/manual/hacking/additional-plugins.md b/docs/manual/hacking/additional-plugins.md
index 7c80215..6294d6f 100644
--- a/docs/manual/hacking/additional-plugins.md
+++ b/docs/manual/hacking/additional-plugins.md
@@ -124,3 +124,62 @@ vim.your-plugin.setupOpts = {
   '';
 }
 ```
+
+## Lazy plugins {#sec-lazy-plugins}
+
+If your plugin can be lazy-loaded, you should use `vim.lazy.plugins` to add your plugin. Lazy
+plugins are managed by `lz.n`.
+
+```nix
+# in modules/.../your-plugin/config.nix
+{lib, config, ...}:
+let
+  cfg = config.vim.your-plugin;
+in {
+  vim.lazy.plugins = [
+    {
+      # instead of vim.startPlugins, use this:
+      package = "your-plugin";
+
+      # if your plugin uses the `require('your-plugin').setup{...}` pattern
+      setupModule = "your-plugin";
+      inherit (cfg) setupOpts;
+
+      # events that trigger this plugin to be loaded
+      events = ["DirChanged"];
+      cmd = ["YourPluginCommand"];
+
+      # keymaps
+      keys = [
+        # we'll cover this in detail in the keymaps section
+        {
+          key = "<leader>d";
+          mode = "n";
+          action = ":YourPluginCommand";
+        }
+      ]
+    }
+  ];
+}
+```
+
+This results in the lua code:
+```lua
+require('lz.n').load({
+  {
+    "name-of-your-plugin",
+    after = function()
+      require('your-plugin').setup({--[[ your setupOpts ]]})
+    end,
+
+    events = {"DirChanged"},
+    cmd = {"YourPluginCommand"},
+    keys = {
+      {"<leader>d", ":YourPluginCommand", mode = {"n"}},
+    },
+  }
+})
+```
+
+A full list of options can be found
+[here](https://notashelf.github.io/nvf/options.html#opt-vim.lazy.plugins

From 283ea5b92c34afb6441d02d79adea2ad2ae457c2 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 19:15:39 +0200
Subject: [PATCH 17/70] lazy: support lazy.enable=false

---
 modules/wrapper/lazy/config.nix | 50 ++++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
index 9ee15e7..d575e64 100644
--- a/modules/wrapper/lazy/config.nix
+++ b/modules/wrapper/lazy/config.nix
@@ -3,12 +3,12 @@
   config,
   ...
 }: let
-  inherit (builtins) toJSON typeOf head length tryEval filter;
-  inherit (lib.modules) mkIf;
+  inherit (builtins) toJSON typeOf head length tryEval filter concatLists concatStringsSep;
+  inherit (lib.modules) mkIf mkMerge;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.strings) optionalString;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.nvim.dag) entryBefore entryAfter;
   cfg = config.vim.lazy;
 
   toLuaLznKeySpec = keySpec:
@@ -63,14 +63,44 @@
         else spec.keys;
     };
   lznSpecs = map toLuaLznSpec cfg.plugins;
+
+  specToNotLazyConfig = spec: ''
+    do
+      ${optionalString (spec.before != null) spec.before}
+      ${optionalString (spec.setupModule != null)
+      "require(${toJSON spec.setupModule}).setup(${toLuaObject spec.setupOpts})"}
+      ${optionalString (spec.after != null) spec.after}
+    end
+  '';
+
+  specToKeymaps = spec:
+    if typeOf spec.keys == "list"
+    then map (x: removeAttrs x ["ft"]) (filter (lznKey: lznKey.action != null && lznKey.ft == null) spec.keys)
+    else if spec.keys == null || typeOf spec.keys == "string"
+    then []
+    else [spec.keys];
+
+  notLazyConfig = concatStringsSep "\n" (map specToNotLazyConfig cfg.plugins);
 in {
-  config.vim = mkIf cfg.enable {
-    startPlugins = ["lz-n" "lzn-auto-require"];
+  config.vim = mkMerge [
+    (mkIf cfg.enable {
+      startPlugins = ["lz-n" "lzn-auto-require"];
 
-    optPlugins = map (plugin: plugin.package) cfg.plugins;
+      optPlugins = map (plugin: plugin.package) cfg.plugins;
 
-    luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
-      require('lz.n').load(${toLuaObject lznSpecs})
-    '';
-  };
+      luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
+        require('lz.n').load(${toLuaObject lznSpecs})
+      '';
+    })
+    (
+      mkIf (!cfg.enable) {
+        startPlugins = map (plugin: plugin.package) cfg.plugins;
+        luaConfigPre =
+          concatStringsSep "\n"
+          (filter (x: x != null) (map (spec: spec.beforeAll) cfg.plugins));
+        luaConfigRC.unlazy = entryAfter ["pluginConfigs"] notLazyConfig;
+        keymaps = concatLists (map specToKeymaps cfg.plugins);
+      }
+    )
+  ];
 }

From 6ae18403a8de77e1cc9d305d7634471f9faad323 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 19:34:47 +0200
Subject: [PATCH 18/70] comment-nvim: lazy load

---
 .../comments/comment-nvim/comment-nvim.nix    |  8 +++
 .../plugins/comments/comment-nvim/config.nix  | 59 +++++++++----------
 2 files changed, 36 insertions(+), 31 deletions(-)

diff --git a/modules/plugins/comments/comment-nvim/comment-nvim.nix b/modules/plugins/comments/comment-nvim/comment-nvim.nix
index 61a9171..76fd813 100644
--- a/modules/plugins/comments/comment-nvim/comment-nvim.nix
+++ b/modules/plugins/comments/comment-nvim/comment-nvim.nix
@@ -1,6 +1,7 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.comments.comment-nvim = {
     enable = mkEnableOption "smart and powerful comment plugin for neovim comment-nvim";
@@ -15,5 +16,12 @@ in {
       toggleSelectedLine = mkMappingOption "Toggle selected comment" "gc";
       toggleSelectedBlock = mkMappingOption "Toggle selected block" "gb";
     };
+
+    setupOpts = mkPluginSetupOption "Comment-nvim" {
+      mappings = {
+        basic = mkEnableOption "basic mappings";
+        extra = mkEnableOption "extra mappings";
+      };
+    };
   };
 }
diff --git a/modules/plugins/comments/comment-nvim/config.nix b/modules/plugins/comments/comment-nvim/config.nix
index e70e918..4c3a955 100644
--- a/modules/plugins/comments/comment-nvim/config.nix
+++ b/modules/plugins/comments/comment-nvim/config.nix
@@ -3,9 +3,8 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkExprBinding mkBinding;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) mkLznExprBinding mkLznBinding;
 
   cfg = config.vim.comments.comment-nvim;
   self = import ./comment-nvim.nix {inherit lib;};
@@ -16,35 +15,33 @@ in {
       "comment-nvim"
     ];
 
-    vim.maps.normal = mkMerge [
-      (mkBinding cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
-      (mkBinding cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
+    vim.lazy.plugins = [
+      {
+        package = "comment-nvim";
+        setupModule = "Comment";
+        inherit (cfg) setupOpts;
+        keys = [
+          (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
+          (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
 
-      (mkExprBinding cfg.mappings.toggleCurrentLine ''
-          function()
-            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
-                    or '<Plug>(comment_toggle_linewise_count)'
-          end
-        ''
-        mappings.toggleCurrentLine.description)
-      (mkExprBinding cfg.mappings.toggleCurrentBlock ''
-          function()
-            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
-                    or '<Plug>(comment_toggle_blockwise_count)'
-          end
-        ''
-        mappings.toggleCurrentBlock.description)
+          (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentLine ''
+              function()
+                return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
+                        or '<Plug>(comment_toggle_linewise_count)'
+              end
+            ''
+            mappings.toggleCurrentLine.description)
+          (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentBlock ''
+              function()
+                return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
+                        or '<Plug>(comment_toggle_blockwise_count)'
+              end
+            ''
+            mappings.toggleCurrentBlock.description)
+          (mkLznBinding ["x"] cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
+          (mkLznBinding ["x"] cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
+        ];
+      }
     ];
-
-    vim.maps.visualOnly = mkMerge [
-      (mkBinding cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
-      (mkBinding cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
-    ];
-
-    vim.pluginRC.comment-nvim = entryAnywhere ''
-      require('Comment').setup({
-        mappings = { basic = false, extra = false, },
-      })
-    '';
   };
 }

From 4701bb15c5be93a80af92c03380297c69c8dbef1 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 20:13:39 +0200
Subject: [PATCH 19/70] surround-nvim: lazy load

---
 modules/plugins/utility/surround/config.nix | 51 +++++++++++++++------
 1 file changed, 38 insertions(+), 13 deletions(-)

diff --git a/modules/plugins/utility/surround/config.nix b/modules/plugins/utility/surround/config.nix
index 4c98c86..5752085 100644
--- a/modules/plugins/utility/surround/config.nix
+++ b/modules/plugins/utility/surround/config.nix
@@ -8,25 +8,50 @@
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.utility.surround;
+  vendoredKeybinds = {
+    insert = "<C-g>z";
+    insert_line = "<C-g>Z";
+    normal = "gz";
+    normal_cur = "gZ";
+    normal_line = "gzz";
+    normal_cur_line = "gZZ";
+    visual = "gz";
+    visual_line = "gZ";
+    delete = "gzd";
+    change = "gzr";
+    change_line = "gZR";
+  };
+  mkLznKey = mode: key: {
+    inherit key mode;
+  };
 in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = ["nvim-surround"];
       pluginRC.surround = entryAnywhere "require('nvim-surround').setup(${toLuaObject cfg.setupOpts})";
 
-      utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings {
-        insert = "<C-g>z";
-        insert_line = "<C-g>Z";
-        normal = "gz";
-        normal_cur = "gZ";
-        normal_line = "gzz";
-        normal_cur_line = "gZZ";
-        visual = "gz";
-        visual_line = "gZ";
-        delete = "gzd";
-        change = "gzr";
-        change_line = "gZR";
-      };
+      lazy.plugins = [
+        {
+          package = "nvim-surround";
+          setupModule = "nvim-surround";
+          inherit (cfg) setupOpts;
+
+          keys =
+            map (mkLznKey ["i"]) (with vendoredKeybinds; [insert insert_line])
+            ++ map (mkLznKey ["x"]) (with vendoredKeybinds; [visual visual_line])
+            ++ map (mkLznKey ["n"]) (with vendoredKeybinds; [
+              normal
+              normal_cur
+              normal_line
+              normal_cur_line
+              delete
+              change
+              change_line
+            ]);
+        }
+      ];
+
+      utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings vendoredKeybinds;
     };
   };
 }

From b7a34ad52b86b589f9b1631a13093a8487a0bfbf Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 20:51:33 +0200
Subject: [PATCH 20/70] neo-tree: lazy load

---
 modules/plugins/filetree/neo-tree/config.nix | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/modules/plugins/filetree/neo-tree/config.nix b/modules/plugins/filetree/neo-tree/config.nix
index be67df1..16cc029 100644
--- a/modules/plugins/filetree/neo-tree/config.nix
+++ b/modules/plugins/filetree/neo-tree/config.nix
@@ -4,8 +4,6 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.filetree.neo-tree;
 in {
@@ -20,11 +18,17 @@ in {
         "neo-tree-nvim"
       ];
 
-      visuals.nvimWebDevicons.enable = true;
+      lazy.plugins = [
+        {
+          package = "neo-tree-nvim";
+          setupModule = "neo-tree";
+          inherit (cfg) setupOpts;
 
-      pluginRC.neo-tree = entryAnywhere ''
-        require("neo-tree").setup(${toLuaObject cfg.setupOpts})
-      '';
+          cmd = ["Neotree"];
+        }
+      ];
+
+      visuals.nvimWebDevicons.enable = true;
     };
   };
 }

From 3b7a11cb427057682826854aaae457b30b19be27 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 22:43:06 +0200
Subject: [PATCH 21/70] fixup! lazy: init module

---
 modules/wrapper/lazy/lazy.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
index 5f20c12..9b97bb8 100644
--- a/modules/wrapper/lazy/lazy.nix
+++ b/modules/wrapper/lazy/lazy.nix
@@ -92,7 +92,7 @@
         description = ''
           Lua code to run after plugin is loaded. This will be wrapped in a function.
 
-          If {opt}`vim.plugins.*.setupModule` is provided, the setup will be ran before `after`.
+          If [](#opt-vim.lazy.plugins._.setupModule) is provided, the setup will be ran before `after`.
         '';
         default = null;
       };

From 20302afeca7ed0553ca386626b0af2ffff0dd5f1 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Wed, 9 Oct 2024 17:52:32 +0200
Subject: [PATCH 22/70] dap: appease the nix gods (fix statix lint)

---
 modules/plugins/debugger/nvim-dap/config.nix | 104 ++++++++++---------
 1 file changed, 54 insertions(+), 50 deletions(-)

diff --git a/modules/plugins/debugger/nvim-dap/config.nix b/modules/plugins/debugger/nvim-dap/config.nix
index 1c80ac4..a668959 100644
--- a/modules/plugins/debugger/nvim-dap/config.nix
+++ b/modules/plugins/debugger/nvim-dap/config.nix
@@ -16,66 +16,70 @@
 in {
   config = mkMerge [
     (mkIf cfg.enable {
-      vim.startPlugins = ["nvim-dap"];
+      vim = {
+        startPlugins = ["nvim-dap"];
 
-      vim.pluginRC =
-        {
-          # TODO customizable keymaps
-          nvim-dap = entryAnywhere ''
-            local dap = require("dap")
-            vim.fn.sign_define("DapBreakpoint", { text = "🛑", texthl = "ErrorMsg", linehl = "", numhl = "" })
-          '';
-        }
-        // mapAttrs (_: v: (entryAfter ["nvim-dap"] v)) cfg.sources;
+        pluginRC =
+          {
+            # TODO customizable keymaps
+            nvim-dap = entryAnywhere ''
+              local dap = require("dap")
+              vim.fn.sign_define("DapBreakpoint", { text = "🛑", texthl = "ErrorMsg", linehl = "", numhl = "" })
+            '';
+          }
+          // mapAttrs (_: v: (entryAfter ["nvim-dap"] v)) cfg.sources;
 
-      vim.maps.normal = mkMerge [
-        (mkSetLuaBinding mappings.continue "require('dap').continue")
-        (mkSetLuaBinding mappings.restart "require('dap').restart")
-        (mkSetLuaBinding mappings.terminate "require('dap').terminate")
-        (mkSetLuaBinding mappings.runLast "require('dap').run_last")
+        maps.normal = mkMerge [
+          (mkSetLuaBinding mappings.continue "require('dap').continue")
+          (mkSetLuaBinding mappings.restart "require('dap').restart")
+          (mkSetLuaBinding mappings.terminate "require('dap').terminate")
+          (mkSetLuaBinding mappings.runLast "require('dap').run_last")
 
-        (mkSetLuaBinding mappings.toggleRepl "require('dap').repl.toggle")
-        (mkSetLuaBinding mappings.hover "require('dap.ui.widgets').hover")
-        (mkSetLuaBinding mappings.toggleBreakpoint "require('dap').toggle_breakpoint")
+          (mkSetLuaBinding mappings.toggleRepl "require('dap').repl.toggle")
+          (mkSetLuaBinding mappings.hover "require('dap.ui.widgets').hover")
+          (mkSetLuaBinding mappings.toggleBreakpoint "require('dap').toggle_breakpoint")
 
-        (mkSetLuaBinding mappings.runToCursor "require('dap').run_to_cursor")
-        (mkSetLuaBinding mappings.stepInto "require('dap').step_into")
-        (mkSetLuaBinding mappings.stepOut "require('dap').step_out")
-        (mkSetLuaBinding mappings.stepOver "require('dap').step_over")
-        (mkSetLuaBinding mappings.stepBack "require('dap').step_back")
+          (mkSetLuaBinding mappings.runToCursor "require('dap').run_to_cursor")
+          (mkSetLuaBinding mappings.stepInto "require('dap').step_into")
+          (mkSetLuaBinding mappings.stepOut "require('dap').step_out")
+          (mkSetLuaBinding mappings.stepOver "require('dap').step_over")
+          (mkSetLuaBinding mappings.stepBack "require('dap').step_back")
 
-        (mkSetLuaBinding mappings.goUp "require('dap').up")
-        (mkSetLuaBinding mappings.goDown "require('dap').down")
-      ];
+          (mkSetLuaBinding mappings.goUp "require('dap').up")
+          (mkSetLuaBinding mappings.goDown "require('dap').down")
+        ];
+      };
     })
     (mkIf (cfg.enable && cfg.ui.enable) {
-      vim.startPlugins = ["nvim-nio"];
+      vim = {
+        startPlugins = ["nvim-nio"];
 
-      vim.lazy.plugins = [
-        {
-          package = "nvim-dap-ui";
-          setupModule = "dapui";
-          setupOpts = {};
+        lazy.plugins = [
+          {
+            package = "nvim-dap-ui";
+            setupModule = "dapui";
+            setupOpts = {};
 
-          keys = [
-            (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
-          ];
-        }
-      ];
+            keys = [
+              (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
+            ];
+          }
+        ];
 
-      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (
-        optionalString cfg.ui.autoStart ''
-          dap.listeners.after.event_initialized["dapui_config"] = function()
-            require("dapui").open()
-          end
-          dap.listeners.before.event_terminated["dapui_config"] = function()
-            require("dapui").close()
-          end
-          dap.listeners.before.event_exited["dapui_config"] = function()
-            require("dapui").close()
-          end
-        ''
-      );
+        pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (
+          optionalString cfg.ui.autoStart ''
+            dap.listeners.after.event_initialized["dapui_config"] = function()
+              require("dapui").open()
+            end
+            dap.listeners.before.event_terminated["dapui_config"] = function()
+              require("dapui").close()
+            end
+            dap.listeners.before.event_exited["dapui_config"] = function()
+              require("dapui").close()
+            end
+          ''
+        );
+      };
     })
   ];
 }

From 5cc76714b706c8d59a6349358fcfc85d89d3b677 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Fri, 11 Oct 2024 00:04:55 +0200
Subject: [PATCH 23/70] flake.lock: fix merge mistake

---
 flake.lock | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/flake.lock b/flake.lock
index 04ec351..cd091c5 100644
--- a/flake.lock
+++ b/flake.lock
@@ -844,6 +844,22 @@
         "type": "github"
       }
     },
+    "plugin-luasnip": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1726165831,
+        "narHash": "sha256-nkaa1NGOI28Et2QitQB+Spv+J42QVdHE1oywteLcJJw=",
+        "owner": "L3MON4D3",
+        "repo": "LuaSnip",
+        "rev": "e808bee352d1a6fcf902ca1a71cee76e60e24071",
+        "type": "github"
+      },
+      "original": {
+        "owner": "L3MON4D3",
+        "repo": "LuaSnip",
+        "type": "github"
+      }
+    },
     "plugin-lz-n": {
       "flake": false,
       "locked": {
@@ -874,19 +890,6 @@
         "owner": "horriblename",
         "ref": "require-rewrite",
         "repo": "lzn-auto-require",
-    "plugin-luasnip": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1726165831,
-        "narHash": "sha256-nkaa1NGOI28Et2QitQB+Spv+J42QVdHE1oywteLcJJw=",
-        "owner": "L3MON4D3",
-        "repo": "LuaSnip",
-        "rev": "e808bee352d1a6fcf902ca1a71cee76e60e24071",
-        "type": "github"
-      },
-      "original": {
-        "owner": "L3MON4D3",
-        "repo": "LuaSnip",
         "type": "github"
       }
     },
@@ -1906,9 +1909,9 @@
         "plugin-lspkind": "plugin-lspkind",
         "plugin-lspsaga": "plugin-lspsaga",
         "plugin-lualine": "plugin-lualine",
+        "plugin-luasnip": "plugin-luasnip",
         "plugin-lz-n": "plugin-lz-n",
         "plugin-lzn-auto-require": "plugin-lzn-auto-require",
-        "plugin-luasnip": "plugin-luasnip",
         "plugin-mind-nvim": "plugin-mind-nvim",
         "plugin-minimap-vim": "plugin-minimap-vim",
         "plugin-modes-nvim": "plugin-modes-nvim",

From 72da674a2bca6c517de03a7cf0b6002f3a332622 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Fri, 11 Oct 2024 00:07:03 +0200
Subject: [PATCH 24/70] doc: update release note

---
 docs/release-notes/rl-0.7.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/release-notes/rl-0.7.md b/docs/release-notes/rl-0.7.md
index 673fcff..de6c795 100644
--- a/docs/release-notes/rl-0.7.md
+++ b/docs/release-notes/rl-0.7.md
@@ -102,6 +102,10 @@ everyone.
   recommended to go through rustacean.nvim's README to take a closer look at its
   features and usage
 
+- Add [lz.n] support and lazy-load some builtin plugins.
+
+[lz.n]: https://github.com/mrcjkb/rustaceanvim
+
 [jacekpoz](https://jacekpoz.pl):
 
 [ocaml-lsp]: https://github.com/ocaml/ocaml-lsp

From 03c922a3bccecde9f0a7f46b1611ef5ef17f4e11 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 14 Oct 2024 22:04:16 +0200
Subject: [PATCH 25/70] fixup! doc: update release note

---
 docs/release-notes/rl-0.7.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/release-notes/rl-0.7.md b/docs/release-notes/rl-0.7.md
index de6c795..61f382b 100644
--- a/docs/release-notes/rl-0.7.md
+++ b/docs/release-notes/rl-0.7.md
@@ -104,7 +104,7 @@ everyone.
 
 - Add [lz.n] support and lazy-load some builtin plugins.
 
-[lz.n]: https://github.com/mrcjkb/rustaceanvim
+[lz.n]: https://github.com/mrcjkb/lz.n
 
 [jacekpoz](https://jacekpoz.pl):
 

From d76d673dd4ee1d1419013f5e51b4357842333d89 Mon Sep 17 00:00:00 2001
From: Pei Yang Ching <59727193+horriblename@users.noreply.github.com>
Date: Wed, 16 Oct 2024 01:27:10 +0200
Subject: [PATCH 26/70] neo-tree: fix duplicate neo-tree install

---
 modules/plugins/filetree/neo-tree/config.nix | 2 --
 1 file changed, 2 deletions(-)

diff --git a/modules/plugins/filetree/neo-tree/config.nix b/modules/plugins/filetree/neo-tree/config.nix
index 16cc029..c2d6ea6 100644
--- a/modules/plugins/filetree/neo-tree/config.nix
+++ b/modules/plugins/filetree/neo-tree/config.nix
@@ -14,8 +14,6 @@ in {
         "plenary-nvim" # commons library
         "image-nvim" # optional for image previews
         "nui-nvim" # ui library
-        # neotree
-        "neo-tree-nvim"
       ];
 
       lazy.plugins = [

From 854fd340e3e62bff24589321d416f40763280407 Mon Sep 17 00:00:00 2001
From: Pei Yang Ching <59727193+horriblename@users.noreply.github.com>
Date: Thu, 17 Oct 2024 16:53:36 +0200
Subject: [PATCH 27/70] lazy: use attrsOf for lazy.plugins

---
 modules/wrapper/lazy/config.nix | 26 ++++++++++----------------
 modules/wrapper/lazy/lazy.nix   | 22 ++++++++++++++++------
 2 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
index d575e64..08298bd 100644
--- a/modules/wrapper/lazy/config.nix
+++ b/modules/wrapper/lazy/config.nix
@@ -4,6 +4,7 @@
   ...
 }: let
   inherit (builtins) toJSON typeOf head length tryEval filter concatLists concatStringsSep;
+  inherit (lib.attrsets) mapAttrsToList;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.strings) optionalString;
@@ -21,14 +22,7 @@
         else keySpec.action;
     };
 
-  toLuaLznSpec = spec: let
-    name =
-      if typeOf spec.package == "string"
-      then spec.package
-      else if (spec.package ? pname && (tryEval spec.package.pname).success)
-      then spec.package.pname
-      else spec.package.name;
-  in
+  toLuaLznSpec = name: spec:
     (removeAttrs spec ["package" "setupModule" "setupOpts" "keys"])
     // {
       "@1" = name;
@@ -62,9 +56,9 @@
         # empty list or str or (listOf str)
         else spec.keys;
     };
-  lznSpecs = map toLuaLznSpec cfg.plugins;
+  lznSpecs = mapAttrsToList toLuaLznSpec cfg.plugins;
 
-  specToNotLazyConfig = spec: ''
+  specToNotLazyConfig = _: spec: ''
     do
       ${optionalString (spec.before != null) spec.before}
       ${optionalString (spec.setupModule != null)
@@ -73,20 +67,20 @@
     end
   '';
 
-  specToKeymaps = spec:
+  specToKeymaps = _: spec:
     if typeOf spec.keys == "list"
     then map (x: removeAttrs x ["ft"]) (filter (lznKey: lznKey.action != null && lznKey.ft == null) spec.keys)
     else if spec.keys == null || typeOf spec.keys == "string"
     then []
     else [spec.keys];
 
-  notLazyConfig = concatStringsSep "\n" (map specToNotLazyConfig cfg.plugins);
+  notLazyConfig = concatStringsSep "\n" (mapAttrsToList specToNotLazyConfig cfg.plugins);
 in {
   config.vim = mkMerge [
     (mkIf cfg.enable {
       startPlugins = ["lz-n" "lzn-auto-require"];
 
-      optPlugins = map (plugin: plugin.package) cfg.plugins;
+      optPlugins = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
 
       luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
         require('lz.n').load(${toLuaObject lznSpecs})
@@ -94,12 +88,12 @@ in {
     })
     (
       mkIf (!cfg.enable) {
-        startPlugins = map (plugin: plugin.package) cfg.plugins;
+        startPlugins = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
         luaConfigPre =
           concatStringsSep "\n"
-          (filter (x: x != null) (map (spec: spec.beforeAll) cfg.plugins));
+          (filter (x: x != null) (mapAttrsToList (_: spec: spec.beforeAll) cfg.plugins));
         luaConfigRC.unlazy = entryAfter ["pluginConfigs"] notLazyConfig;
-        keymaps = concatLists (map specToKeymaps cfg.plugins);
+        keymaps = concatLists (mapAttrsToList specToKeymaps cfg.plugins);
       }
     )
   ];
diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
index 9b97bb8..622d07f 100644
--- a/modules/wrapper/lazy/lazy.nix
+++ b/modules/wrapper/lazy/lazy.nix
@@ -188,19 +188,29 @@ in {
 
     plugins = mkOption {
       default = [];
-      type = listOf lznPluginType;
-      description = "list of plugins to lazy load";
+      type = attrsOf lznPluginType;
+      description = ''
+        Plugins to lazy load.
+
+        The attribute key is used as the plugin name: for the default `vim.g.lz_n.load`
+        function this should be either the `package.pname` or `package.name`.
+      '';
       example = ''
-        [
-          {
+        {
+          toggleterm-nvim = {
             package = "toggleterm-nvim";
             setupModule = "toggleterm";
             setupOpts = cfg.setupOpts;
 
             after = "require('toggleterm').do_something()";
             cmd = ["ToggleTerm"];
-          }
-        ]
+          };
+
+          $${pkgs.vimPlugins.vim-bbye.pname} = {
+            package = pkgs.vimPlugins.vim-bbye;
+            cmd = ["Bdelete" "Bwipeout"];
+          };
+        }
       '';
     };
   };

From d49e46ab16ccf88e829a352e56069934b6494871 Mon Sep 17 00:00:00 2001
From: Pei Yang Ching <59727193+horriblename@users.noreply.github.com>
Date: Thu, 17 Oct 2024 17:17:18 +0200
Subject: [PATCH 28/70] treewide: update lazy.plugins syntax

---
 .../plugins/comments/comment-nvim/config.nix  | 52 +++++-----
 modules/plugins/debugger/nvim-dap/config.nix  | 18 ++--
 modules/plugins/filetree/neo-tree/config.nix  | 14 ++-
 modules/plugins/filetree/nvimtree/config.nix  | 98 +++++++++----------
 modules/plugins/lsp/trouble/config.nix        | 30 +++---
 .../plugins/terminal/toggleterm/config.nix    | 60 ++++++------
 .../utility/binds/cheatsheet/config.nix       | 16 ++-
 modules/plugins/utility/diffview/config.nix   | 14 ++-
 .../plugins/utility/icon-picker/config.nix    | 18 ++--
 .../plugins/utility/motion/leap/config.nix    | 86 ++++++++--------
 modules/plugins/utility/surround/config.nix   | 36 ++++---
 modules/plugins/utility/telescope/config.nix  | 92 +++++++++--------
 modules/plugins/visuals/fidget/config.nix     | 14 ++-
 13 files changed, 262 insertions(+), 286 deletions(-)

diff --git a/modules/plugins/comments/comment-nvim/config.nix b/modules/plugins/comments/comment-nvim/config.nix
index 4c3a955..fdb87e8 100644
--- a/modules/plugins/comments/comment-nvim/config.nix
+++ b/modules/plugins/comments/comment-nvim/config.nix
@@ -15,33 +15,31 @@ in {
       "comment-nvim"
     ];
 
-    vim.lazy.plugins = [
-      {
-        package = "comment-nvim";
-        setupModule = "Comment";
-        inherit (cfg) setupOpts;
-        keys = [
-          (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
-          (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
+    vim.lazy.plugins.comment-nvim = {
+      package = "comment-nvim";
+      setupModule = "Comment";
+      inherit (cfg) setupOpts;
+      keys = [
+        (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
+        (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
 
-          (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentLine ''
-              function()
-                return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
-                        or '<Plug>(comment_toggle_linewise_count)'
-              end
-            ''
-            mappings.toggleCurrentLine.description)
-          (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentBlock ''
-              function()
-                return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
-                        or '<Plug>(comment_toggle_blockwise_count)'
-              end
-            ''
-            mappings.toggleCurrentBlock.description)
-          (mkLznBinding ["x"] cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
-          (mkLznBinding ["x"] cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
-        ];
-      }
-    ];
+        (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentLine ''
+            function()
+              return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
+                      or '<Plug>(comment_toggle_linewise_count)'
+            end
+          ''
+          mappings.toggleCurrentLine.description)
+        (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentBlock ''
+            function()
+              return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
+                      or '<Plug>(comment_toggle_blockwise_count)'
+            end
+          ''
+          mappings.toggleCurrentBlock.description)
+        (mkLznBinding ["x"] cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
+        (mkLznBinding ["x"] cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
+      ];
+    };
   };
 }
diff --git a/modules/plugins/debugger/nvim-dap/config.nix b/modules/plugins/debugger/nvim-dap/config.nix
index a668959..78e86a8 100644
--- a/modules/plugins/debugger/nvim-dap/config.nix
+++ b/modules/plugins/debugger/nvim-dap/config.nix
@@ -54,17 +54,15 @@ in {
       vim = {
         startPlugins = ["nvim-nio"];
 
-        lazy.plugins = [
-          {
-            package = "nvim-dap-ui";
-            setupModule = "dapui";
-            setupOpts = {};
+        lazy.plugins.nvim-dap-ui = {
+          package = "nvim-dap-ui";
+          setupModule = "dapui";
+          setupOpts = {};
 
-            keys = [
-              (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
-            ];
-          }
-        ];
+          keys = [
+            (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
+          ];
+        };
 
         pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (
           optionalString cfg.ui.autoStart ''
diff --git a/modules/plugins/filetree/neo-tree/config.nix b/modules/plugins/filetree/neo-tree/config.nix
index c2d6ea6..13da035 100644
--- a/modules/plugins/filetree/neo-tree/config.nix
+++ b/modules/plugins/filetree/neo-tree/config.nix
@@ -16,15 +16,13 @@ in {
         "nui-nvim" # ui library
       ];
 
-      lazy.plugins = [
-        {
-          package = "neo-tree-nvim";
-          setupModule = "neo-tree";
-          inherit (cfg) setupOpts;
+      lazy.plugins.neo-tree-nvim = {
+        package = "neo-tree-nvim";
+        setupModule = "neo-tree";
+        inherit (cfg) setupOpts;
 
-          cmd = ["Neotree"];
-        }
-      ];
+        cmd = ["Neotree"];
+      };
 
       visuals.nvimWebDevicons.enable = true;
     };
diff --git a/modules/plugins/filetree/nvimtree/config.nix b/modules/plugins/filetree/nvimtree/config.nix
index 66a901b..30cc680 100644
--- a/modules/plugins/filetree/nvimtree/config.nix
+++ b/modules/plugins/filetree/nvimtree/config.nix
@@ -15,12 +15,12 @@
   inherit (self.options.vim.filetree.nvimTree) mappings;
 in {
   config = mkIf cfg.enable {
-    vim.binds.whichKey.register = pushDownDefault {
-      "<leader>t" = "+NvimTree";
-    };
+    vim = {
+      binds.whichKey.register = pushDownDefault {
+        "<leader>t" = "+NvimTree";
+      };
 
-    vim.lazy.plugins = [
-      {
+      lazy.plugins.nvim-tree-lua = {
         package = "nvim-tree-lua";
         setupModule = "nvim-tree";
         inherit (cfg) setupOpts;
@@ -31,58 +31,58 @@ in {
           (mkLznBinding ["n"] cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
           (mkLznBinding ["n"] cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
         ];
-      }
-    ];
+      };
 
-    vim.pluginRC.nvimtreelua = entryAnywhere ''
-      ${
-        optionalString cfg.setupOpts.disable_netrw ''
-          -- disable netrew completely
-          vim.g.loaded_netrw = 1
-          vim.g.loaded_netrwPlugin = 1
-        ''
-      }
+      pluginRC.nvimtreelua = entryAnywhere ''
+        ${
+          optionalString cfg.setupOpts.disable_netrw ''
+            -- disable netrew completely
+            vim.g.loaded_netrw = 1
+            vim.g.loaded_netrwPlugin = 1
+          ''
+        }
 
-      ${
-        optionalString cfg.openOnSetup ''
-          ${optionalString config.vim.lazy.enable ''require('lz.n').trigger_load("nvim-tree-lua")''}
-          -- autostart behaviour
-          -- Open on startup has been deprecated
-          -- see https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup
+        ${
+          optionalString cfg.openOnSetup ''
+            ${optionalString config.vim.lazy.enable ''require('lz.n').trigger_load("nvim-tree-lua")''}
+            -- autostart behaviour
+            -- Open on startup has been deprecated
+            -- see https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup
 
-          -- use a nix eval to dynamically insert the open on startup function
-          local function open_nvim_tree(data)
-            local IGNORED_FT = {
-              "markdown",
-            }
+            -- use a nix eval to dynamically insert the open on startup function
+            local function open_nvim_tree(data)
+              local IGNORED_FT = {
+                "markdown",
+              }
 
-            -- buffer is a real file on the disk
-            local real_file = vim.fn.filereadable(data.file) == 1
+              -- buffer is a real file on the disk
+              local real_file = vim.fn.filereadable(data.file) == 1
 
-            -- buffer is a [No Name]
-              local no_name = data.file == "" and vim.bo[data.buf].buftype == ""
+              -- buffer is a [No Name]
+                local no_name = data.file == "" and vim.bo[data.buf].buftype == ""
 
-            -- &ft
-            local filetype = vim.bo[data.buf].ft
+              -- &ft
+              local filetype = vim.bo[data.buf].ft
 
-            -- only files please
-            if not real_file and not no_name then
-              return
+              -- only files please
+              if not real_file and not no_name then
+                return
+              end
+
+              -- skip ignored filetypes
+              if vim.tbl_contains(IGNORED_FT, filetype) then
+                return
+              end
+
+              -- open the tree but don't focus it
+              require("nvim-tree.api").tree.toggle({ focus = false })
             end
 
-            -- skip ignored filetypes
-            if vim.tbl_contains(IGNORED_FT, filetype) then
-              return
-            end
-
-            -- open the tree but don't focus it
-            require("nvim-tree.api").tree.toggle({ focus = false })
-          end
-
-          -- function to automatically open the tree on VimEnter
-          vim.api.nvim_create_autocmd({ "VimEnter" }, { callback = open_nvim_tree })
-        ''
-      }
-    '';
+            -- function to automatically open the tree on VimEnter
+            vim.api.nvim_create_autocmd({ "VimEnter" }, { callback = open_nvim_tree })
+          ''
+        }
+      '';
+    };
   };
 }
diff --git a/modules/plugins/lsp/trouble/config.nix b/modules/plugins/lsp/trouble/config.nix
index 1a7eb46..e4b966a 100644
--- a/modules/plugins/lsp/trouble/config.nix
+++ b/modules/plugins/lsp/trouble/config.nix
@@ -14,23 +14,21 @@
 in {
   config = mkIf (cfg.enable && cfg.trouble.enable) {
     vim = {
-      lazy.plugins = [
-        {
-          package = "trouble";
-          setupModule = "trouble";
-          inherit (cfg.trouble) setupOpts;
+      lazy.plugins.trouble = {
+        package = "trouble";
+        setupModule = "trouble";
+        inherit (cfg.trouble) setupOpts;
 
-          cmd = "Trouble";
-          keys = [
-            (mkSetLznBinding mappings.toggle "<cmd>TroubleToggle<CR>")
-            (mkSetLznBinding mappings.workspaceDiagnostics "<cmd>TroubleToggle workspace_diagnostics<CR>")
-            (mkSetLznBinding mappings.documentDiagnostics "<cmd>TroubleToggle document_diagnostics<CR>")
-            (mkSetLznBinding mappings.lspReferences "<cmd>TroubleToggle lsp_references<CR>")
-            (mkSetLznBinding mappings.quickfix "<cmd>TroubleToggle quickfix<CR>")
-            (mkSetLznBinding mappings.locList "<cmd>TroubleToggle loclist<CR>")
-          ];
-        }
-      ];
+        cmd = "Trouble";
+        keys = [
+          (mkSetLznBinding mappings.toggle "<cmd>TroubleToggle<CR>")
+          (mkSetLznBinding mappings.workspaceDiagnostics "<cmd>TroubleToggle workspace_diagnostics<CR>")
+          (mkSetLznBinding mappings.documentDiagnostics "<cmd>TroubleToggle document_diagnostics<CR>")
+          (mkSetLznBinding mappings.lspReferences "<cmd>TroubleToggle lsp_references<CR>")
+          (mkSetLznBinding mappings.quickfix "<cmd>TroubleToggle quickfix<CR>")
+          (mkSetLznBinding mappings.locList "<cmd>TroubleToggle loclist<CR>")
+        ];
+      };
 
       binds.whichKey.register = pushDownDefault {
         "<leader>l" = "Trouble";
diff --git a/modules/plugins/terminal/toggleterm/config.nix b/modules/plugins/terminal/toggleterm/config.nix
index b416748..d96e480 100644
--- a/modules/plugins/terminal/toggleterm/config.nix
+++ b/modules/plugins/terminal/toggleterm/config.nix
@@ -14,39 +14,37 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      lazy.plugins = [
-        {
-          package = "toggleterm-nvim";
-          cmd = ["ToggleTerm" "ToggleTermSendCurrentLine" "ToggleTermSendVisualLines" "ToggleTermSendVisualSelection" "ToggleTermSetName" "ToggleTermToggleAll"];
-          keys = [
-            (mkLznBinding ["n"] cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal")
-            {
-              key = cfg.lazygit.mappings.open;
-              desc = lazygitMapDesc;
-            }
-          ];
+      lazy.plugins.toggleterm-nvim = {
+        package = "toggleterm-nvim";
+        cmd = ["ToggleTerm" "ToggleTermSendCurrentLine" "ToggleTermSendVisualLines" "ToggleTermSendVisualSelection" "ToggleTermSetName" "ToggleTermToggleAll"];
+        keys = [
+          (mkLznBinding ["n"] cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal")
+          {
+            key = cfg.lazygit.mappings.open;
+            desc = lazygitMapDesc;
+          }
+        ];
 
-          setupModule = "toggleterm";
-          inherit (cfg) setupOpts;
-          after = optionalString cfg.lazygit.enable ''
-            local terminal = require 'toggleterm.terminal'
-            local lazygit = terminal.Terminal:new({
-              cmd = '${
-              if (cfg.lazygit.package != null)
-              then getExe cfg.lazygit.package
-              else "lazygit"
-            }',
-              direction = '${cfg.lazygit.direction}',
-              hidden = true,
-              on_open = function(term)
-                vim.cmd("startinsert!")
-              end
-            })
+        setupModule = "toggleterm";
+        inherit (cfg) setupOpts;
+        after = optionalString cfg.lazygit.enable ''
+          local terminal = require 'toggleterm.terminal'
+          local lazygit = terminal.Terminal:new({
+            cmd = '${
+            if (cfg.lazygit.package != null)
+            then getExe cfg.lazygit.package
+            else "lazygit"
+          }',
+            direction = '${cfg.lazygit.direction}',
+            hidden = true,
+            on_open = function(term)
+              vim.cmd("startinsert!")
+            end
+          })
 
-            vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
-          '';
-        }
-      ];
+          vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
+        '';
+      };
     };
   };
 }
diff --git a/modules/plugins/utility/binds/cheatsheet/config.nix b/modules/plugins/utility/binds/cheatsheet/config.nix
index f7bfa44..2fb3e25 100644
--- a/modules/plugins/utility/binds/cheatsheet/config.nix
+++ b/modules/plugins/utility/binds/cheatsheet/config.nix
@@ -9,15 +9,13 @@
   cfg = config.vim.binds.cheatsheet;
 in {
   config = mkIf cfg.enable {
-    vim.lazy.plugins = [
-      {
-        package = "cheatsheet-nvim";
-        setupModule = "cheatsheet";
-        setupOpts = {};
-        cmd = ["Cheatsheet" "CheatsheetEdit"];
+    vim.lazy.plugins.cheatsheet-nvim = {
+      package = "cheatsheet-nvim";
+      setupModule = "cheatsheet";
+      setupOpts = {};
+      cmd = ["Cheatsheet" "CheatsheetEdit"];
 
-        before = optionalString config.vim.lazy.enable "require('lz.n').trigger_load('telescope')";
-      }
-    ];
+      before = optionalString config.vim.lazy.enable "require('lz.n').trigger_load('telescope')";
+    };
   };
 }
diff --git a/modules/plugins/utility/diffview/config.nix b/modules/plugins/utility/diffview/config.nix
index 5ea51d7..a6458ed 100644
--- a/modules/plugins/utility/diffview/config.nix
+++ b/modules/plugins/utility/diffview/config.nix
@@ -10,14 +10,12 @@ in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = ["plenary-nvim"];
-      lazy.plugins = [
-        {
-          package = "diffview-nvim";
-          cmd = ["DiffviewClose" "DiffviewFileHistory" "DiffviewFocusFiles" "DiffviewLog" "DiffviewOpen" "DiffviewRefresh" "DiffviewToggleFiles"];
-          setupModule = "diffview";
-          inherit (cfg) setupOpts;
-        }
-      ];
+      lazy.plugins.diffview-nvim = {
+        package = "diffview-nvim";
+        cmd = ["DiffviewClose" "DiffviewFileHistory" "DiffviewFocusFiles" "DiffviewLog" "DiffviewOpen" "DiffviewRefresh" "DiffviewToggleFiles"];
+        setupModule = "diffview";
+        inherit (cfg) setupOpts;
+      };
     };
   };
 }
diff --git a/modules/plugins/utility/icon-picker/config.nix b/modules/plugins/utility/icon-picker/config.nix
index 13fa45e..99e4304 100644
--- a/modules/plugins/utility/icon-picker/config.nix
+++ b/modules/plugins/utility/icon-picker/config.nix
@@ -10,16 +10,14 @@ in {
   config = mkIf cfg.enable {
     vim.startPlugins = ["dressing-nvim"];
 
-    vim.lazy.plugins = [
-      {
-        package = "icon-picker-nvim";
-        setupModule = "icon-picker";
-        setupOpts = {
-          disable_legacy_commands = true;
-        };
+    vim.lazy.plugins.icon-picker-nvim = {
+      package = "icon-picker-nvim";
+      setupModule = "icon-picker";
+      setupOpts = {
+        disable_legacy_commands = true;
+      };
 
-        cmd = ["IconPickerInsert" "IconPickerNormal" "IconPickerYank"];
-      }
-    ];
+      cmd = ["IconPickerInsert" "IconPickerNormal" "IconPickerYank"];
+    };
   };
 }
diff --git a/modules/plugins/utility/motion/leap/config.nix b/modules/plugins/utility/motion/leap/config.nix
index 9e9cf40..c05cafc 100644
--- a/modules/plugins/utility/motion/leap/config.nix
+++ b/modules/plugins/utility/motion/leap/config.nix
@@ -11,51 +11,49 @@ in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = ["vim-repeat"];
-      lazy.plugins = [
-        {
-          package = "leap-nvim";
-          keys = [
-            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
-            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
-            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-          ];
+      lazy.plugins.leap-nvim = {
+        package = "leap-nvim";
+        keys = [
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
+        ];
 
-          after = ''
-            require('leap').opts = {
-              max_phase_one_targets = nil,
-              highlight_unlabeled_phase_one_targets = false,
-              max_highlighted_traversal_targets = 10,
-              case_sensitive = false,
-              equivalence_classes = { ' \t\r\n', },
-              substitute_chars = {},
-              safe_labels = {
-                "s", "f", "n", "u", "t", "/",
-                "S", "F", "N", "L", "H", "M", "U", "G", "T", "?", "Z"
-              },
-              labels = {
-                "s", "f", "n",
-                "j", "k", "l", "h", "o", "d", "w", "e", "m", "b",
-                "u", "y", "v", "r", "g", "t", "c", "x", "/", "z",
-                "S", "F", "N",
-                "J", "K", "L", "H", "O", "D", "W", "E", "M", "B",
-                "U", "Y", "V", "R", "G", "T", "C", "X", "?", "Z"
-              },
-              special_keys = {
-                repeat_search = '<enter>',
-                next_phase_one_target = '<enter>',
-                next_target = {'<enter>', ';'},
-                prev_target = {'<tab>', ','},
-                next_group = '<space>',
-                prev_group = '<tab>',
-                multi_accept = '<enter>',
-                multi_revert = '<backspace>',
-              },
-            }
-          '';
-        }
-      ];
+        after = ''
+          require('leap').opts = {
+            max_phase_one_targets = nil,
+            highlight_unlabeled_phase_one_targets = false,
+            max_highlighted_traversal_targets = 10,
+            case_sensitive = false,
+            equivalence_classes = { ' \t\r\n', },
+            substitute_chars = {},
+            safe_labels = {
+              "s", "f", "n", "u", "t", "/",
+              "S", "F", "N", "L", "H", "M", "U", "G", "T", "?", "Z"
+            },
+            labels = {
+              "s", "f", "n",
+              "j", "k", "l", "h", "o", "d", "w", "e", "m", "b",
+              "u", "y", "v", "r", "g", "t", "c", "x", "/", "z",
+              "S", "F", "N",
+              "J", "K", "L", "H", "O", "D", "W", "E", "M", "B",
+              "U", "Y", "V", "R", "G", "T", "C", "X", "?", "Z"
+            },
+            special_keys = {
+              repeat_search = '<enter>',
+              next_phase_one_target = '<enter>',
+              next_target = {'<enter>', ';'},
+              prev_target = {'<tab>', ','},
+              next_group = '<space>',
+              prev_group = '<tab>',
+              multi_accept = '<enter>',
+              multi_revert = '<backspace>',
+            },
+          }
+        '';
+      };
     };
   };
 }
diff --git a/modules/plugins/utility/surround/config.nix b/modules/plugins/utility/surround/config.nix
index 5752085..4ce15ca 100644
--- a/modules/plugins/utility/surround/config.nix
+++ b/modules/plugins/utility/surround/config.nix
@@ -30,26 +30,24 @@ in {
       startPlugins = ["nvim-surround"];
       pluginRC.surround = entryAnywhere "require('nvim-surround').setup(${toLuaObject cfg.setupOpts})";
 
-      lazy.plugins = [
-        {
-          package = "nvim-surround";
-          setupModule = "nvim-surround";
-          inherit (cfg) setupOpts;
+      lazy.plugins.nvim-surround = {
+        package = "nvim-surround";
+        setupModule = "nvim-surround";
+        inherit (cfg) setupOpts;
 
-          keys =
-            map (mkLznKey ["i"]) (with vendoredKeybinds; [insert insert_line])
-            ++ map (mkLznKey ["x"]) (with vendoredKeybinds; [visual visual_line])
-            ++ map (mkLznKey ["n"]) (with vendoredKeybinds; [
-              normal
-              normal_cur
-              normal_line
-              normal_cur_line
-              delete
-              change
-              change_line
-            ]);
-        }
-      ];
+        keys =
+          map (mkLznKey ["i"]) (with vendoredKeybinds; [insert insert_line])
+          ++ map (mkLznKey ["x"]) (with vendoredKeybinds; [visual visual_line])
+          ++ map (mkLznKey ["n"]) (with vendoredKeybinds; [
+            normal
+            normal_cur
+            normal_line
+            normal_cur_line
+            delete
+            change
+            change_line
+          ]);
+      };
 
       utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings vendoredKeybinds;
     };
diff --git a/modules/plugins/utility/telescope/config.nix b/modules/plugins/utility/telescope/config.nix
index f50e955..37bdc0f 100644
--- a/modules/plugins/utility/telescope/config.nix
+++ b/modules/plugins/utility/telescope/config.nix
@@ -20,57 +20,55 @@ in {
     vim = {
       startPlugins = ["plenary-nvim"];
 
-      lazy.plugins = [
-        {
-          package = "telescope";
-          setupModule = "telescope";
-          inherit (cfg) setupOpts;
-          # FIXME: how do I deal with extensions? set all as deps?
-          after = ''
-            local telescope = require("telescope")
-            ${optionalString config.vim.ui.noice.enable "telescope.load_extension('noice')"}
-            ${optionalString config.vim.notify.nvim-notify.enable "telescope.load_extension('notify')"}
-            ${optionalString config.vim.projects.project-nvim.enable "telescope.load_extension('projects')"}
-          '';
+      lazy.plugins.telescope = {
+        package = "telescope";
+        setupModule = "telescope";
+        inherit (cfg) setupOpts;
+        # FIXME: how do I deal with extensions? set all as deps?
+        after = ''
+          local telescope = require("telescope")
+          ${optionalString config.vim.ui.noice.enable "telescope.load_extension('noice')"}
+          ${optionalString config.vim.notify.nvim-notify.enable "telescope.load_extension('notify')"}
+          ${optionalString config.vim.projects.project-nvim.enable "telescope.load_extension('projects')"}
+        '';
 
-          cmd = ["Telescope"];
+        cmd = ["Telescope"];
 
-          keys =
-            [
-              (mkSetLznBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
-              (mkSetLznBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
-              (mkSetLznBinding mappings.buffers "<cmd> Telescope buffers<CR>")
-              (mkSetLznBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
-              (mkSetLznBinding mappings.open "<cmd> Telescope<CR>")
+        keys =
+          [
+            (mkSetLznBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
+            (mkSetLznBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
+            (mkSetLznBinding mappings.buffers "<cmd> Telescope buffers<CR>")
+            (mkSetLznBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
+            (mkSetLznBinding mappings.open "<cmd> Telescope<CR>")
 
-              (mkSetLznBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
-              (mkSetLznBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
-              (mkSetLznBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
-              (mkSetLznBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
-              (mkSetLznBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
+            (mkSetLznBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
+            (mkSetLznBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
+            (mkSetLznBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
+            (mkSetLznBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
+            (mkSetLznBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
+          ]
+          ++ (optionals config.vim.lsp.enable [
+            (mkSetLznBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
+            (mkSetLznBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
+
+            (mkSetLznBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
+            (mkSetLznBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
+            (mkSetLznBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
+            (mkSetLznBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
+            (mkSetLznBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
+          ])
+          ++ (
+            optionals config.vim.treesitter.enable [
+              (mkSetLznBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
             ]
-            ++ (optionals config.vim.lsp.enable [
-              (mkSetLznBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
-              (mkSetLznBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
-
-              (mkSetLznBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
-              (mkSetLznBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
-              (mkSetLznBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
-              (mkSetLznBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
-              (mkSetLznBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
-            ])
-            ++ (
-              optionals config.vim.treesitter.enable [
-                (mkSetLznBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
-              ]
-            )
-            ++ (
-              optionals config.vim.projects.project-nvim.enable [
-                (mkSetLznBinding mappings.findProjects "<cmd Telescope projects<CR>")
-              ]
-            );
-        }
-      ];
+          )
+          ++ (
+            optionals config.vim.projects.project-nvim.enable [
+              (mkSetLznBinding mappings.findProjects "<cmd Telescope projects<CR>")
+            ]
+          );
+      };
 
       binds.whichKey.register = pushDownDefault {
         "<leader>f" = "+Telescope";
diff --git a/modules/plugins/visuals/fidget/config.nix b/modules/plugins/visuals/fidget/config.nix
index 6e81e9d..7c83cd9 100644
--- a/modules/plugins/visuals/fidget/config.nix
+++ b/modules/plugins/visuals/fidget/config.nix
@@ -8,13 +8,11 @@
   cfg = config.vim.visuals.fidget-nvim;
 in {
   config = mkIf cfg.enable {
-    vim.lazy.plugins = [
-      {
-        package = "fidget-nvim";
-        setupModule = "fidget";
-        event = "LspAttach";
-        inherit (cfg) setupOpts;
-      }
-    ];
+    vim.lazy.plugins.fidget-nvim = {
+      package = "fidget-nvim";
+      setupModule = "fidget";
+      event = "LspAttach";
+      inherit (cfg) setupOpts;
+    };
   };
 }

From 256a8cf62c270c4439b43f0092d024241a629762 Mon Sep 17 00:00:00 2001
From: Pei Yang Ching <59727193+horriblename@users.noreply.github.com>
Date: Thu, 17 Oct 2024 17:17:18 +0200
Subject: [PATCH 29/70] docs: update lazy.plugins syntax

---
 docs/manual/hacking/additional-plugins.md | 41 +++++++++++------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/docs/manual/hacking/additional-plugins.md b/docs/manual/hacking/additional-plugins.md
index 6294d6f..f0e8d1c 100644
--- a/docs/manual/hacking/additional-plugins.md
+++ b/docs/manual/hacking/additional-plugins.md
@@ -136,30 +136,29 @@ plugins are managed by `lz.n`.
 let
   cfg = config.vim.your-plugin;
 in {
-  vim.lazy.plugins = [
-    {
-      # instead of vim.startPlugins, use this:
-      package = "your-plugin";
+  vim.lazy.plugins.your-plugin = {
+    # instead of vim.startPlugins, use this:
+    package = "your-plugin";
 
-      # if your plugin uses the `require('your-plugin').setup{...}` pattern
-      setupModule = "your-plugin";
-      inherit (cfg) setupOpts;
+    # if your plugin uses the `require('your-plugin').setup{...}` pattern
+    setupModule = "your-plugin";
+    inherit (cfg) setupOpts;
 
-      # events that trigger this plugin to be loaded
-      events = ["DirChanged"];
-      cmd = ["YourPluginCommand"];
+    # events that trigger this plugin to be loaded
+    events = ["DirChanged"];
+    cmd = ["YourPluginCommand"];
 
-      # keymaps
-      keys = [
-        # we'll cover this in detail in the keymaps section
-        {
-          key = "<leader>d";
-          mode = "n";
-          action = ":YourPluginCommand";
-        }
-      ]
-    }
-  ];
+    # keymaps
+    keys = [
+      # we'll cover this in detail in the keymaps section
+      {
+        key = "<leader>d";
+        mode = "n";
+        action = ":YourPluginCommand";
+      }
+    ];
+  };
+;
 }
 ```
 

From 665f0fa106d72bfb795e6ac2c3403d2dd78dbba1 Mon Sep 17 00:00:00 2001
From: Pei Yang Ching <59727193+horriblename@users.noreply.github.com>
Date: Thu, 17 Oct 2024 17:29:25 +0200
Subject: [PATCH 30/70] lazy: cleanup

---
 modules/wrapper/lazy/config.nix | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
index 08298bd..100ee37 100644
--- a/modules/wrapper/lazy/config.nix
+++ b/modules/wrapper/lazy/config.nix
@@ -3,7 +3,7 @@
   config,
   ...
 }: let
-  inherit (builtins) toJSON typeOf head length tryEval filter concatLists concatStringsSep;
+  inherit (builtins) toJSON typeOf head length filter concatLists concatStringsSep;
   inherit (lib.attrsets) mapAttrsToList;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.generators) mkLuaInline;
@@ -86,15 +86,13 @@ in {
         require('lz.n').load(${toLuaObject lznSpecs})
       '';
     })
-    (
-      mkIf (!cfg.enable) {
-        startPlugins = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
-        luaConfigPre =
-          concatStringsSep "\n"
-          (filter (x: x != null) (mapAttrsToList (_: spec: spec.beforeAll) cfg.plugins));
-        luaConfigRC.unlazy = entryAfter ["pluginConfigs"] notLazyConfig;
-        keymaps = concatLists (mapAttrsToList specToKeymaps cfg.plugins);
-      }
-    )
+    (mkIf (!cfg.enable) {
+      startPlugins = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
+      luaConfigPre =
+        concatStringsSep "\n"
+        (filter (x: x != null) (mapAttrsToList (_: spec: spec.beforeAll) cfg.plugins));
+      luaConfigRC.unlazy = entryAfter ["pluginConfigs"] notLazyConfig;
+      keymaps = concatLists (mapAttrsToList specToKeymaps cfg.plugins);
+    })
   ];
 }

From e7cc55225a9fb3b06a75a528bf9bf462958cc41e Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Fri, 18 Oct 2024 10:40:14 +0200
Subject: [PATCH 31/70] Update docs/manual/hacking/additional-plugins.md

Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com>
---
 docs/manual/hacking/additional-plugins.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/manual/hacking/additional-plugins.md b/docs/manual/hacking/additional-plugins.md
index f0e8d1c..3ea2fff 100644
--- a/docs/manual/hacking/additional-plugins.md
+++ b/docs/manual/hacking/additional-plugins.md
@@ -127,7 +127,7 @@ vim.your-plugin.setupOpts = {
 
 ## Lazy plugins {#sec-lazy-plugins}
 
-If your plugin can be lazy-loaded, you should use `vim.lazy.plugins` to add your plugin. Lazy
+If the plugin can be lazy-loaded, `vim.lazy.plugins` should be used to add it. Lazy
 plugins are managed by `lz.n`.
 
 ```nix

From 66a03f53f873685a3565d9019bb150174378dd35 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Fri, 18 Oct 2024 10:48:50 +0200
Subject: [PATCH 32/70] formatting nitpick

Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com>
---
 modules/wrapper/lazy/config.nix | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
index 100ee37..30f9626 100644
--- a/modules/wrapper/lazy/config.nix
+++ b/modules/wrapper/lazy/config.nix
@@ -86,6 +86,7 @@ in {
         require('lz.n').load(${toLuaObject lznSpecs})
       '';
     })
+    
     (mkIf (!cfg.enable) {
       startPlugins = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
       luaConfigPre =

From 9e551aa4275f0140ee8602f03b2240fad9b9159a Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Fri, 18 Oct 2024 10:51:43 +0200
Subject: [PATCH 33/70] typo tee hee :3

Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com>
---
 docs/manual/hacking/additional-plugins.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/manual/hacking/additional-plugins.md b/docs/manual/hacking/additional-plugins.md
index 3ea2fff..123f798 100644
--- a/docs/manual/hacking/additional-plugins.md
+++ b/docs/manual/hacking/additional-plugins.md
@@ -145,7 +145,7 @@ in {
     inherit (cfg) setupOpts;
 
     # events that trigger this plugin to be loaded
-    events = ["DirChanged"];
+    event = ["DirChanged"];
     cmd = ["YourPluginCommand"];
 
     # keymaps

From 2d16be3cebc9a8b85f010028cfeb57df1e8ad0bc Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Fri, 18 Oct 2024 10:52:27 +0200
Subject: [PATCH 34/70] typo tee hee :4

Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com>
---
 docs/manual/hacking/additional-plugins.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/manual/hacking/additional-plugins.md b/docs/manual/hacking/additional-plugins.md
index 123f798..bd2d7a6 100644
--- a/docs/manual/hacking/additional-plugins.md
+++ b/docs/manual/hacking/additional-plugins.md
@@ -171,7 +171,7 @@ require('lz.n').load({
       require('your-plugin').setup({--[[ your setupOpts ]]})
     end,
 
-    events = {"DirChanged"},
+    event = {"DirChanged"},
     cmd = {"YourPluginCommand"},
     keys = {
       {"<leader>d", ":YourPluginCommand", mode = {"n"}},

From d1c410b3ff32b47d2dfe2ce4e456e50942109a93 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 21 Oct 2024 18:07:30 +0200
Subject: [PATCH 35/70] flake: update lz.n

---
 flake.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/flake.lock b/flake.lock
index 59e8e02..5b643b0 100644
--- a/flake.lock
+++ b/flake.lock
@@ -879,11 +879,11 @@
     "plugin-lz-n": {
       "flake": false,
       "locked": {
-        "lastModified": 1727574854,
-        "narHash": "sha256-qDWNleR2NHFkiEKE/+LNVOBRwEeskMC4dWTl5BTyZuE=",
+        "lastModified": 1729525284,
+        "narHash": "sha256-fk+ejqcqqOQz3q4D3VB2Q+U/6wCpCDk1tiDMp2YrPNE=",
         "owner": "nvim-neorocks",
         "repo": "lz.n",
-        "rev": "470173e3cbef763c6d1b918f3f129b67db75e1f8",
+        "rev": "ffd9991400ba7137f4fa8560ff50bccd7f8fb3ee",
         "type": "github"
       },
       "original": {

From 132d83e5880a6714f85be3433f29efa96db5c3d1 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 21 Oct 2024 18:08:09 +0200
Subject: [PATCH 36/70] lazy: update lz.n plugin spec

---
 modules/wrapper/lazy/lazy.nix | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
index 622d07f..6f254fc 100644
--- a/modules/wrapper/lazy/lazy.nix
+++ b/modules/wrapper/lazy/lazy.nix
@@ -160,6 +160,8 @@
         default = null;
       };
 
+      lazy = mkBool false "Lazy-load manually, e.g. using `trigger_load`.";
+
       priority = mkOption {
         type = nullOr int;
         description = "Only useful for stat plugins (not lazy-loaded) to force loading certain plugins first.";

From 7e108703633c4d15fa36ab8ff818fb8e860bd1d0 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 21 Oct 2024 18:08:31 +0200
Subject: [PATCH 37/70] lazy: allow lines in place of str for lua code

---
 modules/wrapper/lazy/lazy.nix | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
index 6f254fc..52ed9c3 100644
--- a/modules/wrapper/lazy/lazy.nix
+++ b/modules/wrapper/lazy/lazy.nix
@@ -1,6 +1,6 @@
 {lib, ...}: let
   inherit (lib.options) mkOption mkEnableOption;
-  inherit (lib.types) enum listOf submodule nullOr str bool int attrsOf anything either oneOf;
+  inherit (lib.types) enum listOf submodule nullOr str bool int attrsOf anything either oneOf lines;
   inherit (lib.nvim.types) pluginType;
   inherit (lib.nvim.config) mkBool;
 
@@ -76,19 +76,19 @@
       };
 
       beforeAll = mkOption {
-        type = nullOr str;
+        type = nullOr lines;
         description = "Lua code to run before any plugins are loaded. This will be wrapped in a function.";
         default = null;
       };
 
       before = mkOption {
-        type = nullOr str;
+        type = nullOr lines;
         description = "Lua code to run before plugin is loaded. This will be wrapped in a function.";
         default = null;
       };
 
       after = mkOption {
-        type = nullOr str;
+        type = nullOr lines;
         description = ''
           Lua code to run after plugin is loaded. This will be wrapped in a function.
 
@@ -169,12 +169,12 @@
       };
 
       load = mkOption {
-        type = nullOr str;
+        type = nullOr lines;
         default = null;
         description = ''
           Lua code to override the `vim.g.lz_n.load()` function for a single plugin.
 
-          This will be wrapped in a function
+          This will be wrapped in a function.
         '';
       };
     };

From b636b220469f236e987de3c68436f121c0e81a79 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 21 Oct 2024 20:19:18 +0200
Subject: [PATCH 38/70] copilot: lazy load

---
 modules/plugins/assistant/copilot/config.nix | 115 ++++++++++---------
 1 file changed, 58 insertions(+), 57 deletions(-)

diff --git a/modules/plugins/assistant/copilot/config.nix b/modules/plugins/assistant/copilot/config.nix
index 923a0c6..6576d50 100644
--- a/modules/plugins/assistant/copilot/config.nix
+++ b/modules/plugins/assistant/copilot/config.nix
@@ -4,11 +4,7 @@
   ...
 }: let
   inherit (builtins) toJSON;
-  inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.lists) optionals;
-  inherit (lib.nvim.binds) mkLuaBinding;
+  inherit (lib.modules) mkIf;
 
   cfg = config.vim.assistant.copilot;
 
@@ -23,65 +19,70 @@
       end
     end
   '';
+
+  mkLuaKeymap = mode: key: action: desc: opts:
+    opts
+    // {
+      inherit mode key action desc;
+      lua = true;
+    };
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins =
-      [
-        "copilot-lua"
-        # cfg.copilotNodePackage
-      ]
-      ++ optionals cfg.cmp.enable [
-        "copilot-cmp"
-      ];
+    vim = {
+      lazy.plugins = {
+        copilot-lua = {
+          package = "copilot-lua";
+          setupModule = "copilot";
+          inherit (cfg) setupOpts;
+          after = mkIf cfg.cmp.enable "require('copilot_cmp').setup()";
 
-    vim.autocomplete.nvim-cmp.sources = {copilot = "[Copilot]";};
+          cmd = ["Copilot" "CopilotAuth" "CopilotDetach" "CopilotPanel" "CopilotStop"];
+          keys = [
+            (mkLuaKeymap ["n"] cfg.mappings.panel.accept (wrapPanelBinding ''require("copilot.panel").accept'' cfg.mappings.panel.accept) "[copilot] Accept suggestion" {})
+            (mkLuaKeymap ["n"] cfg.mappings.panel.jumpNext (wrapPanelBinding "require(\"copilot.panel\").jump_next" cfg.mappings.panel.jumpNext) "[copilot] Accept suggestion" {})
+            (mkLuaKeymap ["n"] cfg.mappings.panel.jumpPrev (wrapPanelBinding "require(\"copilot.panel\").jump_prev" cfg.mappings.panel.jumpPrev) "[copilot] Accept suggestion" {})
+            (mkLuaKeymap ["n"] cfg.mappings.panel.refresh (wrapPanelBinding "require(\"copilot.panel\").refresh" cfg.mappings.panel.refresh) "[copilot] Accept suggestion" {})
+            (mkLuaKeymap ["n"] cfg.mappings.panel.open (wrapPanelBinding ''
+                function() require("copilot.panel").open({ position = "${cfg.setupOpts.panel.layout.position}", ratio = ${toString cfg.setupOpts.panel.layout.ratio}, }) end
+              ''
+              cfg.mappings.panel.open) "[copilot] Accept suggestion" {})
 
-    vim.pluginRC.copilot = entryAnywhere ''
-      require("copilot").setup(${toLuaObject cfg.setupOpts})
+            (mkLuaKeymap ["i"] cfg.mappings.suggestion.accept "function() require('copilot.suggestion').accept() end" "[copilot] Accept suggestion" {})
+            (mkLuaKeymap ["i"] cfg.mappings.suggestion.acceptLine "function() require('copilot.suggestion').accept_line() end" "[copilot] Accept suggestion (line)" {})
+            (mkLuaKeymap ["i"] cfg.mappings.suggestion.acceptWord "function() require('copilot.suggestion').accept_word() end" "[copilot] Accept suggestion (word)" {})
+            (mkLuaKeymap ["i"] cfg.mappings.suggestion.dismiss "function() require('copilot.suggestion').dismiss() end" "[copilot] dismiss suggestion" {})
+            (mkLuaKeymap ["i"] cfg.mappings.suggestion.next "function() require('copilot.suggestion').next() end" "[copilot] next suggestion" {})
+            (mkLuaKeymap ["i"] cfg.mappings.suggestion.prev "function() require('copilot.suggestion').prev() end" "[copilot] previous suggestion" {})
+          ];
+        };
 
-      ${lib.optionalString cfg.cmp.enable ''
-        require("copilot_cmp").setup()
-      ''}
-    '';
-
-    # Disable plugin handled keymaps.
-    # Setting it here so that it doesn't show up in user docs
-    vim.assistant.copilot.setupOpts = {
-      panel.keymap = {
-        jump_prev = lib.mkDefault false;
-        jump_next = lib.mkDefault false;
-        accept = lib.mkDefault false;
-        refresh = lib.mkDefault false;
-        open = lib.mkDefault false;
+        copilot-cmp = mkIf cfg.cmp.enable {
+          package = "copilot-cmp";
+          lazy = true;
+        };
       };
-      suggestion.keymap = {
-        accept = lib.mkDefault false;
-        accept_word = lib.mkDefault false;
-        accept_line = lib.mkDefault false;
-        next = lib.mkDefault false;
-        prev = lib.mkDefault false;
-        dismiss = lib.mkDefault false;
+
+      autocomplete.nvim-cmp.sources = {copilot = "[Copilot]";};
+
+      # Disable plugin handled keymaps.
+      # Setting it here so that it doesn't show up in user docs
+      assistant.copilot.setupOpts = {
+        panel.keymap = {
+          jump_prev = lib.mkDefault false;
+          jump_next = lib.mkDefault false;
+          accept = lib.mkDefault false;
+          refresh = lib.mkDefault false;
+          open = lib.mkDefault false;
+        };
+        suggestion.keymap = {
+          accept = lib.mkDefault false;
+          accept_word = lib.mkDefault false;
+          accept_line = lib.mkDefault false;
+          next = lib.mkDefault false;
+          prev = lib.mkDefault false;
+          dismiss = lib.mkDefault false;
+        };
       };
     };
-
-    vim.maps.normal = mkMerge [
-      (mkLuaBinding cfg.mappings.panel.jumpPrev (wrapPanelBinding "require(\"copilot.panel\").jump_prev" cfg.mappings.panel.jumpPrev) "[copilot] Accept suggestion")
-      (mkLuaBinding cfg.mappings.panel.jumpNext (wrapPanelBinding "require(\"copilot.panel\").jump_next" cfg.mappings.panel.jumpNext) "[copilot] Accept suggestion")
-      (mkLuaBinding cfg.mappings.panel.accept (wrapPanelBinding ''require("copilot.panel").accept'' cfg.mappings.panel.accept) "[copilot] Accept suggestion")
-      (mkLuaBinding cfg.mappings.panel.refresh (wrapPanelBinding "require(\"copilot.panel\").refresh" cfg.mappings.panel.refresh) "[copilot] Accept suggestion")
-      (mkLuaBinding cfg.mappings.panel.open (wrapPanelBinding ''
-          function() require("copilot.panel").open({ position = "${cfg.setupOpts.panel.layout.position}", ratio = ${toString cfg.setupOpts.panel.layout.ratio}, }) end
-        ''
-        cfg.mappings.panel.open) "[copilot] Accept suggestion")
-    ];
-
-    vim.maps.insert = mkMerge [
-      (mkLuaBinding cfg.mappings.suggestion.accept "require(\"copilot.suggestion\").accept" "[copilot] Accept suggestion")
-      (mkLuaBinding cfg.mappings.suggestion.acceptLine "require(\"copilot.suggestion\").accept_line" "[copilot] Accept suggestion (line)")
-      (mkLuaBinding cfg.mappings.suggestion.acceptWord "require(\"copilot.suggestion\").accept_word" "[copilot] Accept suggestion (word)")
-      (mkLuaBinding cfg.mappings.suggestion.next "require(\"copilot.suggestion\").next" "[copilot] next suggestion")
-      (mkLuaBinding cfg.mappings.suggestion.prev "require(\"copilot.suggestion\").prev" "[copilot] previous suggestion")
-      (mkLuaBinding cfg.mappings.suggestion.dismiss "require(\"copilot.suggestion\").dismiss" "[copilot] dismiss suggestion")
-    ];
   };
 }

From 46a1f0427f15bace8ac0003580087b193efe3121 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 21 Oct 2024 18:25:42 +0200
Subject: [PATCH 39/70] cmp: lazy load

this moves cmp itself to lazy.plugins but other plugins that call cmp
are not yet lazy so cmp is technically not yet lazy
---
 .../plugins/completion/nvim-cmp/config.nix    | 139 ++++++++++--------
 1 file changed, 76 insertions(+), 63 deletions(-)

diff --git a/modules/plugins/completion/nvim-cmp/config.nix b/modules/plugins/completion/nvim-cmp/config.nix
index 5d20242..9587f80 100644
--- a/modules/plugins/completion/nvim-cmp/config.nix
+++ b/modules/plugins/completion/nvim-cmp/config.nix
@@ -6,7 +6,6 @@
   inherit (lib.modules) mkIf;
   inherit (lib.strings) optionalString;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (builtins) attrNames;
 
@@ -16,78 +15,92 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = [
-        "nvim-cmp"
-        "cmp-buffer"
-        "cmp-path"
-      ];
+      lazy.plugins = {
+        # cmp sources are loaded via lzn-auto-require as long as it is defined
+        # in cmp sources
+        cmp-buffer = {
+          package = "cmp-buffer";
+          lazy = true;
+        };
+        cmp-path = {
+          package = "cmp-path";
+          lazy = true;
+        };
+        nvim-cmp = {
+          package = "nvim-cmp";
+          after = ''
+            ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
+            local cmp = require("cmp")
+            cmp.setup(${toLuaObject cfg.setupOpts})
+          '';
 
-      autocomplete.nvim-cmp.sources = {
-        nvim-cmp = null;
-        buffer = "[Buffer]";
-        path = "[Path]";
+          event = ["InsertEnter" "CmdlineEnter"];
+          lazy = true;
+        };
       };
 
-      autocomplete.nvim-cmp.setupOpts = {
-        sources = map (s: {name = s;}) (attrNames cfg.sources);
-
-        # TODO: try to get nvim-cmp to follow global border style
-        window = mkIf config.vim.ui.borders.enable {
-          completion = mkLuaInline "cmp.config.window.bordered()";
-          documentation = mkLuaInline "cmp.config.window.bordered()";
+      autocomplete.nvim-cmp = {
+        sources = {
+          nvim-cmp = null;
+          buffer = "[Buffer]";
+          path = "[Path]";
         };
 
-        formatting.format = cfg.format;
-      };
+        setupOpts = {
+          sources = map (s: {name = s;}) (attrNames cfg.sources);
 
-      pluginRC.nvim-cmp = mkIf cfg.enable (entryAfter ["autopairs" "luasnip"] ''
-        ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
-        local cmp = require("cmp")
-        cmp.setup(${toLuaObject cfg.setupOpts})
-      '');
+          # TODO: try to get nvim-cmp to follow global border style
+          window = mkIf config.vim.ui.borders.enable {
+            completion = mkLuaInline "cmp.config.window.bordered()";
+            documentation = mkLuaInline "cmp.config.window.bordered()";
+          };
 
-      # `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
-      autocomplete.nvim-cmp.setupOpts.mapping = {
-        ${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
-        ${mappings.close} = mkLuaInline "cmp.mapping.abort()";
-        ${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
-        ${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
-        ${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
+          formatting.format = cfg.format;
+        };
 
-        ${mappings.next} = mkLuaInline ''
-          cmp.mapping(function(fallback)
-            local has_words_before = function()
-              local line, col = unpack(vim.api.nvim_win_get_cursor(0))
-              return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
-            end
+        # `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
+        setupOpts.mapping = {
+          ${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
+          ${mappings.close} = mkLuaInline "cmp.mapping.abort()";
+          ${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
+          ${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
+          ${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
 
-            if cmp.visible() then
-              cmp.select_next_item()
-              ${optionalString luasnipEnable ''
-            elseif luasnip.locally_jumpable(1) then
-              luasnip.jump(1)
-          ''}
-            elseif has_words_before() then
-              cmp.complete()
-            else
-              fallback()
-            end
-          end)
-        '';
+          ${mappings.next} = mkLuaInline ''
+            cmp.mapping(function(fallback)
+              local has_words_before = function()
+                local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+                return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
+              end
 
-        ${mappings.previous} = mkLuaInline ''
-          cmp.mapping(function(fallback)
-            if cmp.visible() then
-              cmp.select_prev_item()
-              ${optionalString luasnipEnable ''
-            elseif luasnip.locally_jumpable(-1) then
-              luasnip.jump(-1)
-          ''}
-            else
-              fallback()
-            end
-          end)
-        '';
+              if cmp.visible() then
+                cmp.select_next_item()
+                ${optionalString luasnipEnable ''
+              elseif luasnip.locally_jumpable(1) then
+                luasnip.jump(1)
+            ''}
+              elseif has_words_before() then
+                cmp.complete()
+              else
+                fallback()
+              end
+            end)
+          '';
+
+          ${mappings.previous} = mkLuaInline ''
+            cmp.mapping(function(fallback)
+              if cmp.visible() then
+                cmp.select_prev_item()
+                ${optionalString luasnipEnable ''
+              elseif luasnip.locally_jumpable(-1) then
+                luasnip.jump(-1)
+            ''}
+              else
+                fallback()
+              end
+            end)
+          '';
+        };
       };
     };
   };

From e829a0964ac8a30d3b31c25a7d0ce2bed3761f59 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 21 Oct 2024 18:42:02 +0200
Subject: [PATCH 40/70] luasnip: lazy load

---
 modules/plugins/snippets/luasnip/config.nix | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/modules/plugins/snippets/luasnip/config.nix b/modules/plugins/snippets/luasnip/config.nix
index 541fd0f..57a3c54 100644
--- a/modules/plugins/snippets/luasnip/config.nix
+++ b/modules/plugins/snippets/luasnip/config.nix
@@ -9,9 +9,19 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = ["luasnip" "cmp-luasnip"] ++ cfg.providers;
+      lazy.plugins = {
+        luasnip = {
+          package = "luasnip";
+          lazy = true;
+          after = cfg.loaders;
+        };
+        cmp-luasnip = mkIf config.vim.autocomplete.nvim-cmp.enable {
+          package = "cmp-luasnip";
+          lazy = true;
+        };
+      };
+      startPlugins = cfg.providers;
       autocomplete.nvim-cmp.sources = {luasnip = "[LuaSnip]";};
-      pluginRC.luasnip = cfg.loaders;
     };
   };
 }

From f107cc45eb97fb897e5a221b5b4b22cd23453db3 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Tue, 22 Oct 2024 13:00:48 +0200
Subject: [PATCH 41/70] flake: add rtp.nvim

---
 flake.lock | 17 +++++++++++++++++
 flake.nix  |  5 +++++
 2 files changed, 22 insertions(+)

diff --git a/flake.lock b/flake.lock
index 5b643b0..2d73a3e 100644
--- a/flake.lock
+++ b/flake.lock
@@ -1630,6 +1630,22 @@
         "type": "github"
       }
     },
+    "plugin-rtp-nvim": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1724409589,
+        "narHash": "sha256-lmJbiD7I7MTEEpukESs67uAmLyn+p66hrUKLbEHp0Kw=",
+        "owner": "nvim-neorocks",
+        "repo": "rtp.nvim",
+        "rev": "494ddfc888bb466555d90ace731856de1320fe45",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nvim-neorocks",
+        "repo": "rtp.nvim",
+        "type": "github"
+      }
+    },
     "plugin-rustaceanvim": {
       "flake": false,
       "locked": {
@@ -2038,6 +2054,7 @@
         "plugin-project-nvim": "plugin-project-nvim",
         "plugin-registers": "plugin-registers",
         "plugin-rose-pine": "plugin-rose-pine",
+        "plugin-rtp-nvim": "plugin-rtp-nvim",
         "plugin-rustaceanvim": "plugin-rustaceanvim",
         "plugin-scrollbar-nvim": "plugin-scrollbar-nvim",
         "plugin-smartcolumn": "plugin-smartcolumn",
diff --git a/flake.nix b/flake.nix
index 4004358..4de493e 100644
--- a/flake.nix
+++ b/flake.nix
@@ -124,6 +124,11 @@
       flake = false;
     };
 
+    plugin-rtp-nvim = {
+      url = "github:nvim-neorocks/rtp.nvim";
+      flake = false;
+    };
+
     # LSP plugins
     plugin-nvim-lspconfig = {
       url = "github:neovim/nvim-lspconfig";

From 4b703964e14f942ea021f747281021f0fbd4c71b Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Tue, 22 Oct 2024 15:14:15 +0200
Subject: [PATCH 42/70] cmp: actually lazy load source

---
 modules/plugins/assistant/copilot/config.nix   |  8 ++++++++
 modules/plugins/completion/nvim-cmp/config.nix | 16 ++++++++++++++++
 modules/plugins/snippets/luasnip/config.nix    |  8 ++++++++
 modules/plugins/treesitter/config.nix          | 11 +++++++++++
 4 files changed, 43 insertions(+)

diff --git a/modules/plugins/assistant/copilot/config.nix b/modules/plugins/assistant/copilot/config.nix
index 6576d50..9c33714 100644
--- a/modules/plugins/assistant/copilot/config.nix
+++ b/modules/plugins/assistant/copilot/config.nix
@@ -5,6 +5,7 @@
 }: let
   inherit (builtins) toJSON;
   inherit (lib.modules) mkIf;
+  inherit (lib.strings) optionalString;
 
   cfg = config.vim.assistant.copilot;
 
@@ -59,7 +60,14 @@ in {
         copilot-cmp = mkIf cfg.cmp.enable {
           package = "copilot-cmp";
           lazy = true;
+          after = optionalString config.vim.lazy.enable ''
+            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/copilot-cmp')
+            require("rtp_nvim").source_after_plugin_dir(path)
+            require("lz.n").trigger_load("copilot-lua")
+          '';
         };
+
+        nvim-cmp.after = mkIf cfg.cmp.enable "require('lz.n').trigger_load('copilot-cmp')";
       };
 
       autocomplete.nvim-cmp.sources = {copilot = "[Copilot]";};
diff --git a/modules/plugins/completion/nvim-cmp/config.nix b/modules/plugins/completion/nvim-cmp/config.nix
index 9587f80..458b9e9 100644
--- a/modules/plugins/completion/nvim-cmp/config.nix
+++ b/modules/plugins/completion/nvim-cmp/config.nix
@@ -15,23 +15,39 @@
 in {
   config = mkIf cfg.enable {
     vim = {
+      startPlugins = ["rtp-nvim"];
       lazy.plugins = {
         # cmp sources are loaded via lzn-auto-require as long as it is defined
         # in cmp sources
         cmp-buffer = {
           package = "cmp-buffer";
           lazy = true;
+          after = ''
+            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-buffer')
+            require("rtp_nvim").source_after_plugin_dir(path)
+          '';
         };
         cmp-path = {
           package = "cmp-path";
           lazy = true;
+          after = ''
+            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-path')
+            require("rtp_nvim").source_after_plugin_dir(path)
+          '';
         };
         nvim-cmp = {
           package = "nvim-cmp";
           after = ''
             ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
+                require("lz.n").trigger_load("cmp-path")
             local cmp = require("cmp")
             cmp.setup(${toLuaObject cfg.setupOpts})
+
+            ${
+              optionalString config.vim.lazy.enable ''
+                require("lz.n").trigger_load("cmp-buffer")
+              ''
+            }
           '';
 
           event = ["InsertEnter" "CmdlineEnter"];
diff --git a/modules/plugins/snippets/luasnip/config.nix b/modules/plugins/snippets/luasnip/config.nix
index 57a3c54..4fbbd2c 100644
--- a/modules/plugins/snippets/luasnip/config.nix
+++ b/modules/plugins/snippets/luasnip/config.nix
@@ -4,6 +4,7 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
+  inherit (lib.strings) optionalString;
 
   cfg = config.vim.snippets.luasnip;
 in {
@@ -18,7 +19,14 @@ in {
         cmp-luasnip = mkIf config.vim.autocomplete.nvim-cmp.enable {
           package = "cmp-luasnip";
           lazy = true;
+          after = ''
+            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-luasnip')
+            require("rtp_nvim").source_after_plugin_dir(path)
+          '';
         };
+        nvim-cmp.after = optionalString config.vim.lazy.enable ''
+          require("lz.n").trigger_load("cmp-luasnip")
+        '';
       };
       startPlugins = cfg.providers;
       autocomplete.nvim-cmp.sources = {luasnip = "[LuaSnip]";};
diff --git a/modules/plugins/treesitter/config.nix b/modules/plugins/treesitter/config.nix
index ae09386..584a545 100644
--- a/modules/plugins/treesitter/config.nix
+++ b/modules/plugins/treesitter/config.nix
@@ -21,6 +21,17 @@ in {
     vim = {
       startPlugins = ["nvim-treesitter"] ++ optional usingNvimCmp "cmp-treesitter";
 
+      lazy.plugins = {
+        cmp-treesitter = mkIf usingNvimCmp {
+          package = "cmp-treesitter";
+          after = ''
+            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-treesitter')
+            require("rtp_nvim").source_after_plugin_dir(path)
+          '';
+        };
+        nvim-cmp.after = mkIf cfg.cmp.enable "require('lz.n').trigger_load('cmp-treesitter')";
+      };
+
       autocomplete.nvim-cmp.sources = {treesitter = "[Treesitter]";};
       treesitter.grammars = optionals cfg.addDefaultGrammars cfg.defaultGrammars;
 

From 2f502f17902f4a997d3db37459bf354e3c34f52b Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Tue, 22 Oct 2024 15:25:59 +0200
Subject: [PATCH 43/70] fixup! cmp: actually lazy load source

---
 modules/plugins/completion/nvim-cmp/config.nix | 1 -
 modules/plugins/treesitter/config.nix          | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/modules/plugins/completion/nvim-cmp/config.nix b/modules/plugins/completion/nvim-cmp/config.nix
index 458b9e9..9140b05 100644
--- a/modules/plugins/completion/nvim-cmp/config.nix
+++ b/modules/plugins/completion/nvim-cmp/config.nix
@@ -51,7 +51,6 @@ in {
           '';
 
           event = ["InsertEnter" "CmdlineEnter"];
-          lazy = true;
         };
       };
 
diff --git a/modules/plugins/treesitter/config.nix b/modules/plugins/treesitter/config.nix
index 584a545..e810d7e 100644
--- a/modules/plugins/treesitter/config.nix
+++ b/modules/plugins/treesitter/config.nix
@@ -19,7 +19,7 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = ["nvim-treesitter"] ++ optional usingNvimCmp "cmp-treesitter";
+      startPlugins = ["nvim-treesitter"];
 
       lazy.plugins = {
         cmp-treesitter = mkIf usingNvimCmp {
@@ -29,7 +29,7 @@ in {
             require("rtp_nvim").source_after_plugin_dir(path)
           '';
         };
-        nvim-cmp.after = mkIf cfg.cmp.enable "require('lz.n').trigger_load('cmp-treesitter')";
+        nvim-cmp.after = mkIf usingNvimCmp "require('lz.n').trigger_load('cmp-treesitter')";
       };
 
       autocomplete.nvim-cmp.sources = {treesitter = "[Treesitter]";};

From 1952f41632b3abd71f85518733eb98f9146d1df0 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Tue, 22 Oct 2024 15:31:11 +0200
Subject: [PATCH 44/70] format

---
 modules/wrapper/lazy/config.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
index 30f9626..da5dd8c 100644
--- a/modules/wrapper/lazy/config.nix
+++ b/modules/wrapper/lazy/config.nix
@@ -86,7 +86,7 @@ in {
         require('lz.n').load(${toLuaObject lznSpecs})
       '';
     })
-    
+
     (mkIf (!cfg.enable) {
       startPlugins = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
       luaConfigPre =

From 6664304f7e77d2b3a8b5caf345b73ac4e5543f31 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Tue, 22 Oct 2024 15:32:57 +0200
Subject: [PATCH 45/70] docs: fix broken link

---
 modules/wrapper/lazy/lazy.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
index 52ed9c3..e16a8aa 100644
--- a/modules/wrapper/lazy/lazy.nix
+++ b/modules/wrapper/lazy/lazy.nix
@@ -92,7 +92,7 @@
         description = ''
           Lua code to run after plugin is loaded. This will be wrapped in a function.
 
-          If [](#opt-vim.lazy.plugins._.setupModule) is provided, the setup will be ran before `after`.
+          If [](#opt-vim.lazy.plugins._name_.setupModule) is provided, the setup will be ran before `after`.
         '';
         default = null;
       };

From 70e988bb33551cc1bbd5bc1b2112f0f45cd28f86 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Tue, 22 Oct 2024 15:33:18 +0200
Subject: [PATCH 46/70] cmp-nvim-lsp: lazy load

---
 modules/plugins/lsp/config.nix | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/modules/plugins/lsp/config.nix b/modules/plugins/lsp/config.nix
index 52dc15b..63c21d5 100644
--- a/modules/plugins/lsp/config.nix
+++ b/modules/plugins/lsp/config.nix
@@ -23,7 +23,17 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = optional usingNvimCmp "cmp-nvim-lsp";
+      lazy.plugins = {
+        cmp-nvim-lsp = {
+          package = "cmp-nvim-lsp";
+          lazy = true;
+          after = ''
+            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-treesitter')
+            require("rtp_nvim").source_after_plugin_dir(path)
+          '';
+        };
+        nvim-cmp.after = mkIf usingNvimCmp "require('lz.n').trigger_load('cmp-nvim-lsp')";
+      };
 
       autocomplete.nvim-cmp.sources = {nvim_lsp = "[LSP]";};
 

From 0397d0722f91a96f3553bccf3a3d3eb97bd95d14 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Tue, 22 Oct 2024 15:46:04 +0200
Subject: [PATCH 47/70] lazy: allow key mode of str type

---
 modules/wrapper/lazy/lazy.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
index e16a8aa..fc130af 100644
--- a/modules/wrapper/lazy/lazy.nix
+++ b/modules/wrapper/lazy/lazy.nix
@@ -35,7 +35,7 @@
 
       mode = mkOption {
         description = "Modes to bind in";
-        type = listOf str;
+        type = either str (listOf str);
         default = ["n" "x" "s" "o"];
       };
 

From eff15d27b48e213db7a4905d4ff72cb59349a0b9 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sat, 26 Oct 2024 01:51:58 +0200
Subject: [PATCH 48/70] cmp: install sourcess via cmp.sourcePlugins

---
 modules/plugins/assistant/copilot/config.nix  | 17 +---
 .../plugins/completion/nvim-cmp/config.nix    | 77 ++++++++++---------
 .../plugins/completion/nvim-cmp/nvim-cmp.nix  | 10 ++-
 modules/plugins/lsp/config.nix                | 18 +----
 modules/plugins/snippets/luasnip/config.nix   | 17 +---
 modules/plugins/treesitter/config.nix         |  8 +-
 modules/plugins/utility/telescope/config.nix  |  5 +-
 7 files changed, 68 insertions(+), 84 deletions(-)

diff --git a/modules/plugins/assistant/copilot/config.nix b/modules/plugins/assistant/copilot/config.nix
index 9c33714..9f92d14 100644
--- a/modules/plugins/assistant/copilot/config.nix
+++ b/modules/plugins/assistant/copilot/config.nix
@@ -56,21 +56,12 @@ in {
             (mkLuaKeymap ["i"] cfg.mappings.suggestion.prev "function() require('copilot.suggestion').prev() end" "[copilot] previous suggestion" {})
           ];
         };
-
-        copilot-cmp = mkIf cfg.cmp.enable {
-          package = "copilot-cmp";
-          lazy = true;
-          after = optionalString config.vim.lazy.enable ''
-            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/copilot-cmp')
-            require("rtp_nvim").source_after_plugin_dir(path)
-            require("lz.n").trigger_load("copilot-lua")
-          '';
-        };
-
-        nvim-cmp.after = mkIf cfg.cmp.enable "require('lz.n').trigger_load('copilot-cmp')";
       };
 
-      autocomplete.nvim-cmp.sources = {copilot = "[Copilot]";};
+      autocomplete.nvim-cmp = {
+        sources = {copilot = "[Copilot]";};
+        sourcePlugins = ["copilot-cmp"];
+      };
 
       # Disable plugin handled keymaps.
       # Setting it here so that it doesn't show up in user docs
diff --git a/modules/plugins/completion/nvim-cmp/config.nix b/modules/plugins/completion/nvim-cmp/config.nix
index 9140b05..27d0bfb 100644
--- a/modules/plugins/completion/nvim-cmp/config.nix
+++ b/modules/plugins/completion/nvim-cmp/config.nix
@@ -3,56 +3,57 @@
   config,
   ...
 }: let
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
   inherit (lib.strings) optionalString;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (builtins) attrNames;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (builtins) attrNames typeOf tryEval concatStringsSep;
 
   cfg = config.vim.autocomplete.nvim-cmp;
   luasnipEnable = config.vim.snippets.luasnip.enable;
+  getPluginName = plugin:
+    if typeOf plugin == "string"
+    then plugin
+    else if (plugin ? pname && (tryEval plugin.pname).success)
+    then plugin.pname
+    else plugin.name;
   inherit (cfg) mappings;
 in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = ["rtp-nvim"];
-      lazy.plugins = {
-        # cmp sources are loaded via lzn-auto-require as long as it is defined
-        # in cmp sources
-        cmp-buffer = {
-          package = "cmp-buffer";
-          lazy = true;
-          after = ''
-            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-buffer')
-            require("rtp_nvim").source_after_plugin_dir(path)
-          '';
-        };
-        cmp-path = {
-          package = "cmp-path";
-          lazy = true;
-          after = ''
-            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-path')
-            require("rtp_nvim").source_after_plugin_dir(path)
-          '';
-        };
-        nvim-cmp = {
-          package = "nvim-cmp";
-          after = ''
-            ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
-                require("lz.n").trigger_load("cmp-path")
-            local cmp = require("cmp")
-            cmp.setup(${toLuaObject cfg.setupOpts})
+      lazy.plugins = mkMerge [
+        (mapListToAttrs (package: {
+            name = getPluginName package;
+            value = {
+              inherit package;
+              lazy = true;
+              after = ''
+                local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/${getPluginName package}')
+                require("rtp_nvim").source_after_plugin_dir(path)
+              '';
+            };
+          })
+          cfg.sourcePlugins)
+        {
+          nvim-cmp = {
+            package = "nvim-cmp";
+            after = ''
+              ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
+                  require("lz.n").trigger_load("cmp-path")
+              local cmp = require("cmp")
+              cmp.setup(${toLuaObject cfg.setupOpts})
 
-            ${
-              optionalString config.vim.lazy.enable ''
-                require("lz.n").trigger_load("cmp-buffer")
-              ''
-            }
-          '';
+              ${concatStringsSep "\n" (map
+                (package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
+                cfg.sourcePlugins)}
+            '';
 
-          event = ["InsertEnter" "CmdlineEnter"];
-        };
-      };
+            event = ["InsertEnter" "CmdlineEnter"];
+          };
+        }
+      ];
 
       autocomplete.nvim-cmp = {
         sources = {
@@ -61,6 +62,8 @@ in {
           path = "[Path]";
         };
 
+        sourcePlugins = ["cmp-buffer" "cmp-path"];
+
         setupOpts = {
           sources = map (s: {name = s;}) (attrNames cfg.sources);
 
diff --git a/modules/plugins/completion/nvim-cmp/nvim-cmp.nix b/modules/plugins/completion/nvim-cmp/nvim-cmp.nix
index 860a1c3..8246e71 100644
--- a/modules/plugins/completion/nvim-cmp/nvim-cmp.nix
+++ b/modules/plugins/completion/nvim-cmp/nvim-cmp.nix
@@ -4,10 +4,10 @@
   ...
 }: let
   inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
-  inherit (lib.types) str attrsOf nullOr either;
+  inherit (lib.types) str attrsOf nullOr either listOf;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.binds) mkMappingOption;
-  inherit (lib.nvim.types) mkPluginSetupOption luaInline mergelessListOf;
+  inherit (lib.nvim.types) mkPluginSetupOption luaInline mergelessListOf pluginType;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (builtins) isString;
 
@@ -99,5 +99,11 @@ in {
         }
       '';
     };
+
+    sourcePlugins = mkOption {
+      type = listOf pluginType;
+      default = [];
+      description = "List of source plugins used by nvim-cmp.";
+    };
   };
 }
diff --git a/modules/plugins/lsp/config.nix b/modules/plugins/lsp/config.nix
index 63c21d5..841e28b 100644
--- a/modules/plugins/lsp/config.nix
+++ b/modules/plugins/lsp/config.nix
@@ -5,7 +5,6 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.lists) optional;
   inherit (lib.strings) optionalString;
   inherit (lib.trivial) boolToString;
   inherit (lib.nvim.binds) addDescriptionsToMappings;
@@ -23,20 +22,11 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      lazy.plugins = {
-        cmp-nvim-lsp = {
-          package = "cmp-nvim-lsp";
-          lazy = true;
-          after = ''
-            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-treesitter')
-            require("rtp_nvim").source_after_plugin_dir(path)
-          '';
-        };
-        nvim-cmp.after = mkIf usingNvimCmp "require('lz.n').trigger_load('cmp-nvim-lsp')";
+      autocomplete.nvim-cmp = {
+        sources = {nvim_lsp = "[LSP]";};
+        sourcePlugins = ["cmp-nvim-lsp"];
       };
 
-      autocomplete.nvim-cmp.sources = {nvim_lsp = "[LSP]";};
-
       pluginRC.lsp-setup = ''
         vim.g.formatsave = ${boolToString cfg.formatOnSave};
 
@@ -126,7 +116,7 @@ in {
         end
 
         local capabilities = vim.lsp.protocol.make_client_capabilities()
-        ${optionalString usingNvimCmp "capabilities = require('cmp_nvim_lsp').default_capabilities()"}
+        -- ${optionalString usingNvimCmp "capabilities = require('cmp_nvim_lsp').default_capabilities()"}
       '';
     };
   };
diff --git a/modules/plugins/snippets/luasnip/config.nix b/modules/plugins/snippets/luasnip/config.nix
index 4fbbd2c..927b21f 100644
--- a/modules/plugins/snippets/luasnip/config.nix
+++ b/modules/plugins/snippets/luasnip/config.nix
@@ -4,7 +4,6 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.strings) optionalString;
 
   cfg = config.vim.snippets.luasnip;
 in {
@@ -16,20 +15,12 @@ in {
           lazy = true;
           after = cfg.loaders;
         };
-        cmp-luasnip = mkIf config.vim.autocomplete.nvim-cmp.enable {
-          package = "cmp-luasnip";
-          lazy = true;
-          after = ''
-            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-luasnip')
-            require("rtp_nvim").source_after_plugin_dir(path)
-          '';
-        };
-        nvim-cmp.after = optionalString config.vim.lazy.enable ''
-          require("lz.n").trigger_load("cmp-luasnip")
-        '';
       };
       startPlugins = cfg.providers;
-      autocomplete.nvim-cmp.sources = {luasnip = "[LuaSnip]";};
+      autocomplete.nvim-cmp = {
+        sources = {luasnip = "[LuaSnip]";};
+        sourcePlugins = ["cmp-luasnip"];
+      };
     };
   };
 }
diff --git a/modules/plugins/treesitter/config.nix b/modules/plugins/treesitter/config.nix
index e810d7e..e863d04 100644
--- a/modules/plugins/treesitter/config.nix
+++ b/modules/plugins/treesitter/config.nix
@@ -5,7 +5,7 @@
   ...
 }: let
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) optional optionals;
+  inherit (lib.lists) optionals;
   inherit (lib.nvim.binds) mkSetBinding addDescriptionsToMappings;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.dag) entryBefore entryAfter;
@@ -32,7 +32,11 @@ in {
         nvim-cmp.after = mkIf usingNvimCmp "require('lz.n').trigger_load('cmp-treesitter')";
       };
 
-      autocomplete.nvim-cmp.sources = {treesitter = "[Treesitter]";};
+      autocomplete.nvim-cmp = {
+        sources = {treesitter = "[Treesitter]";};
+        sourcePlugins = ["cmp-treesitter"];
+      };
+
       treesitter.grammars = optionals cfg.addDefaultGrammars cfg.defaultGrammars;
 
       maps = {
diff --git a/modules/plugins/utility/telescope/config.nix b/modules/plugins/utility/telescope/config.nix
index 37bdc0f..d42e1bb 100644
--- a/modules/plugins/utility/telescope/config.nix
+++ b/modules/plugins/utility/telescope/config.nix
@@ -1,6 +1,6 @@
 {
+  options,
   config,
-  pkgs,
   lib,
   ...
 }: let
@@ -11,8 +11,7 @@
   inherit (lib.nvim.binds) pushDownDefault mkSetLznBinding;
 
   cfg = config.vim.telescope;
-  self = import ./telescope.nix {inherit pkgs lib;};
-  mappingDefinitions = self.options.vim.telescope.mappings;
+  mappingDefinitions = options.vim.telescope.mappings;
 
   mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
 in {

From aac776f7a49f6199631384e4e4040ac6d12a6c9c Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 28 Oct 2024 02:31:47 +0100
Subject: [PATCH 49/70] Update docs/manual/hacking/additional-plugins.md

Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com>
---
 docs/manual/hacking/additional-plugins.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/manual/hacking/additional-plugins.md b/docs/manual/hacking/additional-plugins.md
index bd2d7a6..8531aa9 100644
--- a/docs/manual/hacking/additional-plugins.md
+++ b/docs/manual/hacking/additional-plugins.md
@@ -162,7 +162,7 @@ in {
 }
 ```
 
-This results in the lua code:
+This results in the following lua code:
 ```lua
 require('lz.n').load({
   {

From 12ed05bcfbbe013089dbc3fc18cb293f224fbd06 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 28 Oct 2024 02:26:56 +0100
Subject: [PATCH 50/70] lazy: refactor common var

---
 modules/wrapper/lazy/config.nix | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
index da5dd8c..a76a5cd 100644
--- a/modules/wrapper/lazy/config.nix
+++ b/modules/wrapper/lazy/config.nix
@@ -58,6 +58,8 @@
     };
   lznSpecs = mapAttrsToList toLuaLznSpec cfg.plugins;
 
+  pluginPackages = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
+
   specToNotLazyConfig = _: spec: ''
     do
       ${optionalString (spec.before != null) spec.before}
@@ -80,7 +82,7 @@ in {
     (mkIf cfg.enable {
       startPlugins = ["lz-n" "lzn-auto-require"];
 
-      optPlugins = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
+      optPlugins = pluginPackages;
 
       luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
         require('lz.n').load(${toLuaObject lznSpecs})
@@ -88,7 +90,7 @@ in {
     })
 
     (mkIf (!cfg.enable) {
-      startPlugins = mapAttrsToList (_: plugin: plugin.package) cfg.plugins;
+      startPlugins = pluginPackages;
       luaConfigPre =
         concatStringsSep "\n"
         (filter (x: x != null) (mapAttrsToList (_: spec: spec.beforeAll) cfg.plugins));

From eb95f77e75085cc864dabe07a43b273c24d7e171 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 28 Oct 2024 02:30:57 +0100
Subject: [PATCH 51/70] nvim-dap-ui: add setupOpts

---
 modules/plugins/debugger/nvim-dap/config.nix   | 2 +-
 modules/plugins/debugger/nvim-dap/nvim-dap.nix | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/modules/plugins/debugger/nvim-dap/config.nix b/modules/plugins/debugger/nvim-dap/config.nix
index 78e86a8..7e9e8f7 100644
--- a/modules/plugins/debugger/nvim-dap/config.nix
+++ b/modules/plugins/debugger/nvim-dap/config.nix
@@ -57,7 +57,7 @@ in {
         lazy.plugins.nvim-dap-ui = {
           package = "nvim-dap-ui";
           setupModule = "dapui";
-          setupOpts = {};
+          inherit (cfg.ui) setupOpts;
 
           keys = [
             (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
diff --git a/modules/plugins/debugger/nvim-dap/nvim-dap.nix b/modules/plugins/debugger/nvim-dap/nvim-dap.nix
index 3fab33a..5a69949 100644
--- a/modules/plugins/debugger/nvim-dap/nvim-dap.nix
+++ b/modules/plugins/debugger/nvim-dap/nvim-dap.nix
@@ -2,12 +2,16 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) bool attrsOf str;
   inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.debugger.nvim-dap = {
     enable = mkEnableOption "debugging via nvim-dap";
 
     ui = {
       enable = mkEnableOption "UI extension for nvim-dap";
+
+      setupOpts = mkPluginSetupOption "nvim-dap-ui" {};
+
       autoStart = mkOption {
         type = bool;
         default = true;

From 192340494b4f66a8fdd729edbb597206b080aa4e Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 28 Oct 2024 02:48:42 +0100
Subject: [PATCH 52/70] refactor: re-order plugin and lz.n configs

lazy: make lzn-auto-require togglable
---
 modules/wrapper/lazy/config.nix | 19 +++++++++++++------
 modules/wrapper/lazy/lazy.nix   | 20 +++++++++++++++++++-
 modules/wrapper/rc/config.nix   |  5 ++---
 3 files changed, 34 insertions(+), 10 deletions(-)

diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
index a76a5cd..01deeb0 100644
--- a/modules/wrapper/lazy/config.nix
+++ b/modules/wrapper/lazy/config.nix
@@ -76,7 +76,13 @@
     then []
     else [spec.keys];
 
-  notLazyConfig = concatStringsSep "\n" (mapAttrsToList specToNotLazyConfig cfg.plugins);
+  notLazyConfig =
+    concatStringsSep "\n"
+    (mapAttrsToList specToNotLazyConfig cfg.plugins);
+
+  beforeAllJoined =
+    concatStringsSep "\n"
+    (filter (x: x != null) (mapAttrsToList (_: spec: spec.beforeAll) cfg.plugins));
 in {
   config.vim = mkMerge [
     (mkIf cfg.enable {
@@ -84,17 +90,18 @@ in {
 
       optPlugins = pluginPackages;
 
-      luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
+      lazy.builtLazyConfig = ''
         require('lz.n').load(${toLuaObject lznSpecs})
+        ${optionalString cfg.enableLznAutoRequire "require('lzn-auto-require').enable()"}
       '';
     })
 
     (mkIf (!cfg.enable) {
       startPlugins = pluginPackages;
-      luaConfigPre =
-        concatStringsSep "\n"
-        (filter (x: x != null) (mapAttrsToList (_: spec: spec.beforeAll) cfg.plugins));
-      luaConfigRC.unlazy = entryAfter ["pluginConfigs"] notLazyConfig;
+      lazy.builtLazyConfig = ''
+        ${beforeAllJoined}
+        ${notLazyConfig}
+      '';
       keymaps = concatLists (mapAttrsToList specToKeymaps cfg.plugins);
     })
   ];
diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
index fc130af..5b2c53d 100644
--- a/modules/wrapper/lazy/lazy.nix
+++ b/modules/wrapper/lazy/lazy.nix
@@ -181,7 +181,7 @@
   };
 in {
   options.vim.lazy = {
-    enable = mkEnableOption "plugin lazy-loading" // {default = true;};
+    enable = mkEnableOption "plugin lazy-loading via lz.n and lzn-auto-require" // {default = true;};
     loader = mkOption {
       description = "Lazy loader to use";
       type = enum ["lz.n"];
@@ -215,5 +215,23 @@ in {
         }
       '';
     };
+
+    enableLznAutoRequire = mkOption {
+      description = ''
+        Enable lzn-auto-require. Since builtin plugins rely on this, only turn
+        off for debugging.
+      '';
+      type = bool;
+      default = true;
+    };
+
+    builtLazyConfig = mkOption {
+      internal = true;
+      type = lines;
+      description = ''
+        The built config for lz.n, or if `vim.lazy.enable` is false, the
+        individual plugin configs.
+      '';
+    };
   };
 }
diff --git a/modules/wrapper/rc/config.nix b/modules/wrapper/rc/config.nix
index 25fc9bc..627fd05 100644
--- a/modules/wrapper/rc/config.nix
+++ b/modules/wrapper/rc/config.nix
@@ -52,11 +52,10 @@ in {
         optionsScript = entryAfter ["basic"] (concatLines optionsScript);
 
         # Basic
-        pluginConfigs = entryAfter ["optionsScript"] pluginConfigs;
+        lazyConfigs = entryAfter ["optionsScript"] cfg.lazy.builtLazyConfig;
+        pluginConfigs = entryAfter ["lazyConfigs"] pluginConfigs;
         extraPluginConfigs = entryAfter ["pluginConfigs"] extraPluginConfigs;
         mappings = entryAfter ["extraPluginConfigs"] keymaps;
-        # FIXME: put this somewhere less stupid
-        footer = entryAfter ["mappings"] (optionalString config.vim.lazy.enable "require('lzn-auto-require').enable()");
       };
 
       builtLuaConfigRC = let

From 536feac3312f1c7a0cee557b2cd0dfe365803844 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 28 Oct 2024 02:52:08 +0100
Subject: [PATCH 53/70] docs: update dag-entries

---
 docs/manual/configuring/dag-entries.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/docs/manual/configuring/dag-entries.md b/docs/manual/configuring/dag-entries.md
index 402cde6..32dd4c6 100644
--- a/docs/manual/configuring/dag-entries.md
+++ b/docs/manual/configuring/dag-entries.md
@@ -15,9 +15,11 @@ entries in nvf:
 5. `theme` (this is simply placed before `pluginConfigs`, meaning that
    surrounding entries don't depend on it) - used to set up the theme, which has
    to be done before other plugins
-6. `pluginConfigs` - the result of the nested `vim.pluginRC` (internal option,
+6. `lazyConfigs` - `lz.n` and `lzn-auto-require` configs. If `vim.lazy.enable`
+   is false, this will contain each plugin's config instead.
+7. `pluginConfigs` - the result of the nested `vim.pluginRC` (internal option,
    see the [Custom Plugins](/index.xhtml#ch-custom-plugins) page for adding your
    own plugins) DAG, used to set up internal plugins
-7. `extraPluginConfigs` - the result of `vim.extraPlugins`, which is not a
+8. `extraPluginConfigs` - the result of `vim.extraPlugins`, which is not a
    direct DAG, but is converted to, and resolved as one internally
-8. `mappings` - the result of `vim.maps`
+9. `mappings` - the result of `vim.maps`

From b59689dbd94aef129359ef0d3b4907543fc38e1f Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Mon, 28 Oct 2024 03:04:53 +0100
Subject: [PATCH 54/70] trouble: remove redundant import

---
 modules/plugins/lsp/trouble/config.nix | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/plugins/lsp/trouble/config.nix b/modules/plugins/lsp/trouble/config.nix
index e4b966a..cae0c7a 100644
--- a/modules/plugins/lsp/trouble/config.nix
+++ b/modules/plugins/lsp/trouble/config.nix
@@ -1,6 +1,7 @@
 {
   config,
   lib,
+  options,
   ...
 }: let
   inherit (lib.modules) mkIf;
@@ -8,8 +9,7 @@
 
   cfg = config.vim.lsp;
 
-  self = import ./trouble.nix {inherit lib;};
-  mappingDefinitions = self.options.vim.lsp.trouble.mappings;
+  mappingDefinitions = options.vim.lsp.trouble.mappings;
   mappings = addDescriptionsToMappings cfg.trouble.mappings mappingDefinitions;
 in {
   config = mkIf (cfg.enable && cfg.trouble.enable) {

From 9360becd30ef2a845eefa3888a051a1be9775afc Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Thu, 31 Oct 2024 13:51:51 +0100
Subject: [PATCH 55/70] lazy: remove unused module arg

---
 modules/wrapper/lazy/default.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/wrapper/lazy/default.nix b/modules/wrapper/lazy/default.nix
index fa40127..671516b 100644
--- a/modules/wrapper/lazy/default.nix
+++ b/modules/wrapper/lazy/default.nix
@@ -1,4 +1,4 @@
-_: {
+{
   imports = [
     ./lazy.nix
     ./config.nix

From 7543cc272512b687a9dae45c3c24169bcf7f8f36 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Thu, 31 Oct 2024 13:57:13 +0100
Subject: [PATCH 56/70] toggleterm: make lazygit keybind optional

---
 modules/plugins/terminal/toggleterm/config.nix | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/modules/plugins/terminal/toggleterm/config.nix b/modules/plugins/terminal/toggleterm/config.nix
index d96e480..68be3de 100644
--- a/modules/plugins/terminal/toggleterm/config.nix
+++ b/modules/plugins/terminal/toggleterm/config.nix
@@ -5,6 +5,7 @@
 }: let
   inherit (builtins) toJSON;
   inherit (lib.strings) optionalString;
+  inherit (lib.lists) optional;
   inherit (lib.modules) mkIf;
   inherit (lib.meta) getExe;
   inherit (lib.nvim.binds) mkLznBinding;
@@ -17,13 +18,12 @@ in {
       lazy.plugins.toggleterm-nvim = {
         package = "toggleterm-nvim";
         cmd = ["ToggleTerm" "ToggleTermSendCurrentLine" "ToggleTermSendVisualLines" "ToggleTermSendVisualSelection" "ToggleTermSetName" "ToggleTermToggleAll"];
-        keys = [
-          (mkLznBinding ["n"] cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal")
-          {
+        keys =
+          [(mkLznBinding ["n"] cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal")]
+          ++ optional cfg.lazygit.enable {
             key = cfg.lazygit.mappings.open;
             desc = lazygitMapDesc;
-          }
-        ];
+          };
 
         setupModule = "toggleterm";
         inherit (cfg) setupOpts;

From 11e0b9a031ca31583e2b84a2ea2c9a6e0c9fbfd4 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Thu, 31 Oct 2024 13:58:59 +0100
Subject: [PATCH 57/70] toggleterm: use toLuaObject for clarity

---
 modules/plugins/terminal/toggleterm/config.nix | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/plugins/terminal/toggleterm/config.nix b/modules/plugins/terminal/toggleterm/config.nix
index 68be3de..f0ebd72 100644
--- a/modules/plugins/terminal/toggleterm/config.nix
+++ b/modules/plugins/terminal/toggleterm/config.nix
@@ -3,12 +3,12 @@
   lib,
   ...
 }: let
-  inherit (builtins) toJSON;
   inherit (lib.strings) optionalString;
   inherit (lib.lists) optional;
   inherit (lib.modules) mkIf;
   inherit (lib.meta) getExe;
   inherit (lib.nvim.binds) mkLznBinding;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.terminal.toggleterm;
   lazygitMapDesc = "Open lazygit [toggleterm]";
@@ -42,7 +42,7 @@ in {
             end
           })
 
-          vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
+          vim.keymap.set('n', ${toLuaObject cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
         '';
       };
     };

From de6e70138669deec0484cab73914d3669e775e4d Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Thu, 31 Oct 2024 14:16:46 +0100
Subject: [PATCH 58/70] surround: rework keymap config

---
 modules/plugins/utility/surround/config.nix   | 52 +++++++++----------
 modules/plugins/utility/surround/surround.nix | 49 +++++++++++++++--
 2 files changed, 72 insertions(+), 29 deletions(-)

diff --git a/modules/plugins/utility/surround/config.nix b/modules/plugins/utility/surround/config.nix
index 4ce15ca..7161cf6 100644
--- a/modules/plugins/utility/surround/config.nix
+++ b/modules/plugins/utility/surround/config.nix
@@ -8,19 +8,6 @@
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.utility.surround;
-  vendoredKeybinds = {
-    insert = "<C-g>z";
-    insert_line = "<C-g>Z";
-    normal = "gz";
-    normal_cur = "gZ";
-    normal_line = "gzz";
-    normal_cur_line = "gZZ";
-    visual = "gz";
-    visual_line = "gZ";
-    delete = "gzd";
-    change = "gzr";
-    change_line = "gZR";
-  };
   mkLznKey = mode: key: {
     inherit key mode;
   };
@@ -36,20 +23,33 @@ in {
         inherit (cfg) setupOpts;
 
         keys =
-          map (mkLznKey ["i"]) (with vendoredKeybinds; [insert insert_line])
-          ++ map (mkLznKey ["x"]) (with vendoredKeybinds; [visual visual_line])
-          ++ map (mkLznKey ["n"]) (with vendoredKeybinds; [
-            normal
-            normal_cur
-            normal_line
-            normal_cur_line
-            delete
-            change
-            change_line
-          ]);
+          [
+            (mkLznKey ["i"] cfg.setupOpts.keymaps.insert)
+            (mkLznKey ["i"] cfg.setupOpts.keymaps.insert_line)
+            (mkLznKey ["x"] cfg.setupOpts.keymaps.visual)
+            (mkLznKey ["x"] cfg.setupOpts.keymaps.visual_line)
+            (mkLznKey ["n"] cfg.setupOpts.keymaps.normal)
+            (mkLznKey ["n"] cfg.setupOpts.keymaps.normal_cur)
+            (mkLznKey ["n"] cfg.setupOpts.keymaps.normal_line)
+            (mkLznKey ["n"] cfg.setupOpts.keymaps.normal_cur_line)
+            (mkLznKey ["n"] cfg.setupOpts.keymaps.delete)
+            (mkLznKey ["n"] cfg.setupOpts.keymaps.change)
+            (mkLznKey ["n"] cfg.setupOpts.keymaps.change_line)
+          ]
+          ++ map (mkLznKey ["n" "i" "v"]) [
+            "<Plug>(nvim-surround-insert)"
+            "<Plug>(nvim-surround-insert-line)"
+            "<Plug>(nvim-surround-normal)"
+            "<Plug>(nvim-surround-normal-cur)"
+            "<Plug>(nvim-surround-normal-line)"
+            "<Plug>(nvim-surround-normal-cur-line)"
+            "<Plug>(nvim-surround-visual)"
+            "<Plug>(nvim-surround-visual-line)"
+            "<Plug>(nvim-surround-delete)"
+            "<Plug>(nvim-surround-change)"
+            "<Plug>(nvim-surround-change-line)"
+          ];
       };
-
-      utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings vendoredKeybinds;
     };
   };
 }
diff --git a/modules/plugins/utility/surround/surround.nix b/modules/plugins/utility/surround/surround.nix
index 7d00638..d74966a 100644
--- a/modules/plugins/utility/surround/surround.nix
+++ b/modules/plugins/utility/surround/surround.nix
@@ -1,7 +1,36 @@
-{lib, ...}: let
+{
+  lib,
+  config,
+  ...
+}: let
   inherit (lib.options) mkOption;
-  inherit (lib.types) bool;
+  inherit (lib.types) bool str;
   inherit (lib.nvim.types) mkPluginSetupOption;
+
+  cfg = config.vim.utility.surround;
+  vendoredKeybinds = {
+    insert = "<C-g>z";
+    insert_line = "<C-g>Z";
+    normal = "gz";
+    normal_cur = "gZ";
+    normal_line = "gzz";
+    normal_cur_line = "gZZ";
+    visual = "gz";
+    visual_line = "gZ";
+    delete = "gzd";
+    change = "gzr";
+    change_line = "gZR";
+  };
+
+  mkKeymapOption = name: default:
+    mkOption {
+      description = "keymap for ${name}";
+      type = str;
+      default =
+        if cfg.useVendoredKeybindings
+        then vendoredKeybinds.${name}
+        else default;
+    };
 in {
   options.vim.utility.surround = {
     enable = mkOption {
@@ -13,7 +42,21 @@ in {
         with nvim-leap.
       '';
     };
-    setupOpts = mkPluginSetupOption "nvim-surround" {};
+    setupOpts = mkPluginSetupOption "nvim-surround" {
+      keymaps = {
+        insert = mkKeymapOption "insert" "<C-g>s";
+        insert_line = mkKeymapOption "insert_line" "<C-g>S";
+        normal = mkKeymapOption "normal" "ys";
+        normal_cur = mkKeymapOption "normal_cur" "yss";
+        normal_line = mkKeymapOption "normal_line" "yS";
+        normal_cur_line = mkKeymapOption "normal_cur_line" "ySS";
+        visual = mkKeymapOption "visual" "S";
+        visual_line = mkKeymapOption "visual_line" "gS";
+        delete = mkKeymapOption "delete" "ds";
+        change = mkKeymapOption "change" "cs";
+        change_line = mkKeymapOption "change_line" "cS";
+      };
+    };
 
     useVendoredKeybindings = mkOption {
       type = bool;

From bf54ca3cb2ad5209a9c6e43e6d16bf3257f9151a Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Thu, 31 Oct 2024 14:19:07 +0100
Subject: [PATCH 59/70] remove stale FIXME

---
 modules/plugins/utility/telescope/config.nix | 1 -
 1 file changed, 1 deletion(-)

diff --git a/modules/plugins/utility/telescope/config.nix b/modules/plugins/utility/telescope/config.nix
index d42e1bb..6143627 100644
--- a/modules/plugins/utility/telescope/config.nix
+++ b/modules/plugins/utility/telescope/config.nix
@@ -23,7 +23,6 @@ in {
         package = "telescope";
         setupModule = "telescope";
         inherit (cfg) setupOpts;
-        # FIXME: how do I deal with extensions? set all as deps?
         after = ''
           local telescope = require("telescope")
           ${optionalString config.vim.ui.noice.enable "telescope.load_extension('noice')"}

From 834aee6cce05df336acc4f3b7f6ee4a6be9269af Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 17:55:51 +0100
Subject: [PATCH 60/70] lsp: use cmp_nvim_lsp capabilities

---
 modules/plugins/lsp/config.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/plugins/lsp/config.nix b/modules/plugins/lsp/config.nix
index 841e28b..c9581d0 100644
--- a/modules/plugins/lsp/config.nix
+++ b/modules/plugins/lsp/config.nix
@@ -116,7 +116,7 @@ in {
         end
 
         local capabilities = vim.lsp.protocol.make_client_capabilities()
-        -- ${optionalString usingNvimCmp "capabilities = require('cmp_nvim_lsp').default_capabilities()"}
+        ${optionalString usingNvimCmp "capabilities = require('cmp_nvim_lsp').default_capabilities()"}
       '';
     };
   };

From 347a04b62e6fa57323e7b7fe3b1ff8d40624f3ec Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 18:02:50 +0100
Subject: [PATCH 61/70] cmp: deduplicate attr key

---
 .../plugins/completion/nvim-cmp/config.nix    | 80 +++++++++----------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/modules/plugins/completion/nvim-cmp/config.nix b/modules/plugins/completion/nvim-cmp/config.nix
index 27d0bfb..4d4c257 100644
--- a/modules/plugins/completion/nvim-cmp/config.nix
+++ b/modules/plugins/completion/nvim-cmp/config.nix
@@ -74,50 +74,50 @@ in {
           };
 
           formatting.format = cfg.format;
-        };
 
-        # `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
-        setupOpts.mapping = {
-          ${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
-          ${mappings.close} = mkLuaInline "cmp.mapping.abort()";
-          ${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
-          ${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
-          ${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
+          # `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
+          mapping = {
+            ${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
+            ${mappings.close} = mkLuaInline "cmp.mapping.abort()";
+            ${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
+            ${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
+            ${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
 
-          ${mappings.next} = mkLuaInline ''
-            cmp.mapping(function(fallback)
-              local has_words_before = function()
-                local line, col = unpack(vim.api.nvim_win_get_cursor(0))
-                return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
-              end
+            ${mappings.next} = mkLuaInline ''
+              cmp.mapping(function(fallback)
+                local has_words_before = function()
+                  local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+                  return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
+                end
 
-              if cmp.visible() then
-                cmp.select_next_item()
-                ${optionalString luasnipEnable ''
-              elseif luasnip.locally_jumpable(1) then
-                luasnip.jump(1)
-            ''}
-              elseif has_words_before() then
-                cmp.complete()
-              else
-                fallback()
-              end
-            end)
-          '';
+                if cmp.visible() then
+                  cmp.select_next_item()
+                  ${optionalString luasnipEnable ''
+                elseif luasnip.locally_jumpable(1) then
+                  luasnip.jump(1)
+              ''}
+                elseif has_words_before() then
+                  cmp.complete()
+                else
+                  fallback()
+                end
+              end)
+            '';
 
-          ${mappings.previous} = mkLuaInline ''
-            cmp.mapping(function(fallback)
-              if cmp.visible() then
-                cmp.select_prev_item()
-                ${optionalString luasnipEnable ''
-              elseif luasnip.locally_jumpable(-1) then
-                luasnip.jump(-1)
-            ''}
-              else
-                fallback()
-              end
-            end)
-          '';
+            ${mappings.previous} = mkLuaInline ''
+              cmp.mapping(function(fallback)
+                if cmp.visible() then
+                  cmp.select_prev_item()
+                  ${optionalString luasnipEnable ''
+                elseif luasnip.locally_jumpable(-1) then
+                  luasnip.jump(-1)
+              ''}
+                else
+                  fallback()
+                end
+              end)
+            '';
+          };
         };
       };
     };

From a4f03076bfb1805d2fc848ed7a980f0a0e00d5b8 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 18:12:08 +0100
Subject: [PATCH 62/70] theme: ensure themes load before lazy plugins

---
 modules/plugins/theme/theme.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/plugins/theme/theme.nix b/modules/plugins/theme/theme.nix
index 0422c02..b3147c0 100644
--- a/modules/plugins/theme/theme.nix
+++ b/modules/plugins/theme/theme.nix
@@ -66,7 +66,7 @@ in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = [cfg.name];
-      luaConfigRC.theme = entryBefore ["pluginConfigs"] ''
+      luaConfigRC.theme = entryBefore ["pluginConfigs" "lazyConfigs"] ''
         ${cfg.extraConfig}
         ${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent base16-colors;}}
       '';

From 5e6677fb1a48939a11a99f3394ca5b34478ea798 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 18:13:26 +0100
Subject: [PATCH 63/70] doc: update description of `theme` dag entry

---
 docs/manual/configuring/dag-entries.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/manual/configuring/dag-entries.md b/docs/manual/configuring/dag-entries.md
index 32dd4c6..ff5d5c7 100644
--- a/docs/manual/configuring/dag-entries.md
+++ b/docs/manual/configuring/dag-entries.md
@@ -12,9 +12,9 @@ entries in nvf:
 2. `globalsScript` - used to set globals defined in `vim.globals`
 3. `basic` - used to set basic configuration options
 4. `optionsScript` - used to set options defined in `vim.o`
-5. `theme` (this is simply placed before `pluginConfigs`, meaning that
-   surrounding entries don't depend on it) - used to set up the theme, which has
-   to be done before other plugins
+5. `theme` (this is simply placed before `pluginConfigs` and `lazyConfigs`, meaning that
+   surrounding entries don't depend on it) - used to set up the theme, which has to be done before
+   other plugins
 6. `lazyConfigs` - `lz.n` and `lzn-auto-require` configs. If `vim.lazy.enable`
    is false, this will contain each plugin's config instead.
 7. `pluginConfigs` - the result of the nested `vim.pluginRC` (internal option,

From 02676d4224850886e8026f48919dbbe5ed330591 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 18:34:43 +0100
Subject: [PATCH 64/70] lsp: avoid loading cmp on startup

---
 modules/plugins/lsp/config.nix | 55 +++++++++++++++++++++++++++++++++-
 1 file changed, 54 insertions(+), 1 deletion(-)

diff --git a/modules/plugins/lsp/config.nix b/modules/plugins/lsp/config.nix
index c9581d0..4109c5c 100644
--- a/modules/plugins/lsp/config.nix
+++ b/modules/plugins/lsp/config.nix
@@ -116,7 +116,60 @@ in {
         end
 
         local capabilities = vim.lsp.protocol.make_client_capabilities()
-        ${optionalString usingNvimCmp "capabilities = require('cmp_nvim_lsp').default_capabilities()"}
+        ${optionalString usingNvimCmp ''
+          -- TODO: copied from cmp-nvim-lsp. If we ever lazy load lspconfig we
+          -- should re-evaluate whether we can just use `default_capabilities`
+          capabilities = {
+            textDocument = {
+              completion = {
+                dynamicRegistration = false,
+                completionItem = {
+                  snippetSupport = true,
+                  commitCharactersSupport = true,
+                  deprecatedSupport = true,
+                  preselectSupport = true,
+                  tagSupport = {
+                    valueSet = {
+                      1, -- Deprecated
+                    }
+                  },
+                  insertReplaceSupport = true,
+                  resolveSupport = {
+                    properties = {
+                      "documentation",
+                      "detail",
+                      "additionalTextEdits",
+                      "sortText",
+                      "filterText",
+                      "insertText",
+                      "textEdit",
+                      "insertTextFormat",
+                      "insertTextMode",
+                    },
+                  },
+                  insertTextModeSupport = {
+                    valueSet = {
+                      1, -- asIs
+                      2, -- adjustIndentation
+                    }
+                  },
+                  labelDetailsSupport = true,
+                },
+                contextSupport = true,
+                insertTextMode = 1,
+                completionList = {
+                  itemDefaults = {
+                    'commitCharacters',
+                    'editRange',
+                    'insertTextFormat',
+                    'insertTextMode',
+                    'data',
+                  }
+                }
+              },
+            },
+          }
+        ''}
       '';
     };
   };

From 850465faba24e70731d34b3db6a8b4e4cb82f721 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 18:43:28 +0100
Subject: [PATCH 65/70] doc: update configuration docs on custom plugins

---
 docs/manual/configuring/custom-plugins.md     |  5 ++-
 .../configuring/custom-plugins/configuring.md | 36 +++++++++++++----
 .../configuring/custom-plugins/lazy-method.md | 40 +++++++++++++++++++
 .../{old-method.md => legacy-method.md}       |  2 +-
 .../{new-method.md => non-lazy-method.md}     |  2 +-
 5 files changed, 73 insertions(+), 12 deletions(-)
 create mode 100644 docs/manual/configuring/custom-plugins/lazy-method.md
 rename docs/manual/configuring/custom-plugins/{old-method.md => legacy-method.md} (96%)
 rename docs/manual/configuring/custom-plugins/{new-method.md => non-lazy-method.md} (93%)

diff --git a/docs/manual/configuring/custom-plugins.md b/docs/manual/configuring/custom-plugins.md
index c58c497..76b32ea 100644
--- a/docs/manual/configuring/custom-plugins.md
+++ b/docs/manual/configuring/custom-plugins.md
@@ -20,6 +20,7 @@ custom plugins that you might have added to your configuration.
 
 ```{=include=} sections
 custom-plugins/configuring.md
-custom-plugins/new-method.md
-custom-plugins/old-method.md
+custom-plugins/lazy-method.md
+custom-plugins/non-lazy-method.md
+custom-plugins/legacy-method.md
 ```
diff --git a/docs/manual/configuring/custom-plugins/configuring.md b/docs/manual/configuring/custom-plugins/configuring.md
index 5e837ce..71ce9b8 100644
--- a/docs/manual/configuring/custom-plugins/configuring.md
+++ b/docs/manual/configuring/custom-plugins/configuring.md
@@ -1,12 +1,32 @@
 # Configuring {#sec-configuring-plugins}
 
-Just making the plugin to your Neovim configuration available might not always
-be enough. In that case, you can write custom lua config using either
-`config.vim.extraPlugins` (which has the `setup` field) or
-`config.vim.luaConfigRC`. The first option uses an attribute set, which maps DAG
-section names to a custom type, which has the fields `package`, `after`,
-`setup`. They allow you to set the package of the plugin, the sections its setup
-code should be after (note that the `extraPlugins` option has its own DAG
+Just making the plugin to your Neovim configuration available might not always be enough. In that
+case, you can write custom lua config using either `config.vim.lazy.plugins.*.setupOpts`
+`config.vim.extraPlugins.*.setup` or `config.vim.luaConfigRC`. 
+
+The first option uses an extended version of `lz.n`'s PluginSpec. `setupModule` and `setupOpt` can
+be used if the plugin uses a `require('module').setup(...)` pattern. Otherwise, the `before` and
+`after` hooks should do what you need.
+
+```nix
+{
+  config.vim.lazy.plugins = {
+    aerial-nvim = {
+      # ^^^^^^^^^ this name should match the package.pname or package.name
+      package = aerial-nvim;
+
+      setupModule = "aerial";
+      setupOpts = {option_name = false;};
+
+      after = "print('aerial loaded')";
+    };
+  };
+}
+```
+
+The second option uses an attribute set, which maps DAG section names to a custom type, which has
+the fields `package`, `after`, `setup`. They allow you to set the package of the plugin, the
+sections its setup code should be after (note that the `extraPlugins` option has its own DAG
 scope), and the its setup code respectively. For example:
 
 ```nix
@@ -24,7 +44,7 @@ config.vim.extraPlugins = with pkgs.vimPlugins; {
 }
 ```
 
-The second option also uses an attribute set, but this one is resolved as a DAG
+The third option also uses an attribute set, but this one is resolved as a DAG
 directly. The attribute names denote the section names, and the values lua code.
 For example:
 
diff --git a/docs/manual/configuring/custom-plugins/lazy-method.md b/docs/manual/configuring/custom-plugins/lazy-method.md
new file mode 100644
index 0000000..77b77d5
--- /dev/null
+++ b/docs/manual/configuring/custom-plugins/lazy-method.md
@@ -0,0 +1,40 @@
+# Lazy Method {#sec-lazy-method}
+
+As of version **0.7**, we exposed an API for configuring lazy-loaded plugins via
+`lz.n` and `lzn-auto-require`.
+
+```nix
+{
+  config.vim.lazy.plugins = {
+    aerial = {
+      package = pkgs.vimPlugins.aerial-nvim;
+      setupModule = aerial;
+      setupOpts = {
+        option_name = true;
+      };
+      after = ''
+        -- custom lua code to run after plugin is loaded
+        print('aerial loaded')
+      '';
+
+      # Explicitly mark plugin as lazy. You don't need this if you define one of
+      # the trigger "events" below
+      lazy = true;
+
+      # load on command
+      cmd = ["AerialOpen"];
+
+      # load on event
+      event = ["BufEnter"];
+
+      # load on keymap
+      keys = [
+        {
+          key = "<leader>a";
+          action = ":AerialToggle<CR>";
+        }
+      ];
+    };
+  };
+}
+```
diff --git a/docs/manual/configuring/custom-plugins/old-method.md b/docs/manual/configuring/custom-plugins/legacy-method.md
similarity index 96%
rename from docs/manual/configuring/custom-plugins/old-method.md
rename to docs/manual/configuring/custom-plugins/legacy-method.md
index 3b9d090..0a6b377 100644
--- a/docs/manual/configuring/custom-plugins/old-method.md
+++ b/docs/manual/configuring/custom-plugins/legacy-method.md
@@ -1,4 +1,4 @@
-# Old Method {#sec-old-method}
+# Legacy Method {#sec-legacy-method}
 
 Prior to version 0.5, the method of adding new plugins was adding the plugin
 package to `vim.startPlugins` and add its configuration as a DAG under one of
diff --git a/docs/manual/configuring/custom-plugins/new-method.md b/docs/manual/configuring/custom-plugins/non-lazy-method.md
similarity index 93%
rename from docs/manual/configuring/custom-plugins/new-method.md
rename to docs/manual/configuring/custom-plugins/non-lazy-method.md
index 200ba5e..351af2e 100644
--- a/docs/manual/configuring/custom-plugins/new-method.md
+++ b/docs/manual/configuring/custom-plugins/non-lazy-method.md
@@ -1,4 +1,4 @@
-# New Method {#sec-new-method}
+# Non-lazy Method {#sec-non-lazy-method}
 
 As of version **0.5**, we have a more extensive API for configuring plugins,
 under `vim.extraPlugins`. Instead of using DAGs exposed by the library, you may

From d3ff60bd4c675d79232e1bb8369ae2c7610f775f Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 19:00:25 +0100
Subject: [PATCH 66/70] cmp: skip trigger_load if lazy disabled

---
 modules/plugins/completion/nvim-cmp/config.nix | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/modules/plugins/completion/nvim-cmp/config.nix b/modules/plugins/completion/nvim-cmp/config.nix
index 4d4c257..54670ac 100644
--- a/modules/plugins/completion/nvim-cmp/config.nix
+++ b/modules/plugins/completion/nvim-cmp/config.nix
@@ -41,13 +41,13 @@ in {
             package = "nvim-cmp";
             after = ''
               ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
-                  require("lz.n").trigger_load("cmp-path")
               local cmp = require("cmp")
               cmp.setup(${toLuaObject cfg.setupOpts})
 
-              ${concatStringsSep "\n" (map
-                (package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
-                cfg.sourcePlugins)}
+              ${optionalString config.vim.lazy.enable
+                (concatStringsSep "\n" (map
+                  (package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
+                  cfg.sourcePlugins))}
             '';
 
             event = ["InsertEnter" "CmdlineEnter"];

From 6ef34511b16958b20146f9597d315f8ff6188ee5 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 19:00:51 +0100
Subject: [PATCH 67/70] treesitter: remove redundant code

---
 modules/plugins/treesitter/config.nix | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/modules/plugins/treesitter/config.nix b/modules/plugins/treesitter/config.nix
index e863d04..566a716 100644
--- a/modules/plugins/treesitter/config.nix
+++ b/modules/plugins/treesitter/config.nix
@@ -11,7 +11,6 @@
   inherit (lib.nvim.dag) entryBefore entryAfter;
 
   cfg = config.vim.treesitter;
-  usingNvimCmp = config.vim.autocomplete.nvim-cmp.enable;
 
   self = import ./treesitter.nix {inherit pkgs lib;};
   mappingDefinitions = self.options.vim.treesitter.mappings;
@@ -21,17 +20,6 @@ in {
     vim = {
       startPlugins = ["nvim-treesitter"];
 
-      lazy.plugins = {
-        cmp-treesitter = mkIf usingNvimCmp {
-          package = "cmp-treesitter";
-          after = ''
-            local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/cmp-treesitter')
-            require("rtp_nvim").source_after_plugin_dir(path)
-          '';
-        };
-        nvim-cmp.after = mkIf usingNvimCmp "require('lz.n').trigger_load('cmp-treesitter')";
-      };
-
       autocomplete.nvim-cmp = {
         sources = {treesitter = "[Treesitter]";};
         sourcePlugins = ["cmp-treesitter"];

From e57ef1db64f24c749a6d247369eac1734725a07a Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 19:26:06 +0100
Subject: [PATCH 68/70] lsp: mark hack as HACK

---
 modules/plugins/lsp/config.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/plugins/lsp/config.nix b/modules/plugins/lsp/config.nix
index 4109c5c..2994934 100644
--- a/modules/plugins/lsp/config.nix
+++ b/modules/plugins/lsp/config.nix
@@ -117,7 +117,7 @@ in {
 
         local capabilities = vim.lsp.protocol.make_client_capabilities()
         ${optionalString usingNvimCmp ''
-          -- TODO: copied from cmp-nvim-lsp. If we ever lazy load lspconfig we
+          -- HACK: copied from cmp-nvim-lsp. If we ever lazy load lspconfig we
           -- should re-evaluate whether we can just use `default_capabilities`
           capabilities = {
             textDocument = {

From af9f09762a6b18d441f0fe9d34f12142031d2083 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 3 Nov 2024 19:28:24 +0100
Subject: [PATCH 69/70] comment: remove redundant plugin

---
 modules/plugins/comments/comment-nvim/config.nix | 2 --
 1 file changed, 2 deletions(-)

diff --git a/modules/plugins/comments/comment-nvim/config.nix b/modules/plugins/comments/comment-nvim/config.nix
index 0fde788..c2c1a7e 100644
--- a/modules/plugins/comments/comment-nvim/config.nix
+++ b/modules/plugins/comments/comment-nvim/config.nix
@@ -11,8 +11,6 @@
   inherit (self.options.vim.comments.comment-nvim) mappings;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = ["comment-nvim"];
-
     vim.lazy.plugins.comment-nvim = {
       package = "comment-nvim";
       setupModule = "Comment";

From 3dfd83f38971b943a255bd65daa6e2842f1c35e1 Mon Sep 17 00:00:00 2001
From: diniamo <diniamo53@gmail.com>
Date: Mon, 4 Nov 2024 09:34:16 +0100
Subject: [PATCH 70/70] nvim-cmp: move text and snippet completions to the
 bottom

This doesn't guarantee that snippets will be above text completions, but
that should still be the case, since the `kind` comparator sorts
snippets above text.
---
 modules/plugins/completion/nvim-cmp/config.nix   | 14 ++++++++++++++
 modules/plugins/completion/nvim-cmp/nvim-cmp.nix |  8 ++++++++
 2 files changed, 22 insertions(+)

diff --git a/modules/plugins/completion/nvim-cmp/config.nix b/modules/plugins/completion/nvim-cmp/config.nix
index 54670ac..b50d726 100644
--- a/modules/plugins/completion/nvim-cmp/config.nix
+++ b/modules/plugins/completion/nvim-cmp/config.nix
@@ -42,6 +42,20 @@ in {
             after = ''
               ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
               local cmp = require("cmp")
+
+              local kinds = require("cmp.types").lsp.CompletionItemKind
+              local deprio = function(kind)
+                return function(e1, e2)
+                  if e1:get_kind() == kind then
+                    return false
+                  end
+                  if e2:get_kind() == kind then
+                    return true
+                  end
+                  return nil
+                end
+              end
+
               cmp.setup(${toLuaObject cfg.setupOpts})
 
               ${optionalString config.vim.lazy.enable
diff --git a/modules/plugins/completion/nvim-cmp/nvim-cmp.nix b/modules/plugins/completion/nvim-cmp/nvim-cmp.nix
index 8246e71..ae3e9e2 100644
--- a/modules/plugins/completion/nvim-cmp/nvim-cmp.nix
+++ b/modules/plugins/completion/nvim-cmp/nvim-cmp.nix
@@ -29,6 +29,8 @@ in {
       sorting.comparators = mkOption {
         type = mergelessListOf (either str luaInline);
         default = [
+          (mkLuaInline "deprio(kinds.Text)")
+          (mkLuaInline "deprio(kinds.Snippet)")
           "offset"
           "exact"
           "score"
@@ -43,6 +45,12 @@ in {
           (see `:help cmp-config.sorting.comparators`),
           or a string, in which case the builtin comparator with that name will
           be used.
+
+          A `deprio` function and a `kinds`
+          (`require("cmp.types").lsp.CompletionItemKind`) variable is provided
+          above `setupOpts`. By passing a type to the funcion, the returned
+          funciton will be a comparator that always ranks the specified kind the
+          lowest.
         '';
         apply = map (
           c: