Merge 93c1e37625 into 6670d752c7

flake.lock

@@ -831,16 +831,15 @@
     "plugin-lzn-auto-require": {
       "flake": false,
       "locked": {
-        "lastModified": 1727636949,
-        "narHash": "sha256-BAOzN+XOrFAJwHmsF8JtZ2EyjP9283FD/I2TbFqGSEw=",
+        "lastModified": 1724239920,
+        "narHash": "sha256-wNtja4vbfzgVwVh8fw6cfTHxcxPOqr6z4nl5Fjj2d0I=",
         "owner": "horriblename",
         "repo": "lzn-auto-require",
-        "rev": "55ecd60831dac8c01d6f3dcb63a30a63a1690eb8",
+        "rev": "c74fa9be2203438aab7fd132310abdb181426c66",
         "type": "github"
       },
       "original": {
         "owner": "horriblename",
-        "ref": "require-rewrite",
         "repo": "lzn-auto-require",
         "type": "github"
       }

flake.nix

@@ -120,7 +120,7 @@
     };
 
     plugin-lzn-auto-require = {
-      url = "github:horriblename/lzn-auto-require/require-rewrite";
+      url = "github:horriblename/lzn-auto-require";
       flake = false;
     };
 

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 mkSetLuaLznBinding;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
   inherit (lib.nvim.dag) entryAnywhere entryAfter;
 
   cfg = config.vim.debugger.nvim-dap;
@@ -49,33 +49,24 @@ in {
       ];
     })
     (mkIf (cfg.enable && cfg.ui.enable) {
-      vim.startPlugins = ["nvim-nio"];
+      vim.startPlugins = ["nvim-dap-ui" "nvim-nio"];
 
-      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 ''
+      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
+          local dapui = require("dapui")
+          dapui.setup()
+        ''
+        + optionalString cfg.ui.autoStart ''
           dap.listeners.after.event_initialized["dapui_config"] = function()
-            require("dapui").open()
+            dapui.open()
           end
           dap.listeners.before.event_terminated["dapui_config"] = function()
-            require("dapui").close()
+            dapui.close()
           end
           dap.listeners.before.event_exited["dapui_config"] = function()
-            require("dapui").close()
+            dapui.close()
           end
-        ''
-      );
+        '');
+      vim.maps.normal = mkSetLuaBinding mappings.toggleDapUI "require('dapui').toggle";
     })
   ];
 }

modules/plugins/filetree/nvimtree/config.nix

@@ -4,6 +4,7 @@
   pkgs,
   ...
 }: let
+  inherit (builtins) filter;
   inherit (lib.strings) optionalString;
   inherit (lib.modules) mkIf;
   inherit (lib.nvim.binds) mkLznBinding;
@@ -26,7 +27,8 @@ in {
           setupModule = "nvim-tree";
           inherit (cfg) setupOpts;
           cmd = ["NvimTreeClipboard" "NvimTreeClose" "NvimTreeCollapse" "NvimTreeCollapseKeepBuffers" "NvimTreeFindFile" "NvimTreeFindFileToggle" "NvimTreeFocus" "NvimTreeHiTest" "NvimTreeOpen" "NvimTreeRefresh" "NvimTreeResize" "NvimTreeToggle"];
-          keys = [
+
+          keys = filter ({key, ...}: key != null) [
             (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)

modules/plugins/lsp/trouble/config.nix

@@ -3,8 +3,9 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLznBinding pushDownDefault;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding pushDownDefault;
 
   cfg = config.vim.lsp;
 
@@ -14,22 +15,15 @@
 in {
   config = mkIf (cfg.enable && cfg.trouble.enable) {
     vim = {
-      lazy.plugins = [
-        {
-          package = "trouble";
-          setupModule = "trouble";
-          inherit (cfg.trouble) setupOpts;
+      startPlugins = ["trouble"];
 
-          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>")
-          ];
-        }
+      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>")
       ];
 
       binds.whichKey.register = pushDownDefault {
@@ -37,6 +31,11 @@ in {
         "<leader>x" = "+Trouble";
         "<leader>lw" = "Workspace";
       };
+
+      pluginRC.trouble = entryAnywhere ''
+        -- Enable trouble diagnostics viewer
+        require("trouble").setup {}
+      '';
     };
   };
 }

modules/plugins/lsp/trouble/trouble.nix

@@ -1,14 +1,11 @@
 {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 "Telescope" {};
-
       mappings = {
         toggle = mkMappingOption "Toggle trouble [trouble]" "<leader>xx";
         workspaceDiagnostics = mkMappingOption "Workspace diagnostics [trouble]" "<leader>lwd";

modules/plugins/terminal/toggleterm/config.nix

@@ -4,45 +4,55 @@
   ...
 }: let
   inherit (builtins) toJSON;
-  inherit (lib.strings) optionalString;
-  inherit (lib.modules) mkIf;
+  inherit (lib.lists) optionals;
+  inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.binds) mkLznBinding;
+  inherit (lib.nvim.binds) mkBinding;
+  inherit (lib.nvim.dag) entryAnywhere entryAfter;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.terminal.toggleterm;
 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;}
+  config = mkMerge [
+    (
+      mkIf cfg.enable {
+        vim = {
+          startPlugins = [
+            "toggleterm-nvim"
           ];
 
-          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
-            })
+          maps.normal = mkBinding cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal";
 
-            vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = 'Open lazygit [toggleterm]'})
+          pluginRC.toggleterm = entryAnywhere ''
+            require("toggleterm").setup(${toLuaObject cfg.setupOpts})
           '';
-        }
-      ];
-    };
-  };
+        };
+      }
+    )
+    (
+      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]'})
+        '';
+      }
+    )
+  ];
 }

modules/plugins/utility/binds/cheatsheet/config.nix

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

modules/plugins/utility/diffview/config.nix

@@ -8,16 +8,9 @@
   cfg = config.vim.utility.diffview-nvim;
 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;
-        }
-      ];
-    };
+    vim.startPlugins = [
+      "diffview-nvim"
+      "plenary-nvim"
+    ];
   };
 }

modules/plugins/utility/diffview/diffview.nix

@@ -1,9 +1,7 @@
 {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" {};
   };
 }

modules/plugins/utility/icon-picker/config.nix

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

modules/plugins/utility/motion/leap/config.nix

@@ -3,59 +3,71 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf;
-  inherit (lib.nvim.binds) mkLznBinding;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.binds) mkBinding;
+  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.utility.motion.leap;
 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")
-          ];
+    vim.startPlugins = [
+      "leap-nvim"
+      "vim-repeat"
+    ];
 
-          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>',
-              },
-            }
-          '';
-        }
-      ];
-    };
+    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>',
+        },
+      }
+    '';
   };
 }

modules/plugins/utility/telescope/config.nix

@@ -4,11 +4,11 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf;
-  inherit (lib.nvim.binds) addDescriptionsToMappings;
-  inherit (lib.strings) optionalString;
-  inherit (lib.lists) optionals;
-  inherit (lib.nvim.binds) pushDownDefault mkSetLznBinding;
+  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;
 
   cfg = config.vim.telescope;
   self = import ./telescope.nix {inherit pkgs lib;};
@@ -18,58 +18,45 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = ["plenary-nvim"];
+      startPlugins = [
+        "telescope"
+        "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')"}
-          '';
+      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>")
 
-          cmd = ["Telescope"];
+        (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>")
 
-          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>")
+        (mkIf config.vim.lsp.enable (mkMerge [
+          (mkSetBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
+          (mkSetBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<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>")
+          (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.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>")
-              ]
-            );
-        }
+        (
+          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>")
+        )
       ];
 
       binds.whichKey.register = pushDownDefault {
@@ -79,6 +66,29 @@ 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 ""
+        }
+      '';
     };
   };
 }

modules/plugins/visuals/fidget/config.nix

@@ -4,19 +4,16 @@
   ...
 }: 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.lazy = {
-      plugins = [
-        {
-          package = "fidget-nvim";
-          setupModule = "fidget";
-          event = "LspAttach";
-          inherit (cfg) setupOpts;
-        }
-      ];
-    };
+    vim.startPlugins = ["fidget-nvim"];
+
+    vim.pluginRC.fidget-nvim = entryAnywhere ''
+      require'fidget'.setup(${toLuaObject cfg.setupOpts})
+    '';
   };
 }

modules/wrapper/lazy/config.nix

@@ -3,8 +3,9 @@
   config,
   ...
 }: let
-  inherit (builtins) toJSON typeOf head length tryEval filter;
+  inherit (builtins) toJSON typeOf head length tryEval;
   inherit (lib.modules) mkIf;
+  inherit (lib.attrsets) mapAttrsToList;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.strings) optionalString;
   inherit (lib.nvim.lua) toLuaObject;
@@ -67,8 +68,7 @@
 
       keys =
         if typeOf spec.keys == "list" && length spec.keys > 0 && typeOf (head spec.keys) == "set"
-        then filter (keySpec: keySpec."@1" != null) (map toLuzLznKeySpec spec.keys)
-        # empty list or str or (listOf str)
+        then map toLuzLznKeySpec spec.keys
         else spec.keys;
     };
   lznSpecs = map toLuaLznSpec cfg.plugins;

modules/wrapper/lazy/lazy.nix

@@ -7,8 +7,8 @@
   lznKeysSpec = submodule {
     options = {
       key = mkOption {
-        type = nullOr str;
-        description = "Key to bind to. If key is null this entry is ignored.";
+        type = str;
+        description = "Key to bind to";
       };
 
       action = mkOption {

modules/wrapper/rc/config.nix

@@ -87,7 +87,7 @@ in {
         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()");
+        footer = entryAfter ["mappings"] (optionalString config.vim.lazy.enable "require('lzn-auto-require.loader').register_loader()");
       };
 
       builtLuaConfigRC = let