packaging: add com.danklinux.dms.desktop entry, remove custom icon

resolution

.agents/skills/dms-plugin-dev/references/widget-plugin-guide.md

@@ -235,7 +235,7 @@ Conditionally show/hide the bar pill:
 ```qml
 PluginComponent {
     visibilityCommand: "pgrep -x myapp"
-    visibilityInterval: 5000  // check every 5 seconds
+    visibilityInterval: 5  // seconds between checks; polling pauses while the bar is hidden
 }
 ```
 

.github/pull_request_template.md

@@ -0,0 +1,31 @@
+## Description
+
+<!-- What does this PR do and why? -->
+
+## Type of change
+
+<!-- Check all that apply. -->
+
+- [ ] Bug fix (non-breaking change that fixes an issue)
+- [ ] New feature (non-breaking change that adds functionality)
+- [ ] Breaking change (fix or feature that changes existing behavior)
+- [ ] Refactor / internal cleanup
+- [ ] Documentation
+- [ ] Other
+
+## Related issues
+
+<!-- e.g. "Fixes #123", "Closes #123". Leave blank if none. -->
+
+## Screenshots / video
+
+<!-- Include screenshots or a video for any user-facing or visual change. -->
+
+## Checklist
+
+- [ ] My code follows the conventions in CONTRIBUTING.md
+- [ ] I have tested my changes locally
+- [ ] New user-facing strings are wrapped in `I18n.tr()` with translator context, reusing existing terms where possible
+- [ ] Go changes: ran `make fmt`, added/updated tests, `make test` passes, and `go mod tidy` is clean
+- [ ] QML changes: ran `make lint-qml` with no new warnings
+- [ ] I have opened a corresponding pull request in dlx-docs to document any new behaviors: https://github.com/AvengeMedia/DankLinux-Docs

.github/workflows/prek.yml

@@ -26,4 +26,4 @@ jobs:
           go-version-file: core/go.mod
 
       - name: run pre-commit hooks
-        uses: j178/prek-action@v1
+        uses: j178/prek-action@v2

.gitignore

@@ -115,3 +115,11 @@ core.*
 .direnv/
 quickshell/dms-plugins
 __pycache__
+
+.vscode/
+
+# Void (xbps) build artifacts
+*.xbps
+distro/void/temp/
+distro/void/hostdir/
+distro/void/masterdir*/

.pre-commit-config.yaml

@@ -20,6 +20,14 @@ repos:
         language: system
         files: ^core/.*\.(go|mod|sum)$
         pass_filenames: false
+  - repo: local
+    hooks:
+      - id: settings-search-index
+        name: settings search index is up to date
+        entry: bash -c 'python3 quickshell/translations/extract_settings_index.py >/dev/null || exit 1; if ! git diff --exit-code -- quickshell/translations/settings_search_index.json; then echo "settings_search_index.json is out of date; run quickshell/translations/extract_settings_index.py and stage the result" >&2; exit 1; fi'
+        language: system
+        files: ^quickshell/(Modules/Settings/.*\.qml|Modals/Settings/SettingsSidebar\.qml|translations/extract_settings_index\.py)$
+        pass_filenames: false
   - repo: local
     hooks:
       - id: no-console-in-qml

Makefile

@@ -74,10 +74,11 @@ install-icon:
 	@echo "Icon installed"
 
 install-desktop:
-	@echo "Installing desktop entry..."
+	@echo "Installing desktop entries..."
 	@install -D -m 644 $(ASSETS_DIR)/dms-open.desktop $(APPLICATIONS_DIR)/dms-open.desktop
+	@install -D -m 644 $(ASSETS_DIR)/com.danklinux.dms.desktop $(APPLICATIONS_DIR)/com.danklinux.dms.desktop
 	@update-desktop-database -q $(APPLICATIONS_DIR) 2>/dev/null || true
-	@echo "Desktop entry installed"
+	@echo "Desktop entries installed"
 
 install: install-bin install-shell install-completions install-systemd install-icon install-desktop
 	@echo ""
@@ -116,10 +117,11 @@ uninstall-icon:
 	@echo "Icon removed"
 
 uninstall-desktop:
-	@echo "Removing desktop entry..."
+	@echo "Removing desktop entries..."
 	@rm -f $(APPLICATIONS_DIR)/dms-open.desktop
+	@rm -f $(APPLICATIONS_DIR)/com.danklinux.dms.desktop
 	@update-desktop-database -q $(APPLICATIONS_DIR) 2>/dev/null || true
-	@echo "Desktop entry removed"
+	@echo "Desktop entries removed"
 
 uninstall: uninstall-systemd uninstall-desktop uninstall-icon uninstall-completions uninstall-shell uninstall-bin
 	@echo ""

assets/com.danklinux.dms.desktop

@@ -0,0 +1,11 @@
+[Desktop Entry]
+Type=Application
+Name=DankMaterialShell
+GenericName=Desktop Shell
+Comment=Material 3 inspired shell for Wayland compositors
+Exec=dms run
+Icon=danklogo
+Terminal=false
+NoDisplay=true
+StartupNotify=false
+Categories=Utility;

core/.mockery.yml

@@ -1,82 +1,85 @@
-with-expecter: true
-dir: "internal/mocks/{{.InterfaceDirRelative}}"
-mockname: "Mock{{.InterfaceName}}"
-outpkg: "{{.PackageName}}"
+dir: internal/mocks/{{.InterfaceDirRelative}}
+structname: Mock{{.InterfaceName}}
+pkgname: '{{.SrcPackageName}}'
+filename: 'mock_{{.InterfaceName}}.go'
+template: testify
+template-data:
+  unroll-variadic: true
 packages:
-  github.com/Wifx/gonetworkmanager/v2:
-    interfaces:
-      NetworkManager:
-      Device:
-      DeviceWireless:
-      AccessPoint:
-      Connection:
-      Settings:
-      ActiveConnection:
-      IP4Config:
-  net:
-    interfaces:
-      Conn:
-  github.com/AvengeMedia/danklinux/internal/plugins:
-    interfaces:
-      GitClient:
-  github.com/godbus/dbus/v5:
-    interfaces:
-      BusObject:
-  github.com/AvengeMedia/danklinux/internal/server/brightness:
-    config:
-      dir: "internal/mocks/brightness"
-      outpkg: mocks_brightness
-    interfaces:
-      DBusConn:
   github.com/AvengeMedia/DankMaterialShell/core/internal/geolocation:
     config:
-      dir: "internal/mocks/geolocation"
-      outpkg: mocks_geolocation
+      dir: internal/mocks/geolocation
+      pkgname: mocks_geolocation
     interfaces:
-      Client:
-  github.com/AvengeMedia/DankMaterialShell/core/internal/server/network:
-    config:
-      dir: "internal/mocks/network"
-      outpkg: mocks_network
-    interfaces:
-      Backend:
+      Client: {}
   github.com/AvengeMedia/DankMaterialShell/core/internal/server/cups:
     config:
-      dir: "internal/mocks/cups"
-      outpkg: mocks_cups
+      dir: internal/mocks/cups
+      pkgname: mocks_cups
     interfaces:
-      CUPSClientInterface:
+      CUPSClientInterface: {}
       PkHelper:
         config:
-          dir: "internal/mocks/cups_pkhelper"
-          outpkg: mocks_cups_pkhelper
+          dir: internal/mocks/cups_pkhelper
+          pkgname: mocks_cups_pkhelper
   github.com/AvengeMedia/DankMaterialShell/core/internal/server/evdev:
     config:
-      dir: "internal/mocks/evdev"
-      outpkg: mocks_evdev
+      dir: internal/mocks/evdev
+      pkgname: mocks_evdev
     interfaces:
-      EvdevDevice:
-  github.com/AvengeMedia/DankMaterialShell/core/internal/version:
+      EvdevDevice: {}
+  github.com/AvengeMedia/DankMaterialShell/core/internal/server/network:
     config:
-      dir: "internal/mocks/version"
-      outpkg: mocks_version
+      dir: internal/mocks/network
+      pkgname: mocks_network
     interfaces:
-      VersionFetcher:
+      Backend: {}
   github.com/AvengeMedia/DankMaterialShell/core/internal/server/wlcontext:
     config:
-      dir: "internal/mocks/wlcontext"
-      outpkg: mocks_wlcontext
+      dir: internal/mocks/wlcontext
+      pkgname: mocks_wlcontext
     interfaces:
-      WaylandContext:
-  github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client:
-    config:
-      dir: "internal/mocks/wlclient"
-      outpkg: mocks_wlclient
-    interfaces:
-      WaylandDisplay:
+      WaylandContext: {}
   github.com/AvengeMedia/DankMaterialShell/core/internal/utils:
     config:
-      dir: "internal/mocks/utils"
-      outpkg: mocks_utils
+      dir: internal/mocks/utils
+      pkgname: mocks_utils
     interfaces:
-      AppChecker:
+      AppChecker: {}
+  github.com/AvengeMedia/DankMaterialShell/core/internal/version:
+    config:
+      dir: internal/mocks/version
+      pkgname: mocks_version
+    interfaces:
+      VersionFetcher: {}
+  github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client:
+    config:
+      dir: internal/mocks/wlclient
+      pkgname: mocks_wlclient
+    interfaces:
+      WaylandDisplay: {}
+  github.com/AvengeMedia/DankMaterialShell/core/internal/plugins:
+    interfaces:
+      GitClient: {}
+  github.com/AvengeMedia/DankMaterialShell/core/internal/server/brightness:
+    config:
+      dir: internal/mocks/brightness
+      pkgname: mocks_brightness
+    interfaces:
+      DBusConn: {}
+  github.com/Wifx/gonetworkmanager/v2:
+    interfaces:
+      AccessPoint: {}
+      ActiveConnection: {}
+      Connection: {}
+      Device: {}
+      DeviceWireless: {}
+      IP4Config: {}
+      NetworkManager: {}
+      Settings: {}
+  github.com/godbus/dbus/v5:
+    interfaces:
+      BusObject: {}
+  net:
+    interfaces:
+      Conn: {}

core/cmd/dankinstall/main.go

@@ -42,7 +42,7 @@ configure passwordless sudo for your user.`,
 }
 
 func init() {
-	rootCmd.Flags().StringVarP(&compositor, "compositor", "c", "", "Compositor/WM to install: niri or hyprland (enables headless mode)")
+	rootCmd.Flags().StringVarP(&compositor, "compositor", "c", "", "Compositor/WM to install: niri, hyprland, or mango (enables headless mode)")
 	rootCmd.Flags().StringVarP(&term, "term", "t", "", "Terminal emulator to install: ghostty, kitty, or alacritty (enables headless mode)")
 	rootCmd.Flags().StringSliceVar(&includeDeps, "include-deps", []string{}, "Optional deps to enable (e.g. dms-greeter)")
 	rootCmd.Flags().StringSliceVar(&excludeDeps, "exclude-deps", []string{}, "Deps to skip during installation")
@@ -95,7 +95,7 @@ func runDankinstall(cmd *cobra.Command, args []string) error {
 func runHeadless() error {
 	// Validate required flags
 	if compositor == "" {
-		return fmt.Errorf("--compositor is required for headless mode (niri or hyprland)")
+		return fmt.Errorf("--compositor is required for headless mode (niri, hyprland, or mango)")
 	}
 	if term == "" {
 		return fmt.Errorf("--term is required for headless mode (ghostty, kitty, or alacritty)")

core/cmd/dms/commands_colorpicker.go

@@ -19,7 +19,12 @@ var (
 var colorCmd = &cobra.Command{
 	Use:   "color",
 	Short: "Color utilities",
-	Long:  "Color utilities including picking colors from the screen",
+	Long: `Color utilities including picking colors from the screen.
+
+This is the screen eyedropper CLI. To open the in-shell color modal, use:
+  dms ipc call color-picker toggle
+
+See: https://danklinux.com/docs/dankmaterialshell/keybinds-ipc`,
 }
 
 var colorPickCmd = &cobra.Command{
@@ -29,6 +34,9 @@ var colorPickCmd = &cobra.Command{
 
 Click on any pixel to capture its color, or press Escape to cancel.
 
+This is the screen eyedropper CLI. To open the in-shell color modal, use:
+  dms ipc call color-picker toggle
+
 Output format flags (mutually exclusive, default: --hex):
   --hex  - Hexadecimal (#RRGGBB)
   --rgb  - RGB values (R G B)

core/cmd/dms/commands_common.go

@@ -6,6 +6,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/plugins"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server"
@@ -37,6 +38,7 @@ var runCmd = &cobra.Command{
 			}
 		}
 		log.ApplyEnvOverrides()
+		config.CleanupStrayHyprlandConfFile(log.Infof)
 		if daemon {
 			runShellDaemon(session)
 		} else {
@@ -75,10 +77,15 @@ var killCmd = &cobra.Command{
 }
 
 var ipcCmd = &cobra.Command{
-	Use:   "ipc [target] [function] [args...]",
+	Use:   "ipc",
 	Short: "Send IPC commands to running DMS shell",
+	Long: `Send IPC commands to the running DMS shell.
+
+  dms ipc call <target> <function> [args...]   invoke a command
+  dms ipc list                                 list all targets and functions
+
+Full reference: https://danklinux.com/docs/dankmaterialshell/keybinds-ipc`,
 	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		_ = findConfig(cmd, args)
 		return getShellIPCCompletions(args, toComplete), cobra.ShellCompDirectiveNoFileComp
 	},
 	Run: func(cmd *cobra.Command, args []string) {
@@ -86,9 +93,17 @@ var ipcCmd = &cobra.Command{
 	},
 }
 
+var ipcListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all IPC targets and functions",
+	Run: func(cmd *cobra.Command, args []string) {
+		printIPCHelp()
+	},
+}
+
 func init() {
+	ipcCmd.AddCommand(ipcListCmd)
 	ipcCmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
-		_ = findConfig(cmd, args)
 		printIPCHelp()
 	})
 }
@@ -265,6 +280,8 @@ func browsePlugins() error {
 		return nil
 	}
 
+	feedback := plugins.FetchFeedback()
+
 	fmt.Printf("\nAvailable Plugins (%d):\n\n", len(pluginList))
 	for _, plugin := range pluginList {
 		installed, _ := manager.IsInstalled(plugin)
@@ -288,6 +305,15 @@ func browsePlugins() error {
 		if len(plugin.Dependencies) > 0 {
 			fmt.Printf("    Dependencies: %s\n", strings.Join(plugin.Dependencies, ", "))
 		}
+		if fb, ok := feedback[plugin.ID]; ok {
+			fmt.Printf("    Upvotes: %d\n", fb.Upvotes)
+			if len(fb.Status) > 0 {
+				fmt.Printf("    Status: %s\n", strings.Join(fb.Status, ", "))
+			}
+			if fb.IssueURL != "" {
+				fmt.Printf("    Discuss: %s\n", fb.IssueURL)
+			}
+		}
 		fmt.Println()
 	}
 
@@ -539,5 +565,6 @@ func getCommonCommands() []*cobra.Command {
 		blurCmd,
 		trashCmd,
 		systemCmd,
+		switchUserCmd,
 	}
 }

core/cmd/dms/commands_config.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/luaconfig"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 	"github.com/spf13/cobra"
 )
@@ -27,7 +28,21 @@ var resolveIncludeCmd = &cobra.Command{
 		case 0:
 			return []string{"hyprland", "niri", "mangowc"}, cobra.ShellCompDirectiveNoFileComp
 		case 1:
-			return []string{"cursor.kdl", "cursor.conf", "outputs.kdl", "outputs.conf", "binds.kdl", "binds.conf"}, cobra.ShellCompDirectiveNoFileComp
+			return []string{
+				"binds.lua",
+				"binds-user.lua",
+				"colors.lua",
+				"layout.lua",
+				"outputs.lua",
+				"cursor.lua",
+				"windowrules.lua",
+				"cursor.kdl",
+				"outputs.kdl",
+				"binds.kdl",
+				"cursor.conf",
+				"outputs.conf",
+				"binds.conf",
+			}, cobra.ShellCompDirectiveNoFileComp
 		}
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	},
@@ -39,8 +54,10 @@ func init() {
 }
 
 type IncludeResult struct {
-	Exists   bool `json:"exists"`
-	Included bool `json:"included"`
+	Exists       bool   `json:"exists"`
+	Included     bool   `json:"included"`
+	ConfigFormat string `json:"configFormat,omitempty"`
+	ReadOnly     bool   `json:"readOnly,omitempty"`
 }
 
 func runResolveInclude(cmd *cobra.Command, args []string) {
@@ -55,7 +72,7 @@ func runResolveInclude(cmd *cobra.Command, args []string) {
 		result, err = checkHyprlandInclude(filename)
 	case "niri":
 		result, err = checkNiriInclude(filename)
-	case "mangowc", "dwl", "mango":
+	case "mangowc", "mango":
 		result, err = checkMangoWCInclude(filename)
 	default:
 		log.Fatalf("Unknown compositor: %s", compositor)
@@ -70,10 +87,7 @@ func runResolveInclude(cmd *cobra.Command, args []string) {
 }
 
 func checkHyprlandInclude(filename string) (IncludeResult, error) {
-	configDir, err := utils.ExpandPath("$HOME/.config/hypr")
-	if err != nil {
-		return IncludeResult{}, err
-	}
+	configDir := filepath.Join(utils.XDGConfigHome(), "hypr")
 
 	targetPath := filepath.Join(configDir, "dms", filename)
 	result := IncludeResult{}
@@ -82,17 +96,41 @@ func checkHyprlandInclude(filename string) (IncludeResult, error) {
 		result.Exists = true
 	}
 
-	mainConfig := filepath.Join(configDir, "hyprland.conf")
-	if _, err := os.Stat(mainConfig); os.IsNotExist(err) {
-		return result, nil
+	targetAbs, err := filepath.Abs(targetPath)
+	if err != nil {
+		return result, err
+	}
+
+	targetRel := filepath.ToSlash(filepath.Join("dms", filename))
+
+	mainLua := filepath.Join(configDir, "hyprland.lua")
+	if _, err := os.Stat(mainLua); err == nil {
+		result.ConfigFormat = "lua"
+		result.ReadOnly = false
+		processedLua := make(map[string]bool)
+		if luaconfig.RequiresTarget(mainLua, targetAbs, processedLua) {
+			result.Included = true
+			return result, nil
+		}
+	}
+
+	mainConf := filepath.Join(configDir, "hyprland.conf")
+	if _, err := os.Stat(mainConf); err == nil {
+		if result.ConfigFormat == "" {
+			result.ConfigFormat = "hyprlang"
+			result.ReadOnly = true
+		}
+		processed := make(map[string]bool)
+		if hyprlandFindIncludeHyprlang(mainConf, targetRel, processed) {
+			result.Included = true
+			return result, nil
+		}
 	}
 
-	processed := make(map[string]bool)
-	result.Included = hyprlandFindInclude(mainConfig, "dms/"+filename, processed)
 	return result, nil
 }
 
-func hyprlandFindInclude(filePath, target string, processed map[string]bool) bool {
+func hyprlandFindIncludeHyprlang(filePath, target string, processed map[string]bool) bool {
 	absPath, err := filepath.Abs(filePath)
 	if err != nil {
 		return false
@@ -141,7 +179,7 @@ func hyprlandFindInclude(filePath, target string, processed map[string]bool) boo
 			continue
 		}
 
-		if hyprlandFindInclude(expanded, target, processed) {
+		if hyprlandFindIncludeHyprlang(expanded, target, processed) {
 			return true
 		}
 	}
@@ -150,10 +188,7 @@ func hyprlandFindInclude(filePath, target string, processed map[string]bool) boo
 }
 
 func checkNiriInclude(filename string) (IncludeResult, error) {
-	configDir, err := utils.ExpandPath("$HOME/.config/niri")
-	if err != nil {
-		return IncludeResult{}, err
-	}
+	configDir := filepath.Join(utils.XDGConfigHome(), "niri")
 
 	targetPath := filepath.Join(configDir, "dms", filename)
 	result := IncludeResult{}
@@ -229,10 +264,7 @@ func niriFindInclude(filePath, target string, processed map[string]bool) bool {
 }
 
 func checkMangoWCInclude(filename string) (IncludeResult, error) {
-	configDir, err := utils.ExpandPath("$HOME/.config/mango")
-	if err != nil {
-		return IncludeResult{}, err
-	}
+	configDir := filepath.Join(utils.XDGConfigHome(), "mango")
 
 	targetPath := filepath.Join(configDir, "dms", filename)
 	result := IncludeResult{}

core/cmd/dms/commands_doctor.go

@@ -125,6 +125,7 @@ const (
 	catConfigFiles
 	catServices
 	catEnvironment
+	catFonts
 )
 
 func (c category) String() string {
@@ -147,6 +148,8 @@ func (c category) String() string {
 		return "Services"
 	case catEnvironment:
 		return "Environment"
+	case catFonts:
+		return "Fonts"
 	default:
 		return "Unknown"
 	}
@@ -213,6 +216,7 @@ func runDoctor(cmd *cobra.Command, args []string) {
 		checkConfigurationFiles(),
 		checkSystemdServices(),
 		checkEnvironmentVars(),
+		checkFonts(),
 	)
 
 	switch {
@@ -553,6 +557,8 @@ func detectRunningWM() string {
 		return "Hyprland"
 	case os.Getenv("NIRI_SOCKET") != "":
 		return "niri"
+	case os.Getenv("MANGO_INSTANCE_SIGNATURE") != "":
+		return "MangoWC"
 	case os.Getenv("MIRACLESOCK") != "":
 		return "Miracle WM"
 	case os.Getenv("XDG_CURRENT_DESKTOP") != "":
@@ -947,9 +953,12 @@ func checkSystemdServices() []checkResult {
 			message = fmt.Sprintf("%s, %s", dmsState.enabled, dmsState.active)
 		}
 		switch {
+		case dmsState.active == "failed":
+			status = statusError
+		case dmsState.active == "active":
 		case dmsState.enabled == "disabled":
 			status, message = statusWarn, "Disabled"
-		case dmsState.active == "failed" || dmsState.active == "inactive":
+		case dmsState.active == "inactive":
 			status = statusError
 		}
 		results = append(results, checkResult{catServices, "dms.service", status, message, "", doctorDocsURL + "#services"})
@@ -1132,3 +1141,100 @@ func formatResultsPlain(results []checkResult) string {
 
 	return sb.String()
 }
+
+func checkFonts() []checkResult {
+	var results []checkResult
+	url := doctorDocsURL + "#fonts"
+
+	configDir, err := os.UserConfigDir()
+	if err != nil {
+		return nil
+	}
+	settingsPath := filepath.Join(configDir, "DankMaterialShell", "settings.json")
+
+	fontFamily := "Inter Variable"
+	monoFontFamily := "Fira Code"
+
+	if data, err := os.ReadFile(settingsPath); err == nil {
+		var settings struct {
+			FontFamily     string `json:"fontFamily"`
+			MonoFontFamily string `json:"monoFontFamily"`
+		}
+		if err := json.Unmarshal(data, &settings); err == nil {
+			if settings.FontFamily != "" {
+				fontFamily = settings.FontFamily
+			}
+			if settings.MonoFontFamily != "" {
+				monoFontFamily = settings.MonoFontFamily
+			}
+		}
+	}
+
+	if !utils.CommandExists("fc-list") {
+		results = append(results, checkResult{catFonts, "Fontconfig Tools", statusWarn, "fc-list not installed", "Cannot verify if fonts are cached.", url})
+		return results
+	}
+
+	// Retrieve font list
+	output, err := exec.Command("fc-list", ":", "family").Output()
+	if err != nil {
+		results = append(results, checkResult{catFonts, "Fontconfig Cache", statusError, "Failed to query font list", "Fontconfig cache query failed. Try running 'fc-cache -fv'.", url})
+		return results
+	}
+
+	outStr := string(output)
+	if len(strings.TrimSpace(outStr)) == 0 {
+		results = append(results, checkResult{catFonts, "Fontconfig Cache", statusError, "Cache is empty", "No fonts found in fontconfig cache. Try running 'fc-cache -fv'.", url})
+		return results
+	}
+
+	lowerFonts := strings.ToLower(outStr)
+
+	// Helper to check if a font exists
+	hasFont := func(name string) bool {
+		target := strings.ToLower(strings.TrimSpace(name))
+		if target == "" {
+			return false
+		}
+		for _, line := range strings.Split(lowerFonts, "\n") {
+			line = strings.TrimSpace(line)
+			if line == "" {
+				continue
+			}
+			// Each line can have comma-separated families
+			families := strings.Split(line, ",")
+			for _, fam := range families {
+				if strings.TrimSpace(fam) == target {
+					return true
+				}
+			}
+		}
+		return false
+	}
+
+	// Normal Font Check
+	if hasFont(fontFamily) {
+		results = append(results, checkResult{catFonts, "Normal Font", statusOK, fontFamily, "Available", url})
+	} else {
+		results = append(results, checkResult{
+			catFonts, "Normal Font", statusWarn,
+			fmt.Sprintf("'%s' not found", fontFamily),
+			"Font is not registered. Try running 'fc-cache -fv' or install the font.",
+			url,
+		})
+	}
+
+	// Monospace Font Check
+	if hasFont(monoFontFamily) {
+		results = append(results, checkResult{catFonts, "Monospace Font", statusOK, monoFontFamily, "Available", url})
+	} else {
+		results = append(results, checkResult{
+			catFonts, "Monospace Font", statusWarn,
+			fmt.Sprintf("'%s' not found", monoFontFamily),
+			"Font is not registered. Try running 'fc-cache -fv' or install the font.",
+			url,
+		})
+	}
+
+	return results
+}

core/cmd/dms/commands_greeter.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bufio"
 	"context"
+	"encoding/json"
 	"fmt"
 	"os"
 	"os/exec"
@@ -59,32 +60,80 @@ var greeterInstallCmd = &cobra.Command{
 }
 
 var greeterSyncCmd = &cobra.Command{
-	Use:     "sync",
-	Short:   "Sync DMS theme and settings with greeter",
-	Long:    "Synchronize your current user's DMS theme, settings, and wallpaper configuration with the login greeter screen",
-	PreRunE: preRunPrivileged,
+	Use:   "sync",
+	Short: "Sync DMS theme and settings with greeter",
+	Long:  "Synchronize your current user's DMS theme, settings, and wallpaper configuration with the login greeter screen. Also updates a per-user cache slot at users/<username>/ for multi-account greeter theme preview.\n\nUse --profile on secondary accounts to sync only your own users/<username>/ slot without sudo or greetd changes.",
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		profile, _ := cmd.Flags().GetBool("profile")
+		if profile {
+			return nil
+		}
+		return preRunPrivileged(cmd, args)
+	},
 	Run: func(cmd *cobra.Command, args []string) {
 		yes, _ := cmd.Flags().GetBool("yes")
 		auth, _ := cmd.Flags().GetBool("auth")
 		local, _ := cmd.Flags().GetBool("local")
+		profile, _ := cmd.Flags().GetBool("profile")
+		autologinOnly, _ := cmd.Flags().GetBool("autologin")
 		term, _ := cmd.Flags().GetBool("terminal")
 		if term {
-			if err := syncInTerminal(yes, auth, local); err != nil {
+			if err := syncInTerminal(yes, auth, local, profile, autologinOnly); err != nil {
 				log.Fatalf("Error launching sync in terminal: %v", err)
 			}
 			return
 		}
-		if err := syncGreeter(yes, auth, local); err != nil {
+		if autologinOnly {
+			if err := syncGreeterAutoLoginOnly(yes); err != nil {
+				log.Fatalf("Error syncing greeter auto-login: %v", err)
+			}
+			return
+		}
+		if err := syncGreeter(yes, auth, local, profile); err != nil {
 			log.Fatalf("Error syncing greeter: %v", err)
 		}
 	},
 }
 
+var greeterLaunchSessionCmd = &cobra.Command{
+	Use:    "launch-session",
+	Short:  "Launch a remembered greeter session",
+	Hidden: true,
+	Run: func(cmd *cobra.Command, args []string) {
+		sessionID, _ := cmd.Flags().GetString("session-id")
+		fromMemory, _ := cmd.Flags().GetBool("from-memory")
+		cacheDir, _ := cmd.Flags().GetString("cache-dir")
+
+		if fromMemory {
+			homeDir, err := os.UserHomeDir()
+			if err != nil {
+				log.Fatalf("failed to get user home directory: %v", err)
+			}
+			if err := greeter.LaunchSessionFromMemory(cacheDir, homeDir); err != nil {
+				log.Fatalf("failed to launch remembered greeter session: %v", err)
+			}
+			return
+		}
+
+		if sessionID == "" {
+			log.Fatal("missing --session-id or --from-memory")
+		}
+		if err := greeter.LaunchSessionByID(sessionID); err != nil {
+			log.Fatalf("failed to launch greeter session %q: %v", sessionID, err)
+		}
+	},
+}
+
 func init() {
 	greeterSyncCmd.Flags().BoolP("yes", "y", false, "Non-interactive mode: skip prompts, use defaults (for UI)")
 	greeterSyncCmd.Flags().BoolP("terminal", "t", false, "Run sync in a new terminal (for entering sudo password); terminal auto-closes when done")
 	greeterSyncCmd.Flags().BoolP("auth", "a", false, "Configure PAM for fingerprint and U2F (adds both if modules exist); overrides UI toggles")
 	greeterSyncCmd.Flags().BoolP("local", "l", false, "Developer mode: force greetd config to use a local DMS checkout path")
+	greeterSyncCmd.Flags().BoolP("profile", "p", false, "Sync only your per-user greeter slot (no sudo; for secondary accounts)")
+	greeterSyncCmd.Flags().Bool("autologin", false, "Apply only greeter auto-login on startup settings to greetd (no theme or auth sync)")
+	greeterLaunchSessionCmd.Flags().String("session-id", "", "Desktop session id to launch")
+	greeterLaunchSessionCmd.Flags().Bool("from-memory", false, "Resolve the session id from greeter memory")
+	greeterLaunchSessionCmd.Flags().String("cache-dir", greeter.GreeterCacheDir, "Greeter cache directory")
 }
 
 var greeterEnableCmd = &cobra.Command{
@@ -282,7 +331,7 @@ func installGreeter(nonInteractive bool) error {
 
 	fmt.Println("\n=== Installation Complete ===")
 	fmt.Println("\nTo start the greeter now, run:")
-	fmt.Println("  sudo systemctl start greetd")
+	fmt.Println(startGreeterHint())
 	fmt.Println("\nOr reboot to see the greeter at next boot.")
 
 	return nil
@@ -309,7 +358,13 @@ func uninstallGreeter(nonInteractive bool) error {
 	}
 
 	fmt.Println("\nDisabling greetd...")
-	if err := privesc.Run(context.Background(), "", "systemctl", "disable", "greetd"); err != nil {
+	if isRunit() {
+		if err := disableRunitService("greetd"); err != nil {
+			fmt.Printf("  ⚠ Could not disable greetd: %v\n", err)
+		} else {
+			fmt.Println("  ✓ greetd disabled")
+		}
+	} else if err := privesc.Run(context.Background(), "", "systemctl", "disable", "greetd"); err != nil {
 		fmt.Printf("  ⚠ Could not disable greetd: %v\n", err)
 	} else {
 		fmt.Println("  ✓ greetd disabled")
@@ -432,6 +487,14 @@ func suggestDisplayManagerRestore(nonInteractive bool) {
 
 	enableDM := func(dm string) {
 		fmt.Printf("  Enabling %s...\n", dm)
+		if isRunit() {
+			if err := enableRunitService(dm); err != nil {
+				fmt.Printf("  ⚠ Failed to enable %s: %v\n", dm, err)
+			} else {
+				fmt.Printf("  ✓ %s enabled (linked into %s).\n", dm, runitServiceDir)
+			}
+			return
+		}
 		if err := privesc.Run(context.Background(), "", "systemctl", "enable", "--force", dm); err != nil {
 			fmt.Printf("  ⚠ Failed to enable %s: %v\n", dm, err)
 		} else {
@@ -478,6 +541,9 @@ func suggestDisplayManagerRestore(nonInteractive bool) {
 }
 
 func isSystemdUnitInstalled(unit string) bool {
+	if isRunit() {
+		return runitServiceInstalled(unit)
+	}
 	cmd := exec.Command("systemctl", "list-unit-files", unit+".service", "--no-legend", "--no-pager")
 	out, err := cmd.Output()
 	return err == nil && strings.Contains(string(out), unit)
@@ -512,8 +578,8 @@ func runCommandInTerminal(shellCmd string) error {
 	return fmt.Errorf("no terminal emulator found (tried: gnome-terminal, konsole, xfce4-terminal, ghostty, wezterm, alacritty, kitty, xterm)")
 }
 
-func syncInTerminal(nonInteractive bool, forceAuth bool, local bool) error {
-	syncFlags := make([]string, 0, 3)
+func syncInTerminal(nonInteractive bool, forceAuth bool, local bool, profileOnly bool, autologinOnly bool) error {
+	syncFlags := make([]string, 0, 5)
 	if nonInteractive {
 		syncFlags = append(syncFlags, "--yes")
 	}
@@ -523,11 +589,22 @@ func syncInTerminal(nonInteractive bool, forceAuth bool, local bool) error {
 	if local {
 		syncFlags = append(syncFlags, "--local")
 	}
+	if profileOnly {
+		syncFlags = append(syncFlags, "--profile")
+	}
+	if autologinOnly {
+		syncFlags = append(syncFlags, "--autologin")
+	}
 	shellSyncCmd := "dms greeter sync"
 	if len(syncFlags) > 0 {
 		shellSyncCmd += " " + strings.Join(syncFlags, " ")
 	}
-	shellCmd := shellSyncCmd + `; echo; echo "Sync finished. Closing in 3 seconds..."; sleep 3`
+	var shellCmd string
+	if autologinOnly {
+		shellCmd = shellSyncCmd + `; echo; echo "Auto-login update finished. Closing in 3 seconds..."; sleep 3`
+	} else {
+		shellCmd = shellSyncCmd + `; echo; echo "Sync finished. Closing in 3 seconds..."; sleep 3`
+	}
 	return runCommandInTerminal(shellCmd)
 }
 
@@ -541,7 +618,54 @@ func resolveLocalWrapperShell() (string, error) {
 	return "", fmt.Errorf("could not find bash or sh in PATH for local greeter wrapper")
 }
 
-func syncGreeter(nonInteractive bool, forceAuth bool, local bool) error {
+func syncGreeterAutoLoginOnly(nonInteractive bool) error {
+	logFunc := func(msg string) {
+		fmt.Println(msg)
+	}
+
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get user home directory: %w", err)
+	}
+
+	settingsPath := filepath.Join(homeDir, ".config", "DankMaterialShell", "settings.json")
+	cacheSettingsPath := filepath.Join(greeter.GreeterCacheDir, "settings.json")
+	enabled := false
+	for _, path := range []string{cacheSettingsPath, settingsPath} {
+		data, readErr := os.ReadFile(path)
+		if readErr != nil {
+			continue
+		}
+		var cfg struct {
+			GreeterAutoLogin bool `json:"greeterAutoLogin"`
+		}
+		if json.Unmarshal(data, &cfg) == nil {
+			enabled = cfg.GreeterAutoLogin
+			break
+		}
+	}
+
+	fmt.Println("=== Greeter Auto-Login ===")
+	fmt.Println()
+	if enabled {
+		fmt.Println("Enabling auto-login on startup in greetd.")
+		fmt.Println("After your next reboot, DMS will skip the greeter password until you sign out.")
+	} else {
+		fmt.Println("Disabling auto-login on startup in greetd.")
+		fmt.Println("After your next reboot, you will enter your password at the greeter again.")
+	}
+	fmt.Println()
+	fmt.Println("Administrator (sudo) access is required to update /etc/greetd/config.toml.")
+	fmt.Println()
+
+	return greeter.SyncGreeterAutoLoginOnly(logFunc, "")
+}
+
+func syncGreeter(nonInteractive bool, forceAuth bool, local bool, profileOnly bool) error {
+	if profileOnly {
+		return syncGreeterProfileOnly(nonInteractive)
+	}
+
 	if !nonInteractive {
 		fmt.Println("=== DMS Greeter Sync ===")
 		fmt.Println()
@@ -752,6 +876,26 @@ func syncGreeter(nonInteractive bool, forceAuth bool, local bool) error {
 	return nil
 }
 
+func syncGreeterProfileOnly(nonInteractive bool) error {
+	logFunc := func(msg string) {
+		fmt.Println(msg)
+	}
+	if !nonInteractive {
+		fmt.Println("=== DMS Greeter Profile Sync ===")
+		fmt.Println()
+		fmt.Println("Syncing your personal greeter theme slot (no system changes)...")
+	}
+	if err := greeter.SyncUserProfileCache(logFunc); err != nil {
+		return err
+	}
+	if !nonInteractive {
+		fmt.Println("\n=== Profile Sync Complete ===")
+		fmt.Println("\nYour theme, wallpaper, and profile photo have been synced for the login screen.")
+		fmt.Println("Log out to preview your greeter look when selecting your account.")
+	}
+	return nil
+}
+
 func hasDmsShellQml(dir string) bool {
 	info, err := os.Stat(filepath.Join(dir, "shell.qml"))
 	return err == nil && !info.IsDir()
@@ -837,10 +981,29 @@ func resolveLocalDMSPath() (string, error) {
 		}
 	}
 
-	return "", fmt.Errorf("could not locate a local DMS checkout from %s; run from repo root or set DMS_LOCAL_PATH=/absolute/path/to/repo", wd)
+	configuredCommand := readDefaultSessionCommand("/etc/greetd/config.toml")
+	if pathOverride := extractGreeterPathOverrideFromCommand(configuredCommand); pathOverride != "" {
+		if resolved, ok := resolveDMSLocalCandidate(pathOverride); ok {
+			return resolved, nil
+		}
+	}
+
+	return "", fmt.Errorf("could not locate a local DMS checkout from %s; run from repo root, set DMS_LOCAL_PATH=/absolute/path/to/repo, or configure greetd with -p /path/to/quickshell", wd)
 }
 
 func disableDisplayManager(dmName string) (bool, error) {
+	if isRunit() {
+		if !runitServiceEnabled(dmName) {
+			return false, nil
+		}
+		fmt.Printf("\nDisabling %s (runit)...\n", dmName)
+		if err := disableRunitService(dmName); err != nil {
+			return false, fmt.Errorf("failed to disable %s: %w", dmName, err)
+		}
+		fmt.Printf("  ✓ %s disabled (removed from %s)\n", dmName, runitServiceDir)
+		return true, nil
+	}
+
 	state, err := getSystemdServiceState(dmName)
 	if err != nil {
 		return false, fmt.Errorf("failed to check %s state: %w", dmName, err)
@@ -894,6 +1057,21 @@ func disableDisplayManager(dmName string) (bool, error) {
 }
 
 func ensureGreetdEnabled() error {
+	if isRunit() {
+		fmt.Println("\nEnabling greetd service (runit)...")
+		if !runitServiceInstalled("greetd") {
+			return fmt.Errorf("greetd service not found in %s. Please install greetd first", runitSvDir)
+		}
+		// Seat + runtime-dir setup that logind handles automatically on systemd.
+		ensureRunitSeat("_greeter")
+		ensureGreetdPamRundir()
+		if err := enableRunitService("greetd"); err != nil {
+			return fmt.Errorf("failed to enable greetd: %w", err)
+		}
+		fmt.Printf("  ✓ greetd enabled (%s)\n", runitServiceDir)
+		return nil
+	}
+
 	fmt.Println("\nChecking greetd service status...")
 
 	state, err := getSystemdServiceState("greetd")
@@ -941,6 +1119,12 @@ func ensureGreetdEnabled() error {
 }
 
 func ensureGraphicalTarget() error {
+	if isRunit() {
+		// runit has no targets; a supervised greetd service is the graphical
+		// login, so there is nothing to set here.
+		return nil
+	}
+
 	getDefaultCmd := exec.Command("systemctl", "get-default")
 	currentTarget, err := getDefaultCmd.Output()
 	if err != nil {
@@ -1074,7 +1258,7 @@ func enableGreeter(nonInteractive bool) error {
 		fmt.Println("\n=== Enable Complete ===")
 		fmt.Println("\nGreeter configuration verified and system state corrected.")
 		fmt.Println("To start the greeter now, run:")
-		fmt.Println("  sudo systemctl start greetd")
+		fmt.Println(startGreeterHint())
 		fmt.Println("\nOr reboot to see the greeter at boot time.")
 
 		return nil
@@ -1155,7 +1339,7 @@ func enableGreeter(nonInteractive bool) error {
 
 	fmt.Println("\n=== Enable Complete ===")
 	fmt.Println("\nTo start the greeter now, run:")
-	fmt.Println("  sudo systemctl start greetd")
+	fmt.Println(startGreeterHint())
 	fmt.Println("\nOr reboot to see the greeter at boot time.")
 
 	return nil

core/cmd/dms/commands_keybinds.go

@@ -51,12 +51,20 @@ var keybindsSetCmd = &cobra.Command{
 
 var keybindsRemoveCmd = &cobra.Command{
 	Use:   "remove <provider> <key>",
-	Short: "Remove a keybind override",
-	Long:  "Remove a keybind override from the specified provider",
+	Short: "Remove a keybind",
+	Long:  "Remove a keybind. For Hyprland this writes a negative override to dms/binds-user.lua so the key stays unbound across DMS updates. For other providers it deletes the entry from the managed file.",
 	Args:  cobra.ExactArgs(2),
 	Run:   runKeybindsRemove,
 }
 
+var keybindsResetCmd = &cobra.Command{
+	Use:   "reset <provider> <key>",
+	Short: "Reset a keybind override to its DMS default",
+	Long:  "Drop the user override for the given key so the DMS default re-applies. For providers without a separate default file (Niri, MangoWC) this is equivalent to remove.",
+	Args:  cobra.ExactArgs(2),
+	Run:   runKeybindsReset,
+}
+
 func init() {
 	keybindsListCmd.Flags().BoolP("json", "j", false, "Output as JSON")
 	keybindsShowCmd.Flags().String("path", "", "Override config path for the provider")
@@ -72,6 +80,7 @@ func init() {
 	keybindsCmd.AddCommand(keybindsShowCmd)
 	keybindsCmd.AddCommand(keybindsSetCmd)
 	keybindsCmd.AddCommand(keybindsRemoveCmd)
+	keybindsCmd.AddCommand(keybindsResetCmd)
 
 	keybinds.SetJSONProviderFactory(func(filePath string) (keybinds.Provider, error) {
 		return providers.NewJSONFileProvider(filePath)
@@ -263,3 +272,19 @@ func runKeybindsRemove(_ *cobra.Command, args []string) {
 	}, "", "  ")
 	fmt.Fprintln(os.Stdout, string(output))
 }
+
+func runKeybindsReset(_ *cobra.Command, args []string) {
+	providerName, key := args[0], args[1]
+	writable := getWritableProvider(providerName)
+
+	if err := writable.ResetBind(key); err != nil {
+		log.Fatalf("Error resetting keybind: %v", err)
+	}
+
+	output, _ := json.MarshalIndent(map[string]any{
+		"success": true,
+		"key":     key,
+		"reset":   true,
+	}, "", "  ")
+	fmt.Fprintln(os.Stdout, string(output))
+}

core/cmd/dms/commands_screenshot.go

@@ -4,7 +4,9 @@ import (
 	"bytes"
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"strconv"
 	"strings"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/clipboard"
@@ -37,7 +39,7 @@ Modes:
   full        - Capture the focused output
   all         - Capture all outputs combined
   output      - Capture a specific output by name
-  window      - Capture the focused window (Hyprland/DWL)
+  window      - Capture the focused window (Hyprland/Mango)
   last        - Capture the last selected region
 
 Output format (--format):
@@ -95,7 +97,7 @@ If no previous region exists, falls back to interactive selection.`,
 var ssWindowCmd = &cobra.Command{
 	Use:   "window",
 	Short: "Capture the focused window",
-	Long:  `Capture the currently focused window. Supported on Hyprland and DWL.`,
+	Long:  `Capture the currently focused window. Supported on Hyprland and Mango.`,
 	Run:   runScreenshotWindow,
 }
 
@@ -179,9 +181,39 @@ func getScreenshotConfig(mode screenshot.Mode) screenshot.Config {
 	return config
 }
 
+// setPopoutScreenshotMode toggles the shell handshake so popouts drop their keyboard grab during region select. Best-effort.
+func setPopoutScreenshotMode(begin bool) {
+	fn := "end"
+	if begin {
+		fn = "begin"
+	}
+	cmdArgs := []string{"ipc"}
+	if pid, ok := getFirstDMSPID(); ok {
+		cmdArgs = append(cmdArgs, "--pid", strconv.Itoa(pid))
+	} else {
+		if err := findConfig(nil, nil); err != nil {
+			return
+		}
+		if qsHasAnyDisplay() {
+			cmdArgs = append(cmdArgs, "--any-display")
+		}
+		cmdArgs = append(cmdArgs, "-p", configPath)
+	}
+	cmdArgs = append(cmdArgs, "call", "screenshot", fn)
+	_ = exec.Command("qs", cmdArgs...).Run()
+}
+
 func runScreenshot(config screenshot.Config) {
-	sc := screenshot.New(config)
-	result, err := sc.Run()
+	// Region select needs the keyboard; drop popout grabs for its duration.
+	result, err := func() (*screenshot.CaptureResult, error) {
+		interactive := config.Mode == screenshot.ModeRegion || config.Mode == screenshot.ModeLastRegion
+		if interactive {
+			setPopoutScreenshotMode(true)
+			defer setPopoutScreenshotMode(false)
+		}
+		return screenshot.New(config).Run()
+	}()
+
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		os.Exit(1)

core/cmd/dms/commands_session.go

@@ -0,0 +1,187 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"os/exec"
+	"sort"
+	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
+	"github.com/spf13/cobra"
+)
+
+var switchUserCmd = &cobra.Command{
+	Use:   "switch-user [target]",
+	Short: "Switch to another active session on this seat",
+	Long: `Switch the active VT to another running session.
+
+With no target, prints the list of switchable sessions. Pass a username or a
+numeric session ID to switch directly. Requires the target to already be a
+running session on the same seat (use the greeter for a fresh login).`,
+	Args: cobra.MaximumNArgs(1),
+	Run:  runSwitchUser,
+}
+
+type sessionInfo struct {
+	ID      string
+	Name    string
+	Seat    string
+	TTY     string
+	Type    string
+	Class   string
+	Active  bool
+	State   string
+	Current bool
+}
+
+func runSwitchUser(cmd *cobra.Command, args []string) {
+	currentID := os.Getenv("XDG_SESSION_ID")
+	sessions, err := listSessions(currentID)
+	if err != nil {
+		log.Fatalf("%v", err)
+	}
+
+	switchable := make([]sessionInfo, 0, len(sessions))
+	for _, s := range sessions {
+		if s.Class != "user" || s.State == "closing" || s.Current {
+			continue
+		}
+		switchable = append(switchable, s)
+	}
+
+	if len(args) == 0 {
+		if len(switchable) == 0 {
+			fmt.Println("No other active sessions on this seat.")
+			return
+		}
+		printSessions(switchable)
+		return
+	}
+
+	target := args[0]
+	picked, err := pickSession(switchable, target)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		if len(switchable) == 0 {
+			fmt.Fprintln(os.Stderr, "No other active sessions on this seat. Only already-running sessions can be switched to.")
+		} else {
+			fmt.Fprintln(os.Stderr, "\nSwitchable sessions:")
+			printSessions(switchable)
+		}
+		os.Exit(1)
+	}
+
+	if err := activateSession(picked.ID); err != nil {
+		log.Fatalf("loginctl activate %s: %v", picked.ID, err)
+	}
+}
+
+func listSessions(currentID string) ([]sessionInfo, error) {
+	listOut, err := exec.Command("loginctl", "list-sessions", "--no-legend").Output()
+	if err != nil {
+		return nil, fmt.Errorf("loginctl list-sessions: %w", err)
+	}
+
+	var ids []string
+	scanner := bufio.NewScanner(strings.NewReader(string(listOut)))
+	for scanner.Scan() {
+		fields := strings.Fields(scanner.Text())
+		if len(fields) == 0 {
+			continue
+		}
+		ids = append(ids, fields[0])
+	}
+
+	out := make([]sessionInfo, 0, len(ids))
+	for _, id := range ids {
+		s, err := showSession(id)
+		if err != nil {
+			continue
+		}
+		s.Current = currentID != "" && s.ID == currentID
+		out = append(out, s)
+	}
+	sort.SliceStable(out, func(i, j int) bool {
+		if out[i].Name != out[j].Name {
+			return out[i].Name < out[j].Name
+		}
+		return out[i].ID < out[j].ID
+	})
+	return out, nil
+}
+
+func showSession(id string) (sessionInfo, error) {
+	out, err := exec.Command("loginctl", "show-session", id,
+		"-p", "Id", "-p", "Name", "-p", "Seat", "-p", "TTY",
+		"-p", "Type", "-p", "Class", "-p", "Active", "-p", "State").Output()
+	if err != nil {
+		return sessionInfo{}, err
+	}
+	fields := map[string]string{}
+	for _, line := range strings.Split(string(out), "\n") {
+		idx := strings.IndexByte(line, '=')
+		if idx <= 0 {
+			continue
+		}
+		fields[line[:idx]] = line[idx+1:]
+	}
+	if fields["Id"] == "" {
+		return sessionInfo{}, fmt.Errorf("session %s: no Id", id)
+	}
+	return sessionInfo{
+		ID:     fields["Id"],
+		Name:   fields["Name"],
+		Seat:   fields["Seat"],
+		TTY:    fields["TTY"],
+		Type:   fields["Type"],
+		Class:  fields["Class"],
+		Active: fields["Active"] == "yes",
+		State:  fields["State"],
+	}, nil
+}
+
+func pickSession(sessions []sessionInfo, target string) (sessionInfo, error) {
+	for _, s := range sessions {
+		if s.ID == target {
+			return s, nil
+		}
+	}
+	matches := make([]sessionInfo, 0, 2)
+	for _, s := range sessions {
+		if s.Name == target {
+			matches = append(matches, s)
+		}
+	}
+	if len(matches) == 1 {
+		return matches[0], nil
+	}
+	if len(matches) > 1 {
+		ids := make([]string, len(matches))
+		for i, m := range matches {
+			ids[i] = m.ID
+		}
+		return sessionInfo{}, fmt.Errorf("%s has multiple active sessions (%s); pass a session ID instead", target, strings.Join(ids, ", "))
+	}
+	return sessionInfo{}, fmt.Errorf("no switchable session matches %q", target)
+}
+
+func activateSession(id string) error {
+	return exec.Command("loginctl", "activate", id).Run()
+}
+
+func printSessions(sessions []sessionInfo) {
+	fmt.Printf("%-6s %-12s %-8s %-8s %-8s\n", "ID", "USER", "TYPE", "SEAT", "TTY")
+	for _, s := range sessions {
+		tty := s.TTY
+		if tty == "" {
+			tty = "-"
+		}
+		seat := s.Seat
+		if seat == "" {
+			seat = "-"
+		}
+		fmt.Printf("%-6s %-12s %-8s %-8s %-8s\n", s.ID, s.Name, s.Type, seat, tty)
+	}
+}

core/cmd/dms/commands_setup.go

@@ -100,56 +100,72 @@ var setupWindowrulesCmd = &cobra.Command{
 }
 
 type dmsConfigSpec struct {
-	niriFile    string
-	hyprFile    string
-	niriContent func(terminal string) string
-	hyprContent func(terminal string) string
+	niriFile     string
+	hyprFile     string
+	mangoFile    string
+	niriContent  func(terminal string) string
+	hyprContent  func(terminal string) string
+	mangoContent func(terminal string) string
 }
 
 var dmsConfigSpecs = map[string]dmsConfigSpec{
 	"binds": {
-		niriFile: "binds.kdl",
-		hyprFile: "binds.conf",
+		niriFile:  "binds.kdl",
+		hyprFile:  "binds.lua",
+		mangoFile: "binds.conf",
 		niriContent: func(t string) string {
 			return strings.ReplaceAll(config.NiriBindsConfig, "{{TERMINAL_COMMAND}}", t)
 		},
 		hyprContent: func(t string) string {
-			return strings.ReplaceAll(config.HyprBindsConfig, "{{TERMINAL_COMMAND}}", t)
+			return strings.ReplaceAll(config.DMSBindsLuaConfig, "{{TERMINAL_COMMAND}}", t)
+		},
+		mangoContent: func(t string) string {
+			return strings.ReplaceAll(config.MangoBindsConfig, "{{TERMINAL_COMMAND}}", t)
 		},
 	},
 	"layout": {
-		niriFile:    "layout.kdl",
-		hyprFile:    "layout.conf",
-		niriContent: func(_ string) string { return config.NiriLayoutConfig },
-		hyprContent: func(_ string) string { return config.HyprLayoutConfig },
+		niriFile:     "layout.kdl",
+		hyprFile:     "layout.lua",
+		mangoFile:    "layout.conf",
+		niriContent:  func(_ string) string { return config.NiriLayoutConfig },
+		hyprContent:  func(_ string) string { return config.DMSLayoutLuaConfig },
+		mangoContent: func(_ string) string { return config.MangoLayoutConfig },
 	},
 	"colors": {
-		niriFile:    "colors.kdl",
-		hyprFile:    "colors.conf",
-		niriContent: func(_ string) string { return config.NiriColorsConfig },
-		hyprContent: func(_ string) string { return config.HyprColorsConfig },
+		niriFile:     "colors.kdl",
+		hyprFile:     "colors.lua",
+		mangoFile:    "colors.conf",
+		niriContent:  func(_ string) string { return config.NiriColorsConfig },
+		hyprContent:  func(_ string) string { return config.DMSColorsLuaConfig },
+		mangoContent: func(_ string) string { return config.MangoColorsConfig },
 	},
 	"alttab": {
 		niriFile:    "alttab.kdl",
 		niriContent: func(_ string) string { return config.NiriAlttabConfig },
 	},
 	"outputs": {
-		niriFile:    "outputs.kdl",
-		hyprFile:    "outputs.conf",
-		niriContent: func(_ string) string { return "" },
-		hyprContent: func(_ string) string { return "" },
+		niriFile:     "outputs.kdl",
+		hyprFile:     "outputs.lua",
+		mangoFile:    "outputs.conf",
+		niriContent:  func(_ string) string { return "" },
+		hyprContent:  func(_ string) string { return config.DMSOutputsLuaConfig },
+		mangoContent: func(_ string) string { return "" },
 	},
 	"cursor": {
-		niriFile:    "cursor.kdl",
-		hyprFile:    "cursor.conf",
-		niriContent: func(_ string) string { return "" },
-		hyprContent: func(_ string) string { return "" },
+		niriFile:     "cursor.kdl",
+		hyprFile:     "cursor.lua",
+		mangoFile:    "cursor.conf",
+		niriContent:  func(_ string) string { return "" },
+		hyprContent:  func(_ string) string { return config.DMSCursorLuaConfig },
+		mangoContent: func(_ string) string { return "" },
 	},
 	"windowrules": {
-		niriFile:    "windowrules.kdl",
-		hyprFile:    "windowrules.conf",
-		niriContent: func(_ string) string { return "" },
-		hyprContent: func(_ string) string { return "" },
+		niriFile:     "windowrules.kdl",
+		hyprFile:     "windowrules.lua",
+		mangoFile:    "windowrules.conf",
+		niriContent:  func(_ string) string { return "" },
+		hyprContent:  func(_ string) string { return config.DMSWindowRulesLuaConfig },
+		mangoContent: func(_ string) string { return "" },
 	},
 }
 
@@ -192,7 +208,7 @@ func detectCompositorForSetup() (string, error) {
 
 	switch len(compositors) {
 	case 0:
-		return "", fmt.Errorf("no supported compositors found (niri or Hyprland required)")
+		return "", fmt.Errorf("no supported compositors found (niri, Hyprland, or mango required)")
 	case 1:
 		return strings.ToLower(compositors[0]), nil
 	}
@@ -224,6 +240,9 @@ func runSetupDmsConfig(name string) error {
 	case "hyprland":
 		filename = spec.hyprFile
 		contentFn = spec.hyprContent
+	case "mango", "mangowc":
+		filename = spec.mangoFile
+		contentFn = spec.mangoContent
 	default:
 		return fmt.Errorf("unsupported compositor: %s", compositor)
 	}
@@ -235,9 +254,11 @@ func runSetupDmsConfig(name string) error {
 	var dmsDir string
 	switch compositor {
 	case "niri":
-		dmsDir = filepath.Join(os.Getenv("HOME"), ".config", "niri", "dms")
+		dmsDir = filepath.Join(utils.XDGConfigHome(), "niri", "dms")
 	case "hyprland":
-		dmsDir = filepath.Join(os.Getenv("HOME"), ".config", "hypr", "dms")
+		dmsDir = filepath.Join(utils.XDGConfigHome(), "hypr", "dms")
+	case "mango", "mangowc":
+		dmsDir = filepath.Join(utils.XDGConfigHome(), "mango", "dms")
 	}
 
 	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
@@ -273,7 +294,14 @@ func runSetup() error {
 
 	wm, wmSelected := promptCompositor()
 	terminal, terminalSelected := promptTerminal()
-	useSystemd := promptSystemd()
+	useSystemd := true
+	if wmSelected {
+		if wm == deps.WindowManagerMango {
+			useSystemd = false
+		} else {
+			useSystemd = promptSystemd()
+		}
+	}
 
 	if !wmSelected && !terminalSelected {
 		fmt.Println("No configurations selected. Exiting.")
@@ -379,10 +407,11 @@ func promptCompositor() (deps.WindowManager, bool) {
 	fmt.Println("Select compositor:")
 	fmt.Println("1) Niri")
 	fmt.Println("2) Hyprland")
-	fmt.Println("3) None")
+	fmt.Println("3) Mango")
+	fmt.Println("4) None")
 
 	var response string
-	fmt.Print("\nChoice (1-3): ")
+	fmt.Print("\nChoice (1-4): ")
 	fmt.Scanln(&response)
 	response = strings.TrimSpace(response)
 
@@ -391,6 +420,8 @@ func promptCompositor() (deps.WindowManager, bool) {
 		return deps.WindowManagerNiri, true
 	case "2":
 		return deps.WindowManagerHyprland, true
+	case "3":
+		return deps.WindowManagerMango, true
 	default:
 		return deps.WindowManagerNiri, false
 	}
@@ -438,16 +469,27 @@ func checkExistingConfigs(wm deps.WindowManager, wmSelected bool, terminal deps.
 	willBackup := false
 
 	if wmSelected {
-		var configPath string
+		var configPaths []string
 		switch wm {
 		case deps.WindowManagerNiri:
-			configPath = filepath.Join(homeDir, ".config", "niri", "config.kdl")
+			configPaths = []string{filepath.Join(homeDir, ".config", "niri", "config.kdl")}
 		case deps.WindowManagerHyprland:
-			configPath = filepath.Join(homeDir, ".config", "hypr", "hyprland.conf")
+			configPaths = []string{
+				filepath.Join(homeDir, ".config", "hypr", "hyprland.lua"),
+				filepath.Join(homeDir, ".config", "hypr", "hyprland.conf"),
+			}
+		case deps.WindowManagerMango:
+			configPaths = []string{
+				filepath.Join(homeDir, ".config", "mango", "config.conf"),
+				filepath.Join(homeDir, ".config", "mango", "mango.conf"),
+			}
 		}
 
-		if _, err := os.Stat(configPath); err == nil {
-			willBackup = true
+		for _, configPath := range configPaths {
+			if _, err := os.Stat(configPath); err == nil {
+				willBackup = true
+				break
+			}
 		}
 	}
 

core/cmd/dms/commands_windowrules.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"path/filepath"
 	"strings"
 	"time"
 
@@ -26,7 +27,7 @@ var windowrulesListCmd = &cobra.Command{
 	Args:  cobra.MaximumNArgs(1),
 	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		if len(args) == 0 {
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
+			return []string{"hyprland", "niri", "mango"}, cobra.ShellCompDirectiveNoFileComp
 		}
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	},
@@ -40,8 +41,7 @@ var windowrulesAddCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(2),
 	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		if len(args) == 0 {
-			// ! disabled hyprland return []string{"hyprland", "niri"}, cobra.ShellCompDirectiveNoFileComp
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
+			return []string{"hyprland", "niri", "mango"}, cobra.ShellCompDirectiveNoFileComp
 		}
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	},
@@ -55,7 +55,7 @@ var windowrulesUpdateCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(3),
 	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		if len(args) == 0 {
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
+			return []string{"hyprland", "niri", "mango"}, cobra.ShellCompDirectiveNoFileComp
 		}
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	},
@@ -69,7 +69,7 @@ var windowrulesRemoveCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(2),
 	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		if len(args) == 0 {
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
+			return []string{"hyprland", "niri", "mango"}, cobra.ShellCompDirectiveNoFileComp
 		}
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	},
@@ -83,7 +83,7 @@ var windowrulesReorderCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(2),
 	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		if len(args) == 0 {
-			return []string{"niri"}, cobra.ShellCompDirectiveNoFileComp
+			return []string{"hyprland", "niri", "mango"}, cobra.ShellCompDirectiveNoFileComp
 		}
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	},
@@ -118,9 +118,12 @@ func getCompositor(args []string) string {
 	if os.Getenv("NIRI_SOCKET") != "" {
 		return "niri"
 	}
-	// if os.Getenv("HYPRLAND_INSTANCE_SIGNATURE") != "" {
-	// 	return "hyprland"
-	// }
+	if os.Getenv("HYPRLAND_INSTANCE_SIGNATURE") != "" {
+		return "hyprland"
+	}
+	if os.Getenv("MANGO_INSTANCE_SIGNATURE") != "" {
+		return "mango"
+	}
 	return ""
 }
 
@@ -140,17 +143,14 @@ func writeRuleSuccess(id, path string) {
 func runWindowrulesList(cmd *cobra.Command, args []string) {
 	compositor := getCompositor(args)
 	if compositor == "" {
-		log.Fatalf("Could not detect compositor. Please specify: hyprland or niri")
+		log.Fatalf("Could not detect compositor. Please specify: hyprland, niri, or mango")
 	}
 
 	var result WindowRulesListResult
 
 	switch compositor {
 	case "niri":
-		configDir, err := utils.ExpandPath("$HOME/.config/niri")
-		if err != nil {
-			log.Fatalf("Failed to expand niri config path: %v", err)
-		}
+		configDir := filepath.Join(utils.XDGConfigHome(), "niri")
 
 		parseResult, err := providers.ParseNiriWindowRules(configDir)
 		if err != nil {
@@ -183,11 +183,7 @@ func runWindowrulesList(cmd *cobra.Command, args []string) {
 		result.DMSStatus = parseResult.DMSStatus
 
 	case "hyprland":
-		log.Fatalf("Hyprland support is currently disabled.") // ! disabled hyprland
-		configDir, err := utils.ExpandPath("$HOME/.config/hypr")
-		if err != nil {
-			log.Fatalf("Failed to expand hyprland config path: %v", err)
-		}
+		configDir := filepath.Join(utils.XDGConfigHome(), "hypr")
 
 		parseResult, err := providers.ParseHyprlandWindowRules(configDir)
 		if err != nil {
@@ -219,6 +215,38 @@ func runWindowrulesList(cmd *cobra.Command, args []string) {
 		result.Rules = allRules
 		result.DMSStatus = parseResult.DMSStatus
 
+	case "mango", "mangowc":
+		configDir := filepath.Join(utils.XDGConfigHome(), "mango")
+
+		parseResult, err := providers.ParseMangoWindowRules(configDir)
+		if err != nil {
+			log.Fatalf("Failed to parse mango window rules: %v", err)
+		}
+
+		allRules := providers.ConvertMangoRulesToWindowRules(parseResult.Rules)
+
+		provider := providers.NewMangoWritableProvider(configDir)
+		dmsRules, _ := provider.LoadDMSRules()
+
+		dmsRuleMap := make(map[int]windowrules.WindowRule)
+		for i, dr := range dmsRules {
+			dmsRuleMap[i] = dr
+		}
+
+		dmsIdx := 0
+		for i, r := range allRules {
+			if r.Source == "dms/windowrules.conf" {
+				if dmr, ok := dmsRuleMap[dmsIdx]; ok {
+					allRules[i].ID = dmr.ID
+					allRules[i].Name = dmr.Name
+				}
+				dmsIdx++
+			}
+		}
+
+		result.Rules = allRules
+		result.DMSStatus = parseResult.DMSStatus
+
 	default:
 		log.Fatalf("Unknown compositor: %s", compositor)
 	}
@@ -317,17 +345,14 @@ func runWindowrulesReorder(cmd *cobra.Command, args []string) {
 func getWindowRulesProvider(compositor string) windowrules.WritableProvider {
 	switch compositor {
 	case "niri":
-		configDir, err := utils.ExpandPath("$HOME/.config/niri")
-		if err != nil {
-			return nil
-		}
+		configDir := filepath.Join(utils.XDGConfigHome(), "niri")
 		return providers.NewNiriWritableProvider(configDir)
 	case "hyprland":
-		configDir, err := utils.ExpandPath("$HOME/.config/hypr")
-		if err != nil {
-			return nil
-		}
+		configDir := filepath.Join(utils.XDGConfigHome(), "hypr")
 		return providers.NewHyprlandWritableProvider(configDir)
+	case "mango", "mangowc":
+		configDir := filepath.Join(utils.XDGConfigHome(), "mango")
+		return providers.NewMangoWritableProvider(configDir)
 	default:
 		return nil
 	}

core/cmd/dms/init_service.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
+)
+
+// runit (Void Linux) service helpers. Services live in /etc/sv and are "enabled"
+// by symlinking them into the /var/service supervision dir, so the greeter
+// commands branch on isRunit() instead of shelling systemctl.
+
+const (
+	runitSvDir      = "/etc/sv"
+	runitServiceDir = "/var/service"
+)
+
+// isRunit reports whether this system is supervised by runit (Void Linux).
+func isRunit() bool {
+	if fi, err := os.Stat("/run/runit"); err == nil && fi.IsDir() {
+		return true
+	}
+	if _, err := os.Stat("/run/systemd/system"); err == nil {
+		return false
+	}
+	if fi, err := os.Stat(runitServiceDir); err == nil && fi.IsDir() {
+		return true
+	}
+	return false
+}
+
+func runitServiceInstalled(name string) bool {
+	fi, err := os.Stat(runitSvDir + "/" + name)
+	return err == nil && fi.IsDir()
+}
+
+func runitServiceEnabled(name string) bool {
+	_, err := os.Lstat(runitServiceDir + "/" + name)
+	return err == nil
+}
+
+// enableRunitService links a service into /var/service (idempotent).
+func enableRunitService(name string) error {
+	if !runitServiceInstalled(name) {
+		return fmt.Errorf("runit service %q not found in %s", name, runitSvDir)
+	}
+	if runitServiceEnabled(name) {
+		return nil
+	}
+	return privesc.Run(context.Background(), "", "ln", "-sf",
+		runitSvDir+"/"+name, runitServiceDir+"/"+name)
+}
+
+// disableRunitService removes a service's supervision symlink.
+func disableRunitService(name string) error {
+	if !runitServiceEnabled(name) {
+		return nil
+	}
+	return privesc.Run(context.Background(), "", "rm", "-f",
+		runitServiceDir+"/"+name)
+}
+
+// ensureRunitSeat sets up the seat access a Wayland greeter needs on runit (the
+// equivalent of logind on systemd): enables seatd and adds the greeter user to
+// the seat/video/input groups. Failures are reported but non-fatal.
+func ensureRunitSeat(greeterUser string) {
+	if runitServiceInstalled("seatd") {
+		if err := enableRunitService("seatd"); err != nil {
+			fmt.Printf("  ⚠ could not enable seatd: %v\n", err)
+		} else {
+			fmt.Println("  ✓ seatd enabled")
+		}
+	} else {
+		fmt.Println("  ⚠ seatd not installed — the greeter compositor needs it for GPU/seat access")
+	}
+	if err := privesc.Run(context.Background(), "", "usermod", "-aG", "_seatd,video,input", greeterUser); err != nil {
+		fmt.Printf("  ⚠ could not add %s to seat groups: %v\n", greeterUser, err)
+	} else {
+		fmt.Printf("  ✓ %s added to seat groups (_seatd, video, input)\n", greeterUser)
+	}
+}
+
+// ensureGreetdPamRundir adds pam_rundir to the greetd PAM stack so the post-login
+// session gets an XDG_RUNTIME_DIR on systems without logind (Void with seatd).
+// Appended outside DMS's managed auth block so it survives `dms greeter sync`.
+func ensureGreetdPamRundir() {
+	const pamPath = "/etc/pam.d/greetd"
+	data, err := os.ReadFile(pamPath)
+	if err != nil {
+		fmt.Printf("  ⚠ could not read %s: %v\n", pamPath, err)
+		return
+	}
+	if strings.Contains(string(data), "pam_rundir") {
+		return
+	}
+	line := "session    optional    pam_rundir.so"
+	if err := privesc.Run(context.Background(), "", "sh", "-c",
+		fmt.Sprintf("printf '%%s\\n' %q >> %s", line, pamPath)); err != nil {
+		fmt.Printf("  ⚠ could not add pam_rundir to %s: %v\n", pamPath, err)
+		return
+	}
+	fmt.Println("  ✓ pam_rundir added to greetd PAM (provides XDG_RUNTIME_DIR for the session)")
+}
+
+// startGreeterHint returns the init-appropriate "start greetd now" command.
+func startGreeterHint() string {
+	if isRunit() {
+		return "  sudo sv up greetd"
+	}
+	return "  sudo systemctl start greetd"
+}

core/cmd/dms/main.go

@@ -19,7 +19,7 @@ func init() {
 	runCmd.Flags().String("log-file", "", "Append logs to this file in addition to stderr (overrides DMS_LOG_FILE)")
 	runCmd.Flags().MarkHidden("daemon-child")
 
-	greeterCmd.AddCommand(greeterInstallCmd, greeterSyncCmd, greeterEnableCmd, greeterStatusCmd, greeterUninstallCmd)
+	greeterCmd.AddCommand(greeterInstallCmd, greeterSyncCmd, greeterEnableCmd, greeterStatusCmd, greeterUninstallCmd, greeterLaunchSessionCmd)
 	authCmd.AddCommand(authSyncCmd)
 	setupCmd.AddCommand(setupBindsCmd, setupLayoutCmd, setupColorsCmd, setupAlttabCmd, setupOutputsCmd, setupCursorCmd, setupWindowrulesCmd)
 	updateCmd.AddCommand(updateCheckCmd)

core/cmd/dms/main_distro.go

@@ -19,7 +19,7 @@ func init() {
 	runCmd.Flags().String("log-file", "", "Append logs to this file in addition to stderr (overrides DMS_LOG_FILE)")
 	runCmd.Flags().MarkHidden("daemon-child")
 
-	greeterCmd.AddCommand(greeterInstallCmd, greeterSyncCmd, greeterEnableCmd, greeterStatusCmd, greeterUninstallCmd)
+	greeterCmd.AddCommand(greeterInstallCmd, greeterSyncCmd, greeterEnableCmd, greeterStatusCmd, greeterUninstallCmd, greeterLaunchSessionCmd)
 	authCmd.AddCommand(authSyncCmd)
 	setupCmd.AddCommand(setupBindsCmd, setupLayoutCmd, setupColorsCmd, setupAlttabCmd, setupOutputsCmd, setupCursorCmd, setupWindowrulesCmd)
 	pluginsCmd.AddCommand(pluginsBrowseCmd, pluginsListCmd, pluginsInstallCmd, pluginsUninstallCmd, pluginsUpdateCmd)

core/cmd/dms/server_client.go

@@ -12,6 +12,10 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
 )
 
+// maxIPCMessageSize allows room for a 50 MB clipboard entry plus JSON/base64
+// overhead in the line-delimited IPC response.
+const maxIPCMessageSize = 96 * 1024 * 1024
+
 func sendServerRequest(req models.Request) (*models.Response[any], error) {
 	socketPath := getServerSocketPath()
 
@@ -22,6 +26,7 @@ func sendServerRequest(req models.Request) (*models.Response[any], error) {
 	defer conn.Close()
 
 	scanner := bufio.NewScanner(conn)
+	scanner.Buffer(make([]byte, bufio.MaxScanTokenSize), maxIPCMessageSize)
 	scanner.Scan() // discard initial capabilities message
 
 	reqData, err := json.Marshal(req)
@@ -61,6 +66,7 @@ func sendServerRequestFireAndForget(req models.Request) error {
 	defer conn.Close()
 
 	scanner := bufio.NewScanner(conn)
+	scanner.Buffer(make([]byte, bufio.MaxScanTokenSize), maxIPCMessageSize)
 	scanner.Scan() // discard initial capabilities message
 
 	reqData, err := json.Marshal(req)

core/cmd/dms/shell.go

@@ -2,7 +2,9 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"os/signal"
@@ -192,6 +194,7 @@ func runShellInteractive(session bool) {
 		}
 	}()
 
+	ensureFontCache()
 	log.Infof("Spawning quickshell with -p %s", configPath)
 
 	cmd := exec.CommandContext(ctx, "qs", "-p", configPath)
@@ -222,13 +225,18 @@ func runShellInteractive(session bool) {
 	if os.Getenv("QT_QPA_PLATFORM") == "" {
 		cmd.Env = append(cmd.Env, "QT_QPA_PLATFORM=wayland;xcb")
 	}
+	if os.Getenv("QSG_USE_SIMPLE_ANIMATION_DRIVER") == "" {
+		cmd.Env = append(cmd.Env, "QSG_USE_SIMPLE_ANIMATION_DRIVER=1")
+	}
 
 	cmd.Env = appendLogEnv(cmd.Env)
 
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
+	tracker := &stderrTracker{parent: os.Stderr}
+	cmd.Stderr = tracker
 
+	startTime := time.Now()
 	if err := cmd.Start(); err != nil {
 		log.Fatalf("Error starting quickshell: %v", err)
 	}
@@ -277,7 +285,9 @@ func runShellInteractive(session bool) {
 			case <-errChan:
 				cancel()
 				os.Remove(socketPath)
-				os.Exit(getProcessExitCode(cmd.ProcessState))
+				exitCode := getProcessExitCode(cmd.ProcessState)
+				logStartupFailure(startTime, exitCode, tracker)
+				os.Exit(exitCode)
 			case <-time.After(500 * time.Millisecond):
 			}
 
@@ -294,7 +304,9 @@ func runShellInteractive(session bool) {
 				cmd.Process.Signal(syscall.SIGTERM)
 			}
 			os.Remove(socketPath)
-			os.Exit(getProcessExitCode(cmd.ProcessState))
+			exitCode := getProcessExitCode(cmd.ProcessState)
+			logStartupFailure(startTime, exitCode, tracker)
+			os.Exit(exitCode)
 		}
 	}
 }
@@ -434,6 +446,7 @@ func runShellDaemon(session bool) {
 		}
 	}()
 
+	ensureFontCache()
 	log.Infof("Spawning quickshell with -p %s", configPath)
 
 	cmd := exec.CommandContext(ctx, "qs", "-p", configPath)
@@ -467,6 +480,9 @@ func runShellDaemon(session bool) {
 	if os.Getenv("QT_QPA_PLATFORM") == "" {
 		cmd.Env = append(cmd.Env, "QT_QPA_PLATFORM=wayland;xcb")
 	}
+	if os.Getenv("QSG_USE_SIMPLE_ANIMATION_DRIVER") == "" {
+		cmd.Env = append(cmd.Env, "QSG_USE_SIMPLE_ANIMATION_DRIVER=1")
+	}
 
 	cmd.Env = appendLogEnv(cmd.Env)
 
@@ -478,8 +494,10 @@ func runShellDaemon(session bool) {
 
 	cmd.Stdin = devNull
 	cmd.Stdout = devNull
-	cmd.Stderr = devNull
+	tracker := &stderrTracker{parent: devNull}
+	cmd.Stderr = tracker
 
+	startTime := time.Now()
 	if err := cmd.Start(); err != nil {
 		log.Fatalf("Error starting daemon: %v", err)
 	}
@@ -528,7 +546,9 @@ func runShellDaemon(session bool) {
 			case <-errChan:
 				cancel()
 				os.Remove(socketPath)
-				os.Exit(getProcessExitCode(cmd.ProcessState))
+				exitCode := getProcessExitCode(cmd.ProcessState)
+				logStartupFailure(startTime, exitCode, tracker)
+				os.Exit(exitCode)
 			case <-time.After(500 * time.Millisecond):
 			}
 
@@ -543,7 +563,9 @@ func runShellDaemon(session bool) {
 				cmd.Process.Signal(syscall.SIGTERM)
 			}
 			os.Remove(socketPath)
-			os.Exit(getProcessExitCode(cmd.ProcessState))
+			exitCode := getProcessExitCode(cmd.ProcessState)
+			logStartupFailure(startTime, exitCode, tracker)
+			os.Exit(exitCode)
 		}
 	}
 }
@@ -585,12 +607,30 @@ func parseTargetsFromIPCShowOutput(output string) ipcTargets {
 	return targets
 }
 
-func getShellIPCCompletions(args []string, _ string) []string {
+func buildQsIPCBaseArgs() ([]string, error) {
 	cmdArgs := []string{"ipc"}
-	if qsHasAnyDisplay() {
-		cmdArgs = append(cmdArgs, "--any-display")
+	switch pid, ok := getFirstDMSPID(); {
+	case ok:
+		cmdArgs = append(cmdArgs, "--pid", strconv.Itoa(pid))
+	default:
+		if err := findConfig(nil, nil); err != nil {
+			return nil, err
+		}
+		if qsHasAnyDisplay() {
+			cmdArgs = append(cmdArgs, "--any-display")
+		}
+		cmdArgs = append(cmdArgs, "-p", configPath)
 	}
-	cmdArgs = append(cmdArgs, "-p", configPath, "show")
+	return cmdArgs, nil
+}
+
+func getShellIPCCompletions(args []string, _ string) []string {
+	baseArgs, err := buildQsIPCBaseArgs()
+	if err != nil {
+		log.Debugf("Error building IPC args for completions: %v", err)
+		return nil
+	}
+	cmdArgs := append(baseArgs, "show")
 	cmd := exec.Command("qs", cmdArgs...)
 	var targets ipcTargets
 
@@ -607,7 +647,7 @@ func getShellIPCCompletions(args []string, _ string) []string {
 
 	if len(args) == 0 {
 		targetNames := make([]string, 0)
-		targetNames = append(targetNames, "call")
+		targetNames = append(targetNames, "call", "list")
 		for k := range targets {
 			targetNames = append(targetNames, k)
 		}
@@ -680,23 +720,11 @@ func runShellIPCCommand(args []string) {
 		args = append([]string{"call"}, args...)
 	}
 
-	cmdArgs := []string{"ipc"}
-
-	switch pid, ok := getFirstDMSPID(); {
-	case ok:
-		cmdArgs = append(cmdArgs, "--pid", strconv.Itoa(pid))
-	default:
-		if err := findConfig(nil, nil); err != nil {
-			log.Fatalf("Error finding config: %v", err)
-		}
-		// ! TODO - remove check when QS 0.3 is released
-		if qsHasAnyDisplay() {
-			cmdArgs = append(cmdArgs, "--any-display")
-		}
-		cmdArgs = append(cmdArgs, "-p", configPath)
+	baseArgs, err := buildQsIPCBaseArgs()
+	if err != nil {
+		log.Fatalf("Error finding config: %v", err)
 	}
-
-	cmdArgs = append(cmdArgs, args...)
+	cmdArgs := append(baseArgs, args...)
 	cmd := exec.Command("qs", cmdArgs...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
@@ -708,19 +736,20 @@ func runShellIPCCommand(args []string) {
 }
 
 func printIPCHelp() {
-	fmt.Println("Usage: dms ipc <target> <function> [args...]")
+	fmt.Println("Usage: dms ipc call <target> <function> [args...]")
 	fmt.Println()
 
-	cmdArgs := []string{"ipc"}
-	if qsHasAnyDisplay() {
-		cmdArgs = append(cmdArgs, "--any-display")
+	baseArgs, err := buildQsIPCBaseArgs()
+	if err != nil {
+		printIPCHelpFailure(err)
+		return
 	}
-	cmdArgs = append(cmdArgs, "-p", configPath, "show")
+	cmdArgs := append(baseArgs, "show")
 	cmd := exec.Command("qs", cmdArgs...)
 
 	output, err := cmd.Output()
 	if err != nil {
-		fmt.Println("Could not retrieve available IPC targets (is DMS running?)")
+		printIPCHelpFailure(err)
 		return
 	}
 
@@ -748,3 +777,143 @@ func printIPCHelp() {
 		fmt.Printf("  %-16s %s\n", targetName, strings.Join(funcNames, ", "))
 	}
 }
+
+func printIPCHelpFailure(err error) {
+	fmt.Println("Could not retrieve IPC targets.")
+	if err != nil {
+		fmt.Printf("  %v\n", err)
+	}
+	fmt.Println()
+	fmt.Println("  Full docs:  https://danklinux.com/docs/dankmaterialshell/keybinds-ipc")
+	fmt.Println("  Try:        dms ipc call <target> <function>")
+}
+
+// ensureFontCache rebuilds the fontconfig cache if user-configured fonts are missing while skipping defaults
+func ensureFontCache() {
+	if _, err := exec.LookPath("fc-list"); err != nil {
+		return
+	}
+	if _, err := exec.LookPath("fc-cache"); err != nil {
+		return
+	}
+
+	var fontsToCheck []string
+
+	if configDir, err := os.UserConfigDir(); err == nil {
+		settingsPath := filepath.Join(configDir, "DankMaterialShell", "settings.json")
+		if data, err := os.ReadFile(settingsPath); err == nil {
+			var settings struct {
+				FontFamily     string `json:"fontFamily"`
+				MonoFontFamily string `json:"monoFontFamily"`
+			}
+			if err := json.Unmarshal(data, &settings); err == nil {
+				if settings.FontFamily != "" && settings.FontFamily != "Inter Variable" {
+					fontsToCheck = append(fontsToCheck, settings.FontFamily)
+				}
+				if settings.MonoFontFamily != "" && settings.MonoFontFamily != "Fira Code" {
+					fontsToCheck = append(fontsToCheck, settings.MonoFontFamily)
+				}
+			}
+		}
+	}
+
+	if len(fontsToCheck) == 0 {
+		return
+	}
+
+	output, err := exec.Command("fc-list", ":", "family").Output()
+	if err != nil || len(strings.TrimSpace(string(output))) == 0 {
+		log.Warnf("Font cache appears empty or corrupt, rebuilding...")
+		rebuildFontCache()
+		return
+	}
+
+	cacheFonts := strings.ToLower(string(output))
+	var missing []string
+	for _, font := range fontsToCheck {
+		if !fontInCache(strings.ToLower(font), cacheFonts) {
+			missing = append(missing, font)
+		}
+	}
+
+	if len(missing) > 0 {
+		log.Warnf("Font(s) not found in cache: %s — rebuilding...", strings.Join(missing, ", "))
+		rebuildFontCache()
+	}
+}
+
+func fontInCache(target, cache string) bool {
+	for _, line := range strings.Split(cache, "\n") {
+		for _, fam := range strings.Split(strings.TrimSpace(line), ",") {
+			if strings.TrimSpace(fam) == target {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func rebuildFontCache() {
+	cmd := exec.Command("fc-cache", "-f")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		log.Warnf("Failed to rebuild font cache: %v\n%s", err, string(output))
+	} else {
+		log.Infof("Font cache rebuilt successfully")
+	}
+}
+
+type stderrTracker struct {
+	mu     sync.Mutex
+	buf    strings.Builder
+	parent io.Writer
+}
+
+func (s *stderrTracker) Write(p []byte) (n int, err error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.buf.Len() < 8192 {
+		s.buf.Write(p)
+	}
+	if s.parent != nil {
+		return s.parent.Write(p)
+	}
+	return len(p), nil
+}
+
+func (s *stderrTracker) String() string {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.buf.String()
+}
+
+// logStartupFailure logs diagnostic advice if qs crashes within 5s of launch.
+func logStartupFailure(startTime time.Time, exitCode int, tracker *stderrTracker) {
+	if time.Since(startTime) >= 5*time.Second || exitCode == 0 || exitCode > 128 {
+		return
+	}
+	if containsFontCrashSignature(tracker.String()) {
+		log.Errorf("DMS startup failed due to a potential font/rendering crash. Try running 'fc-cache -fv' and restarting DMS.")
+	} else {
+		log.Errorf("DMS startup failed (exit code %d). Run 'dms doctor' for more diagnostics.", exitCode)
+	}
+}
+
+func containsFontCrashSignature(logStr string) bool {
+	logStr = strings.ToLower(logStr)
+	signatures := []string{
+		"fontconfig",
+		"freetype",
+		"ft_load_glyph",
+		"ft_face",
+		"fc-list",
+		"fc-cache",
+		"glyph",
+		"typeface",
+	}
+	for _, sig := range signatures {
+		if strings.Contains(logStr, sig) {
+			return true
+		}
+	}
+	return false
+}

core/internal/config/deployer.go

@@ -12,6 +12,8 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/deps"
 )
 
+const hyprlandBackupDirName = ".dms-backups"
+
 type ConfigDeployer struct {
 	logChan chan<- string
 }
@@ -63,12 +65,27 @@ func (cd *ConfigDeployer) deployConfigurationsInternal(ctx context.Context, wm d
 	var results []DeploymentResult
 
 	// Primary config file paths used to detect fresh installs.
-	configPrimaryPaths := map[string]string{
-		"Niri":      filepath.Join(os.Getenv("HOME"), ".config", "niri", "config.kdl"),
-		"Hyprland":  filepath.Join(os.Getenv("HOME"), ".config", "hypr", "hyprland.conf"),
-		"Ghostty":   filepath.Join(os.Getenv("HOME"), ".config", "ghostty", "config"),
-		"Kitty":     filepath.Join(os.Getenv("HOME"), ".config", "kitty", "kitty.conf"),
-		"Alacritty": filepath.Join(os.Getenv("HOME"), ".config", "alacritty", "alacritty.toml"),
+	configPrimaryPaths := map[string][]string{
+		"Niri": {
+			filepath.Join(os.Getenv("HOME"), ".config", "niri", "config.kdl"),
+		},
+		"Hyprland": {
+			filepath.Join(os.Getenv("HOME"), ".config", "hypr", "hyprland.lua"),
+			filepath.Join(os.Getenv("HOME"), ".config", "hypr", "hyprland.conf"),
+		},
+		"Mango": {
+			filepath.Join(os.Getenv("HOME"), ".config", "mango", "config.conf"),
+			filepath.Join(os.Getenv("HOME"), ".config", "mango", "mango.conf"),
+		},
+		"Ghostty": {
+			filepath.Join(os.Getenv("HOME"), ".config", "ghostty", "config"),
+		},
+		"Kitty": {
+			filepath.Join(os.Getenv("HOME"), ".config", "kitty", "kitty.conf"),
+		},
+		"Alacritty": {
+			filepath.Join(os.Getenv("HOME"), ".config", "alacritty", "alacritty.toml"),
+		},
 	}
 
 	shouldReplaceConfig := func(configType string) bool {
@@ -81,8 +98,15 @@ func (cd *ConfigDeployer) deployConfigurationsInternal(ctx context.Context, wm d
 		}
 		// Config is explicitly set to "don't replace" — but still deploy
 		// if the config file doesn't exist yet (fresh install scenario).
-		if primaryPath, ok := configPrimaryPaths[configType]; ok {
-			if _, err := os.Stat(primaryPath); os.IsNotExist(err) {
+		if primaryPaths, ok := configPrimaryPaths[configType]; ok {
+			exists := false
+			for _, primaryPath := range primaryPaths {
+				if _, err := os.Stat(primaryPath); err == nil {
+					exists = true
+					break
+				}
+			}
+			if !exists {
 				return true
 			}
 		}
@@ -106,6 +130,14 @@ func (cd *ConfigDeployer) deployConfigurationsInternal(ctx context.Context, wm d
 				return results, fmt.Errorf("failed to deploy Hyprland config: %w", err)
 			}
 		}
+	case deps.WindowManagerMango:
+		if shouldReplaceConfig("Mango") {
+			result, err := cd.deployMangoConfig(terminal, useSystemd)
+			results = append(results, result)
+			if err != nil {
+				return results, fmt.Errorf("failed to deploy Mango config: %w", err)
+			}
+		}
 	}
 
 	switch terminal {
@@ -249,6 +281,96 @@ func (cd *ConfigDeployer) deployNiriDmsConfigs(dmsDir, terminalCommand string) e
 	return nil
 }
 
+func (cd *ConfigDeployer) deployMangoConfig(terminal deps.Terminal, useSystemd bool) (DeploymentResult, error) {
+	result := DeploymentResult{
+		ConfigType: "Mango",
+		Path:       filepath.Join(os.Getenv("HOME"), ".config", "mango", "config.conf"),
+	}
+
+	configDir := filepath.Dir(result.Path)
+	if err := os.MkdirAll(configDir, 0o755); err != nil {
+		result.Error = fmt.Errorf("failed to create config directory: %w", err)
+		return result, result.Error
+	}
+
+	dmsDir := filepath.Join(configDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		result.Error = fmt.Errorf("failed to create dms directory: %w", err)
+		return result, result.Error
+	}
+
+	var terminalCommand string
+	switch terminal {
+	case deps.TerminalGhostty:
+		terminalCommand = "ghostty"
+	case deps.TerminalKitty:
+		terminalCommand = "kitty"
+	case deps.TerminalAlacritty:
+		terminalCommand = "alacritty"
+	default:
+		terminalCommand = "ghostty"
+	}
+
+	// DMS owns config.conf for mango (like niri/hyprland): back up and replace.
+	if existingData, err := os.ReadFile(result.Path); err == nil {
+		cd.log("Found existing Mango configuration")
+		timestamp := time.Now().Format("2006-01-02_15-04-05")
+		result.BackupPath = result.Path + ".backup." + timestamp
+		if err := os.WriteFile(result.BackupPath, existingData, 0o644); err != nil {
+			result.Error = fmt.Errorf("failed to create backup: %w", err)
+			return result, result.Error
+		}
+		cd.log(fmt.Sprintf("Backed up existing config to %s", result.BackupPath))
+	}
+
+	newConfig := strings.ReplaceAll(MangoConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
+	if err := os.WriteFile(result.Path, []byte(newConfig), 0o644); err != nil {
+		result.Error = fmt.Errorf("failed to write config: %w", err)
+		return result, result.Error
+	}
+
+	if err := cd.deployMangoDmsConfigs(dmsDir, terminalCommand); err != nil {
+		result.Error = fmt.Errorf("failed to deploy dms configs: %w", err)
+		return result, result.Error
+	}
+
+	result.Deployed = true
+	cd.log("Successfully deployed Mango configuration")
+	return result, nil
+}
+
+func (cd *ConfigDeployer) deployMangoDmsConfigs(dmsDir, terminalCommand string) error {
+	configs := []struct {
+		name      string
+		content   string
+		overwrite bool
+	}{
+		// binds.conf is DMS-owned (overwrite); the rest are runtime/user-managed.
+		{"binds.conf", strings.ReplaceAll(MangoBindsConfig, "{{TERMINAL_COMMAND}}", terminalCommand), true},
+		{"colors.conf", MangoColorsConfig, false},
+		{"layout.conf", MangoLayoutConfig, false},
+		{"outputs.conf", "", false},
+		{"cursor.conf", "", false},
+		{"windowrules.conf", "", false},
+	}
+
+	for _, cfg := range configs {
+		path := filepath.Join(dmsDir, cfg.name)
+		if !cfg.overwrite {
+			if info, err := os.Stat(path); err == nil && info.Size() > 0 {
+				cd.log(fmt.Sprintf("Skipping %s (already exists)", cfg.name))
+				continue
+			}
+		}
+		if err := os.WriteFile(path, []byte(cfg.content), 0o644); err != nil {
+			return fmt.Errorf("failed to write %s: %w", cfg.name, err)
+		}
+		cd.log(fmt.Sprintf("Deployed %s", cfg.name))
+	}
+
+	return nil
+}
+
 func (cd *ConfigDeployer) deployGhosttyConfig() ([]DeploymentResult, error) {
 	var results []DeploymentResult
 
@@ -495,7 +617,7 @@ func (cd *ConfigDeployer) mergeNiriOutputSections(newConfig, existingConfig, dms
 func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystemd bool) (DeploymentResult, error) {
 	result := DeploymentResult{
 		ConfigType: "Hyprland",
-		Path:       filepath.Join(os.Getenv("HOME"), ".config", "hypr", "hyprland.conf"),
+		Path:       filepath.Join(os.Getenv("HOME"), ".config", "hypr", "hyprland.lua"),
 	}
 
 	configDir := filepath.Dir(result.Path)
@@ -510,20 +632,20 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 		return result, result.Error
 	}
 
+	timestamp := time.Now().Format("2006-01-02_15-04-05")
+	backupDir := filepath.Join(configDir, hyprlandBackupDirName, timestamp)
 	var existingConfig string
-	if _, err := os.Stat(result.Path); err == nil {
-		cd.log("Found existing Hyprland configuration")
+	existingData, existingPath, err := readExistingHyprlandConfig(configDir)
+	if err != nil {
+		result.Error = err
+		return result, result.Error
+	}
+	if existingData != "" {
+		existingConfig = existingData
+		cd.log(fmt.Sprintf("Found existing Hyprland configuration at %s", existingPath))
 
-		existingData, err := os.ReadFile(result.Path)
-		if err != nil {
-			result.Error = fmt.Errorf("failed to read existing config: %w", err)
-			return result, result.Error
-		}
-		existingConfig = string(existingData)
-
-		timestamp := time.Now().Format("2006-01-02_15-04-05")
-		result.BackupPath = result.Path + ".backup." + timestamp
-		if err := os.WriteFile(result.BackupPath, existingData, 0o644); err != nil {
+		result.BackupPath = filepath.Join(backupDir, filepath.Base(existingPath))
+		if err := backupHyprlandConfigFile(existingPath, result.BackupPath, []byte(existingData), strings.EqualFold(filepath.Ext(existingPath), ".conf")); err != nil {
 			result.Error = fmt.Errorf("failed to create backup: %w", err)
 			return result, result.Error
 		}
@@ -542,10 +664,10 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 		terminalCommand = "ghostty"
 	}
 
-	newConfig := strings.ReplaceAll(HyprlandConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
+	newConfig := strings.ReplaceAll(HyprlandLuaConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
 
 	if !useSystemd {
-		newConfig = cd.transformHyprlandConfigForNonSystemd(newConfig, terminalCommand)
+		newConfig = transformHyprlandLuaForNonSystemd(newConfig, terminalCommand)
 	}
 
 	if existingConfig != "" {
@@ -563,39 +685,144 @@ func (cd *ConfigDeployer) deployHyprlandConfig(terminal deps.Terminal, useSystem
 		return result, result.Error
 	}
 
+	movedLegacy, err := backupLegacyHyprlandConfFiles(configDir, dmsDir, backupDir)
+	if err != nil {
+		result.Error = fmt.Errorf("failed to back up legacy hyprlang configs: %w", err)
+		return result, result.Error
+	}
+	if movedLegacy > 0 {
+		if result.BackupPath == "" {
+			result.BackupPath = backupDir
+		}
+		cd.log(fmt.Sprintf("Moved %d legacy hyprlang config(s) to %s", movedLegacy, backupDir))
+	}
+
 	if err := cd.deployHyprlandDmsConfigs(dmsDir, terminalCommand); err != nil {
 		result.Error = fmt.Errorf("failed to deploy dms configs: %w", err)
 		return result, result.Error
 	}
 
+	CleanupStrayHyprlandConfFile(func(format string, v ...any) {
+		cd.log(fmt.Sprintf(format, v...))
+	})
+
 	result.Deployed = true
 	cd.log("Successfully deployed Hyprland configuration")
 	return result, nil
 }
 
+func backupHyprlandConfigFile(src, dst string, data []byte, removeSource bool) error {
+	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
+		return err
+	}
+	if err := os.WriteFile(dst, data, 0o644); err != nil {
+		return err
+	}
+	if removeSource {
+		if err := os.Remove(src); err != nil && !os.IsNotExist(err) {
+			return err
+		}
+	}
+	return nil
+}
+
+func backupLegacyHyprlandConfFiles(configDir, dmsDir, backupDir string) (int, error) {
+	legacyPaths := []string{filepath.Join(configDir, "hyprland.conf")}
+	dmsConfPaths, err := filepath.Glob(filepath.Join(dmsDir, "*.conf"))
+	if err != nil {
+		return 0, err
+	}
+	legacyPaths = append(legacyPaths, dmsConfPaths...)
+	backupPaths, err := adjacentHyprlandBackupFiles(configDir, dmsDir)
+	if err != nil {
+		return 0, err
+	}
+	legacyPaths = append(legacyPaths, backupPaths...)
+
+	moved := 0
+	for _, src := range legacyPaths {
+		info, err := os.Lstat(src)
+		if os.IsNotExist(err) {
+			continue
+		}
+		if err != nil {
+			return moved, err
+		}
+		if info.IsDir() {
+			continue
+		}
+
+		rel, err := filepath.Rel(configDir, src)
+		if err != nil {
+			rel = filepath.Base(src)
+		}
+		dst := filepath.Join(backupDir, rel)
+		if err := moveHyprlandConfigFile(src, dst); err != nil {
+			return moved, err
+		}
+		moved++
+	}
+
+	return moved, nil
+}
+
+func moveHyprlandConfigFile(src, dst string) error {
+	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
+		return err
+	}
+	return os.Rename(src, dst)
+}
+
+func adjacentHyprlandBackupFiles(configDir, dmsDir string) ([]string, error) {
+	var paths []string
+	patterns := []string{
+		filepath.Join(configDir, "hyprland.conf.backup.*"),
+		filepath.Join(configDir, "hyprland.lua.backup.*"),
+		filepath.Join(dmsDir, "*.conf.backup.*"),
+		filepath.Join(dmsDir, "*.lua.backup.*"),
+	}
+	for _, pattern := range patterns {
+		matches, err := filepath.Glob(pattern)
+		if err != nil {
+			return nil, err
+		}
+		paths = append(paths, matches...)
+	}
+	return paths, nil
+}
+
 func (cd *ConfigDeployer) deployHyprlandDmsConfigs(dmsDir string, terminalCommand string) error {
 	configs := []struct {
-		name    string
-		content string
+		name      string
+		content   string
+		overwrite bool
 	}{
-		{"colors.conf", HyprColorsConfig},
-		{"layout.conf", HyprLayoutConfig},
-		{"binds.conf", strings.ReplaceAll(HyprBindsConfig, "{{TERMINAL_COMMAND}}", terminalCommand)},
-		{"outputs.conf", ""},
-		{"cursor.conf", ""},
-		{"windowrules.conf", ""},
+		{name: "colors.lua", content: DMSColorsLuaConfig},
+		{name: "layout.lua", content: DMSLayoutLuaConfig},
+		{name: "binds.lua", content: strings.ReplaceAll(DMSBindsLuaConfig, "{{TERMINAL_COMMAND}}", terminalCommand), overwrite: true},
+		{name: "binds-user.lua", content: DMSBindsUserLuaConfig},
+		{name: "outputs.lua", content: DMSOutputsLuaConfig},
+		{name: "cursor.lua", content: DMSCursorLuaConfig},
+		{name: "windowrules.lua", content: DMSWindowRulesLuaConfig},
 	}
 
 	for _, cfg := range configs {
 		path := filepath.Join(dmsDir, cfg.name)
-		// Skip if file already exists and is not empty to preserve user modifications
+		existed := false
 		if info, err := os.Stat(path); err == nil && info.Size() > 0 {
+			existed = true
+		}
+		if existed && !cfg.overwrite {
 			cd.log(fmt.Sprintf("Skipping %s (already exists)", cfg.name))
 			continue
 		}
 		if err := os.WriteFile(path, []byte(cfg.content), 0o644); err != nil {
 			return fmt.Errorf("failed to write %s: %w", cfg.name, err)
 		}
+		if existed {
+			cd.log(fmt.Sprintf("Updated %s", cfg.name))
+			continue
+		}
 		cd.log(fmt.Sprintf("Deployed %s", cfg.name))
 	}
 
@@ -603,94 +830,42 @@ func (cd *ConfigDeployer) deployHyprlandDmsConfigs(dmsDir string, terminalComman
 }
 
 func (cd *ConfigDeployer) mergeHyprlandMonitorSections(newConfig, existingConfig, dmsDir string) (string, error) {
-	monitorRegex := regexp.MustCompile(`(?m)^#?\s*monitor\s*=.*$`)
-	existingMonitors := monitorRegex.FindAllString(existingConfig, -1)
-
-	if len(existingMonitors) == 0 {
+	_ = newConfig
+	lines := extractHyprlangMonitorLines(existingConfig)
+	if len(lines) == 0 {
 		return newConfig, nil
 	}
 
-	outputsPath := filepath.Join(dmsDir, "outputs.conf")
-	if _, err := os.Stat(outputsPath); err != nil {
-		var outputsContent strings.Builder
-		for _, monitor := range existingMonitors {
-			outputsContent.WriteString(monitor)
-			outputsContent.WriteString("\n")
-		}
-		if err := os.WriteFile(outputsPath, []byte(outputsContent.String()), 0o644); err != nil {
-			cd.log(fmt.Sprintf("Warning: Failed to migrate monitors to %s: %v", outputsPath, err))
-		} else {
-			cd.log("Migrated monitor sections to dms/outputs.conf")
-		}
+	outputsPath := filepath.Join(dmsDir, "outputs.lua")
+	if info, err := os.Stat(outputsPath); err == nil && info.Size() > 0 {
+		cd.log("Skipping monitor migration: dms/outputs.lua already exists")
+		return newConfig, nil
 	}
 
-	exampleMonitorRegex := regexp.MustCompile(`(?m)^# monitor = eDP-2.*$`)
-	mergedConfig := exampleMonitorRegex.ReplaceAllString(newConfig, "")
-
-	monitorHeaderRegex := regexp.MustCompile(`(?m)^# MONITOR CONFIG\n# ==================$`)
-	headerMatch := monitorHeaderRegex.FindStringIndex(mergedConfig)
-
-	if headerMatch == nil {
-		return "", fmt.Errorf("could not find MONITOR CONFIG section")
-	}
-
-	insertPos := headerMatch[1] + 1
-
-	var builder strings.Builder
-	builder.WriteString(mergedConfig[:insertPos])
-	builder.WriteString("# Monitors from existing configuration\n")
-
-	for _, monitor := range existingMonitors {
-		builder.WriteString(monitor)
-		builder.WriteString("\n")
-	}
-
-	builder.WriteString(mergedConfig[insertPos:])
-
-	return builder.String(), nil
-}
-
-func (cd *ConfigDeployer) transformHyprlandConfigForNonSystemd(config, terminalCommand string) string {
-	lines := strings.Split(config, "\n")
-	var result []string
-	startupSectionFound := false
-
+	var b strings.Builder
+	b.WriteString("-- Migrated from existing hyprlang monitor lines\n\n")
+	ok := 0
 	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "exec-once = dbus-update-activation-environment") {
+		lua, err := hyprlangMonitorLineToLua(line)
+		if err != nil {
+			cd.log(fmt.Sprintf("Warning: could not migrate monitor line %q: %v", line, err))
 			continue
 		}
-		if strings.HasPrefix(trimmed, "exec-once = systemctl --user start") {
-			startupSectionFound = true
-			result = append(result, "exec-once = dms run")
-			result = append(result, "env = QT_QPA_PLATFORM,wayland;xcb")
-			result = append(result, "env = ELECTRON_OZONE_PLATFORM_HINT,auto")
-			result = append(result, "env = QT_QPA_PLATFORMTHEME,gtk3")
-			result = append(result, "env = QT_QPA_PLATFORMTHEME_QT6,gtk3")
-			result = append(result, fmt.Sprintf("env = TERMINAL,%s", terminalCommand))
-			continue
-		}
-		result = append(result, line)
+		b.WriteString(lua)
+		b.WriteByte('\n')
+		ok++
 	}
-
-	if !startupSectionFound {
-		for i, line := range result {
-			if strings.Contains(line, "STARTUP APPS") {
-				insertLines := []string{
-					"exec-once = dms run",
-					"env = QT_QPA_PLATFORM,wayland;xcb",
-					"env = ELECTRON_OZONE_PLATFORM_HINT,auto",
-					"env = QT_QPA_PLATFORMTHEME,gtk3",
-					"env = QT_QPA_PLATFORMTHEME_QT6,gtk3",
-					fmt.Sprintf("env = TERMINAL,%s", terminalCommand),
-				}
-				result = append(result[:i+2], append(insertLines, result[i+2:]...)...)
-				break
-			}
-		}
+	if ok == 0 {
+		return newConfig, nil
 	}
-
-	return strings.Join(result, "\n")
+	b.WriteByte('\n')
+	b.WriteString("-- Default fallback\n")
+	b.WriteString("hl.monitor({ output = \"\", mode = \"preferred\", position = \"auto\", scale = \"auto\" })\n")
+	if err := os.WriteFile(outputsPath, []byte(b.String()), 0o644); err != nil {
+		return newConfig, err
+	}
+	cd.log("Migrated monitor sections to dms/outputs.lua")
+	return newConfig, nil
 }
 
 func (cd *ConfigDeployer) transformNiriConfigForNonSystemd(config, terminalCommand string) string {

core/internal/config/deployer_test.go

@@ -11,6 +11,55 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestCleanupStrayHyprlandConfFile(t *testing.T) {
+	if os.Getenv("HYPRLAND_INSTANCE_SIGNATURE") == "" {
+		t.Setenv("HYPRLAND_INSTANCE_SIGNATURE", "test-signature")
+	}
+
+	t.Run("leaves conf alone when no hyprland.lua present", func(t *testing.T) {
+		td := t.TempDir()
+		t.Setenv("HOME", td)
+		configDir := filepath.Join(td, ".config", "hypr")
+		dmsDir := filepath.Join(configDir, "dms")
+		require.NoError(t, os.MkdirAll(dmsDir, 0o755))
+		confPath := filepath.Join(configDir, "hyprland.conf")
+		dmsConfPath := filepath.Join(dmsDir, "colors.conf")
+		require.NoError(t, os.WriteFile(confPath, []byte("# legacy user config\n"), 0o644))
+		require.NoError(t, os.WriteFile(dmsConfPath, []byte("$primary = rgba(d0bcffFF)\n"), 0o644))
+
+		CleanupStrayHyprlandConfFile(nil)
+
+		assert.FileExists(t, confPath, "must not touch hyprland.conf when user has not migrated")
+		assert.FileExists(t, dmsConfPath, "must not touch dms/*.conf when user has not migrated")
+		assert.NoDirExists(t, filepath.Join(configDir, hyprlandBackupDirName))
+	})
+
+	t.Run("moves stray conf into backup when hyprland.lua exists", func(t *testing.T) {
+		td := t.TempDir()
+		t.Setenv("HOME", td)
+		configDir := filepath.Join(td, ".config", "hypr")
+		dmsDir := filepath.Join(configDir, "dms")
+		require.NoError(t, os.MkdirAll(dmsDir, 0o755))
+		luaPath := filepath.Join(configDir, "hyprland.lua")
+		require.NoError(t, os.WriteFile(luaPath, []byte("-- dms managed\n"), 0o644))
+		confPath := filepath.Join(configDir, "hyprland.conf")
+		dmsConfPath := filepath.Join(dmsDir, "colors.conf")
+		require.NoError(t, os.WriteFile(confPath, []byte("# autogen\n"), 0o644))
+		require.NoError(t, os.WriteFile(dmsConfPath, []byte("$primary = rgba(d0bcffFF)\n"), 0o644))
+
+		CleanupStrayHyprlandConfFile(nil)
+
+		assert.NoFileExists(t, confPath)
+		assert.NoFileExists(t, dmsConfPath)
+		assert.FileExists(t, luaPath)
+		entries, err := os.ReadDir(filepath.Join(configDir, hyprlandBackupDirName))
+		require.NoError(t, err)
+		require.Len(t, entries, 1)
+		assert.FileExists(t, filepath.Join(configDir, hyprlandBackupDirName, entries[0].Name(), "hyprland.conf"))
+		assert.FileExists(t, filepath.Join(configDir, hyprlandBackupDirName, entries[0].Name(), "dms", "colors.conf"))
+	})
+}
+
 func TestMergeNiriOutputSections(t *testing.T) {
 	cd := &ConfigDeployer{}
 
@@ -259,130 +308,56 @@ func getGhosttyPath() string {
 func TestMergeHyprlandMonitorSections(t *testing.T) {
 	cd := &ConfigDeployer{}
 
-	tests := []struct {
-		name            string
-		newConfig       string
-		existingConfig  string
-		wantError       bool
-		wantContains    []string
-		wantNotContains []string
-	}{
-		{
-			name: "no existing monitors",
-			newConfig: `# ==================
-# MONITOR CONFIG
-# ==================
-# monitor = eDP-2, 2560x1600@239.998993, 2560x0, 1, vrr, 1
+	t.Run("no monitors in existing", func(t *testing.T) {
+		tmp := t.TempDir()
+		out, err := cd.mergeHyprlandMonitorSections(`hl.config({})`, `input { kb_layout = us }`, tmp)
+		require.NoError(t, err)
+		assert.Equal(t, `hl.config({})`, out)
+		_, e := os.Stat(filepath.Join(tmp, "outputs.lua"))
+		assert.True(t, os.IsNotExist(e))
+	})
 
-# ==================
-# ENVIRONMENT VARS
-# ==================
-env = XDG_CURRENT_DESKTOP,niri`,
-			existingConfig: `# Some other config
-input {
-    kb_layout = us
-}`,
-			wantError:    false,
-			wantContains: []string{"MONITOR CONFIG", "ENVIRONMENT VARS"},
-		},
-		{
-			name: "merge single monitor",
-			newConfig: `# ==================
-# MONITOR CONFIG
-# ==================
-# monitor = eDP-2, 2560x1600@239.998993, 2560x0, 1, vrr, 1
-
-# ==================
-# ENVIRONMENT VARS
-# ==================`,
-			existingConfig: `# My config
-monitor = DP-1, 1920x1080@144, 0x0, 1
-input {
-    kb_layout = us
-}`,
-			wantError: false,
-			wantContains: []string{
-				"MONITOR CONFIG",
-				"monitor = DP-1, 1920x1080@144, 0x0, 1",
-				"Monitors from existing configuration",
-			},
-			wantNotContains: []string{
-				"monitor = eDP-2", // Example monitor should be removed
-			},
-		},
-		{
-			name: "merge multiple monitors",
-			newConfig: `# ==================
-# MONITOR CONFIG
-# ==================
-# monitor = eDP-2, 2560x1600@239.998993, 2560x0, 1, vrr, 1
-
-# ==================
-# ENVIRONMENT VARS
-# ==================`,
-			existingConfig: `monitor = DP-1, 1920x1080@144, 0x0, 1
+	t.Run("writes outputs lua from hyprlang monitors", func(t *testing.T) {
+		tmp := t.TempDir()
+		existing := `monitor = DP-1, 1920x1080@144, 0x0, 1
 # monitor = HDMI-A-1, 1920x1080@60, 1920x0, 1
-monitor = eDP-1, 2560x1440@165, auto, 1.25`,
-			wantError: false,
-			wantContains: []string{
-				"monitor = DP-1",
-				"# monitor = HDMI-A-1", // Commented monitor preserved
-				"monitor = eDP-1",
-				"Monitors from existing configuration",
-			},
-			wantNotContains: []string{
-				"monitor = eDP-2", // Example monitor should be removed
-			},
-		},
-		{
-			name: "preserve commented monitors",
-			newConfig: `# ==================
-# MONITOR CONFIG
-# ==================
-# monitor = eDP-2, 2560x1600@239.998993, 2560x0, 1, vrr, 1
+monitor = eDP-1, 2560x1440@165, auto, 1.25`
+		out, err := cd.mergeHyprlandMonitorSections(`return`, existing, tmp)
+		require.NoError(t, err)
+		assert.Equal(t, `return`, out)
+		b, err := os.ReadFile(filepath.Join(tmp, "outputs.lua"))
+		require.NoError(t, err)
+		s := string(b)
+		assert.Contains(t, s, "hl.monitor")
+		assert.Contains(t, s, "DP-1")
+		assert.Contains(t, s, "HDMI-A-1")
+		assert.Contains(t, s, "eDP-1")
+		assert.Contains(t, s, "preferred") // fallback rule at end
+	})
 
-# ==================`,
-			existingConfig: `# monitor = DP-1, 1920x1080@144, 0x0, 1
-# monitor = HDMI-A-1, 1920x1080@60, 1920x0, 1`,
-			wantError: false,
-			wantContains: []string{
-				"# monitor = DP-1",
-				"# monitor = HDMI-A-1",
-				"Monitors from existing configuration",
-			},
-		},
-		{
-			name: "no monitor config section",
-			newConfig: `# Some config without monitor section
-input {
-    kb_layout = us
-}`,
-			existingConfig: `monitor = DP-1, 1920x1080@144, 0x0, 1`,
-			wantError:      true,
-		},
-	}
+	t.Run("skips when outputs lua already exists", func(t *testing.T) {
+		tmp := t.TempDir()
+		path := filepath.Join(tmp, "outputs.lua")
+		require.NoError(t, os.WriteFile(path, []byte("-- keep\n"), 0o644))
+		_, err := cd.mergeHyprlandMonitorSections(`x`, `monitor = DP-1, 1920x1080@144, 0x0, 1`, tmp)
+		require.NoError(t, err)
+		b, err := os.ReadFile(path)
+		require.NoError(t, err)
+		assert.Equal(t, "-- keep\n", string(b))
+	})
+}
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpDir := t.TempDir()
-			result, err := cd.mergeHyprlandMonitorSections(tt.newConfig, tt.existingConfig, tmpDir)
+func TestHyprlangMonitorLineToLuaPreservesOptions(t *testing.T) {
+	got, err := hyprlangMonitorLineToLua(`monitor = DP-1, 1920x1080@144, 0x0, 1, transform, 1, vrr, 2, bitdepth, 10, cm, hdr, sdrbrightness, 1.2, sdrsaturation, 0.98`)
+	require.NoError(t, err)
 
-			if tt.wantError {
-				assert.Error(t, err)
-				return
-			}
-
-			require.NoError(t, err)
-
-			for _, want := range tt.wantContains {
-				assert.Contains(t, result, want, "merged config should contain: %s", want)
-			}
-
-			for _, notWant := range tt.wantNotContains {
-				assert.NotContains(t, result, notWant, "merged config should NOT contain: %s", notWant)
-			}
-		})
-	}
+	assert.Contains(t, got, `output = "DP-1"`)
+	assert.Contains(t, got, `transform = 1`)
+	assert.Contains(t, got, `vrr = 2`)
+	assert.Contains(t, got, `bitdepth = 10`)
+	assert.Contains(t, got, `cm = "hdr"`)
+	assert.Contains(t, got, `sdrbrightness = 1.2`)
+	assert.Contains(t, got, `sdrsaturation = 0.98`)
 }
 
 func TestHyprlandConfigDeployment(t *testing.T) {
@@ -398,6 +373,10 @@ func TestHyprlandConfigDeployment(t *testing.T) {
 	cd := NewConfigDeployer(logChan)
 
 	t.Run("deploy hyprland config to empty directory", func(t *testing.T) {
+		td, err := os.MkdirTemp("", "dankinstall-hyprland-empty")
+		require.NoError(t, err)
+		defer os.RemoveAll(td)
+		os.Setenv("HOME", td)
 		result, err := cd.deployHyprlandConfig(deps.TerminalGhostty, true)
 		require.NoError(t, err)
 
@@ -408,12 +387,16 @@ func TestHyprlandConfigDeployment(t *testing.T) {
 
 		content, err := os.ReadFile(result.Path)
 		require.NoError(t, err)
-		assert.Contains(t, string(content), "# MONITOR CONFIG")
-		assert.Contains(t, string(content), "source = ./dms/binds.conf")
-		assert.Contains(t, string(content), "exec-once = ")
+		assert.Contains(t, string(content), `require("dms.binds")`)
+		assert.Contains(t, string(content), "DMS_STARTUP_BEGIN")
+		assert.Contains(t, string(content), "hl.config(")
 	})
 
 	t.Run("deploy hyprland config with existing monitors", func(t *testing.T) {
+		td, err := os.MkdirTemp("", "dankinstall-hyprland-merge")
+		require.NoError(t, err)
+		defer os.RemoveAll(td)
+		os.Setenv("HOME", td)
 		existingContent := `# My existing Hyprland config
 monitor = DP-1, 1920x1080@144, 0x0, 1
 monitor = HDMI-A-1, 3840x2160@60, 1920x0, 1.5
@@ -422,11 +405,18 @@ general {
     gaps_in = 10
 }
 `
-		hyprPath := filepath.Join(tempDir, ".config", "hypr", "hyprland.conf")
-		err := os.MkdirAll(filepath.Dir(hyprPath), 0o755)
+		hyprPath := filepath.Join(td, ".config", "hypr", "hyprland.conf")
+		err = os.MkdirAll(filepath.Dir(hyprPath), 0o755)
 		require.NoError(t, err)
 		err = os.WriteFile(hyprPath, []byte(existingContent), 0o644)
 		require.NoError(t, err)
+		dmsDir := filepath.Join(td, ".config", "hypr", "dms")
+		require.NoError(t, os.MkdirAll(dmsDir, 0o755))
+		require.NoError(t, os.WriteFile(filepath.Join(dmsDir, "binds.conf"), []byte("bind = SUPER, T, exec, foot\n"), 0o644))
+		require.NoError(t, os.WriteFile(filepath.Join(dmsDir, "colors.conf"), []byte("$primary = rgba(d0bcffFF)\n"), 0o644))
+		require.NoError(t, os.WriteFile(filepath.Join(dmsDir, "cursor.conf"), []byte("env = XCURSOR_SIZE,24\n"), 0o644))
+		require.NoError(t, os.WriteFile(filepath.Join(filepath.Dir(hyprPath), "hyprland.conf.backup.old"), []byte("old backup\n"), 0o644))
+		require.NoError(t, os.WriteFile(filepath.Join(dmsDir, "binds.conf.backup.old"), []byte("old dms backup\n"), 0o644))
 
 		result, err := cd.deployHyprlandConfig(deps.TerminalKitty, true)
 		require.NoError(t, err)
@@ -440,13 +430,78 @@ general {
 		backupContent, err := os.ReadFile(result.BackupPath)
 		require.NoError(t, err)
 		assert.Equal(t, existingContent, string(backupContent))
+		assert.Contains(t, result.BackupPath, hyprlandBackupDirName)
+		assert.NoFileExists(t, hyprPath)
+		assert.FileExists(t, filepath.Join(filepath.Dir(result.BackupPath), "dms", "binds.conf"))
+		assert.FileExists(t, filepath.Join(filepath.Dir(result.BackupPath), "dms", "colors.conf"))
+		assert.FileExists(t, filepath.Join(filepath.Dir(result.BackupPath), "dms", "cursor.conf"))
+		assert.FileExists(t, filepath.Join(filepath.Dir(result.BackupPath), "hyprland.conf.backup.old"))
+		assert.FileExists(t, filepath.Join(filepath.Dir(result.BackupPath), "dms", "binds.conf.backup.old"))
+		assert.NoFileExists(t, filepath.Join(dmsDir, "binds.conf"))
+		assert.NoFileExists(t, filepath.Join(dmsDir, "colors.conf"))
+		assert.NoFileExists(t, filepath.Join(dmsDir, "cursor.conf"))
+		assert.NoFileExists(t, filepath.Join(filepath.Dir(hyprPath), "hyprland.conf.backup.old"))
+		assert.NoFileExists(t, filepath.Join(dmsDir, "binds.conf.backup.old"))
 
 		newContent, err := os.ReadFile(result.Path)
 		require.NoError(t, err)
-		assert.Contains(t, string(newContent), "monitor = DP-1, 1920x1080@144")
-		assert.Contains(t, string(newContent), "monitor = HDMI-A-1, 3840x2160@60")
-		assert.Contains(t, string(newContent), "source = ./dms/binds.conf")
-		assert.NotContains(t, string(newContent), "monitor = eDP-2")
+		assert.Contains(t, string(newContent), `require("dms.binds")`)
+
+		outputsPath := filepath.Join(td, ".config", "hypr", "dms", "outputs.lua")
+		outBytes, err := os.ReadFile(outputsPath)
+		require.NoError(t, err)
+		outs := string(outBytes)
+		assert.Contains(t, outs, `hl.monitor`)
+		assert.Contains(t, outs, "DP-1")
+		assert.Contains(t, outs, "HDMI-A-1")
+	})
+
+	t.Run("deploy hyprland config removes root legacy symlink when lua exists", func(t *testing.T) {
+		td, err := os.MkdirTemp("", "dankinstall-hyprland-lua-conf-symlink")
+		require.NoError(t, err)
+		defer os.RemoveAll(td)
+		os.Setenv("HOME", td)
+
+		configDir := filepath.Join(td, ".config", "hypr")
+		require.NoError(t, os.MkdirAll(configDir, 0o755))
+		luaPath := filepath.Join(configDir, "hyprland.lua")
+		confPath := filepath.Join(configDir, "hyprland.conf")
+		require.NoError(t, os.WriteFile(luaPath, []byte(`require("dms.binds")`+"\n"), 0o644))
+		require.NoError(t, os.Symlink(filepath.Join(configDir, "missing-legacy.conf"), confPath))
+
+		result, err := cd.deployHyprlandConfig(deps.TerminalKitty, true)
+		require.NoError(t, err)
+
+		assert.Equal(t, luaPath, result.Path)
+		_, err = os.Lstat(confPath)
+		assert.True(t, os.IsNotExist(err), "root hyprland.conf symlink should be moved out of the live config directory")
+		_, err = os.Lstat(filepath.Join(filepath.Dir(result.BackupPath), "hyprland.conf"))
+		assert.NoError(t, err)
+	})
+
+	t.Run("deploy hyprland config refreshes managed binds but preserves user binds", func(t *testing.T) {
+		td, err := os.MkdirTemp("", "dankinstall-hyprland-refresh-binds")
+		require.NoError(t, err)
+		defer os.RemoveAll(td)
+		os.Setenv("HOME", td)
+
+		dmsDir := filepath.Join(td, ".config", "hypr", "dms")
+		require.NoError(t, os.MkdirAll(dmsDir, 0o755))
+		require.NoError(t, os.WriteFile(filepath.Join(dmsDir, "binds.lua"), []byte("-- stale managed binds\n"), 0o644))
+		userBinds := "-- custom user binds\n"
+		require.NoError(t, os.WriteFile(filepath.Join(dmsDir, "binds-user.lua"), []byte(userBinds), 0o644))
+
+		_, err = cd.deployHyprlandConfig(deps.TerminalKitty, true)
+		require.NoError(t, err)
+
+		managed, err := os.ReadFile(filepath.Join(dmsDir, "binds.lua"))
+		require.NoError(t, err)
+		assert.Contains(t, string(managed), `hl.bind("SUPER + F", hl.dsp.window.fullscreen({ mode = "maximized", action = "toggle" }))`)
+		assert.Contains(t, string(managed), `hl.bind("SUPER + minus", hl.dsp.window.resize({ x = -100, y = 0, relative = true }), { repeating = true })`)
+
+		user, err := os.ReadFile(filepath.Join(dmsDir, "binds-user.lua"))
+		require.NoError(t, err)
+		assert.Equal(t, userBinds, string(user))
 	})
 }
 
@@ -459,10 +514,22 @@ func TestNiriConfigStructure(t *testing.T) {
 }
 
 func TestHyprlandConfigStructure(t *testing.T) {
-	assert.Contains(t, HyprlandConfig, "# MONITOR CONFIG")
-	assert.Contains(t, HyprlandConfig, "# STARTUP APPS")
-	assert.Contains(t, HyprlandConfig, "# INPUT CONFIG")
-	assert.Contains(t, HyprlandConfig, "source = ./dms/binds.conf")
+	assert.Contains(t, HyprlandLuaConfig, `require("dms.binds")`)
+	assert.Contains(t, HyprlandLuaConfig, "DMS_STARTUP_BEGIN")
+	assert.Contains(t, HyprlandLuaConfig, "hl.config(")
+	assert.Contains(t, HyprlandLuaConfig, "input =")
+}
+
+func TestMangoConfigStructure(t *testing.T) {
+	assert.Contains(t, MangoConfig, "exec-once=dms run")
+	assert.NotContains(t, MangoConfig, "exec_once=dms run")
+	assert.Contains(t, MangoConfig, "source=./dms/binds.conf")
+	assert.Contains(t, MangoBindsConfig, "bind=SUPER,H,focusdir,left")
+	assert.Contains(t, MangoBindsConfig, "bind=SUPER,J,focusdir,down")
+	assert.Contains(t, MangoBindsConfig, "bind=SUPER,K,focusdir,up")
+	assert.Contains(t, MangoBindsConfig, "bind=SUPER,L,focusdir,right")
+	assert.Contains(t, MangoBindsConfig, "gesturebind=none,right,3,viewtoleft_have_client")
+	assert.Contains(t, MangoBindsConfig, "gesturebind=none,left,3,viewtoright_have_client")
 }
 
 func TestGhosttyConfigStructure(t *testing.T) {
@@ -789,4 +856,37 @@ func TestShouldReplaceConfigDeployIfMissing(t *testing.T) {
 		}
 		assert.True(t, foundGhostty, "expected Ghostty config to be deployed when replaceConfigs is true")
 	})
+
+	t.Run("hyprland legacy config exists skips when replace false", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "dankinstall-hyprland-legacy-skip-test")
+		require.NoError(t, err)
+		defer os.RemoveAll(tempDir)
+
+		originalHome := os.Getenv("HOME")
+		os.Setenv("HOME", tempDir)
+		defer os.Setenv("HOME", originalHome)
+
+		hyprConf := filepath.Join(tempDir, ".config", "hypr", "hyprland.conf")
+		require.NoError(t, os.MkdirAll(filepath.Dir(hyprConf), 0o755))
+		require.NoError(t, os.WriteFile(hyprConf, []byte("monitor = , preferred, auto, 1\n"), 0o644))
+
+		logChan := make(chan string, 100)
+		cd := NewConfigDeployer(logChan)
+		results, err := cd.deployConfigurationsInternal(
+			context.Background(),
+			deps.WindowManagerHyprland,
+			deps.TerminalGhostty,
+			nil,
+			allFalse,
+			nil,
+			true,
+		)
+		require.NoError(t, err)
+
+		for _, r := range results {
+			if r.ConfigType == "Hyprland" && r.Deployed {
+				t.Fatalf("expected Hyprland deployment to be skipped when legacy config exists and replace=false")
+			}
+		}
+	})
 }

core/internal/config/embedded/hypr-binds-user.lua

@@ -0,0 +1 @@
+-- Optional per-user keybind overrides (managed by DMS). Loaded after default binds.

core/internal/config/embedded/hypr-binds.conf

@@ -1,165 +0,0 @@
-# === Application Launchers ===
-bind = SUPER, T, exec, {{TERMINAL_COMMAND}}
-bind = SUPER, space, exec, dms ipc call spotlight toggle
-bind = SUPER, V, exec, dms ipc call clipboard toggle
-bind = SUPER, M, exec, dms ipc call processlist focusOrToggle
-bind = SUPER, comma, exec, dms ipc call settings focusOrToggle
-bind = SUPER, N, exec, dms ipc call notifications toggle
-bind = SUPER SHIFT, N, exec, dms ipc call notepad toggle
-bind = SUPER, Y, exec, dms ipc call dankdash wallpaper
-bind = SUPER, TAB, exec, dms ipc call hypr toggleOverview
-bind = SUPER, X, exec, dms ipc call powermenu toggle
-
-# === Cheat sheet
-bind = SUPER SHIFT, Slash, exec, dms ipc call keybinds toggle hyprland
-
-# === Security ===
-bind = SUPER ALT, L, exec, dms ipc call lock lock
-bind = SUPER SHIFT, E, exit
-bind = CTRL ALT, Delete, exec, dms ipc call processlist focusOrToggle
-
-# === Audio Controls ===
-bindel = , XF86AudioRaiseVolume, exec, dms ipc call audio increment 3
-bindel = , XF86AudioLowerVolume, exec, dms ipc call audio decrement 3
-bindl = , XF86AudioMute, exec, dms ipc call audio mute
-bindl = , XF86AudioMicMute, exec, dms ipc call audio micmute
-bindl = , XF86AudioPause, exec, dms ipc call mpris playPause
-bindl = , XF86AudioPlay, exec, dms ipc call mpris playPause
-bindl = , XF86AudioPrev, exec, dms ipc call mpris previous
-bindl = , XF86AudioNext, exec, dms ipc call mpris next
-bindel = CTRL, XF86AudioRaiseVolume, exec, dms ipc call mpris increment 3
-bindel = CTRL, XF86AudioLowerVolume, exec, dms ipc call mpris decrement 3
-
-# === Brightness Controls ===
-bindel = , XF86MonBrightnessUp, exec, dms ipc call brightness increment 5 ""
-bindel = , XF86MonBrightnessDown, exec, dms ipc call brightness decrement 5 ""
-
-# === Window Management ===
-bind = SUPER, Q, killactive
-bind = SUPER, F, fullscreen, 1
-bind = SUPER SHIFT, F, fullscreen, 0
-bind = SUPER SHIFT, T, togglefloating
-bind = SUPER, W, togglegroup
-bind = SUPER SHIFT, W, exec, dms ipc call window-rules toggle
-
-# === Focus Navigation ===
-bind = SUPER, left, movefocus, l
-bind = SUPER, down, movefocus, d
-bind = SUPER, up, movefocus, u
-bind = SUPER, right, movefocus, r
-bind = SUPER, H, movefocus, l
-bind = SUPER, J, movefocus, d
-bind = SUPER, K, movefocus, u
-bind = SUPER, L, movefocus, r
-
-# === Window Movement ===
-bind = SUPER SHIFT, left, movewindow, l
-bind = SUPER SHIFT, down, movewindow, d
-bind = SUPER SHIFT, up, movewindow, u
-bind = SUPER SHIFT, right, movewindow, r
-bind = SUPER SHIFT, H, movewindow, l
-bind = SUPER SHIFT, J, movewindow, d
-bind = SUPER SHIFT, K, movewindow, u
-bind = SUPER SHIFT, L, movewindow, r
-
-# === Column Navigation ===
-bind = SUPER, Home, focuswindow, first
-bind = SUPER, End, focuswindow, last
-
-# === Monitor Navigation ===
-bind = SUPER CTRL, left, focusmonitor, l
-bind = SUPER CTRL, right, focusmonitor, r
-bind = SUPER CTRL, H, focusmonitor, l
-bind = SUPER CTRL, J, focusmonitor, d
-bind = SUPER CTRL, K, focusmonitor, u
-bind = SUPER CTRL, L, focusmonitor, r
-
-# === Move to Monitor ===
-bind = SUPER SHIFT CTRL, left, movewindow, mon:l
-bind = SUPER SHIFT CTRL, down, movewindow, mon:d
-bind = SUPER SHIFT CTRL, up, movewindow, mon:u
-bind = SUPER SHIFT CTRL, right, movewindow, mon:r
-bind = SUPER SHIFT CTRL, H, movewindow, mon:l
-bind = SUPER SHIFT CTRL, J, movewindow, mon:d
-bind = SUPER SHIFT CTRL, K, movewindow, mon:u
-bind = SUPER SHIFT CTRL, L, movewindow, mon:r
-
-# === Workspace Navigation ===
-bind = SUPER, Page_Down, workspace, e+1
-bind = SUPER, Page_Up, workspace, e-1
-bind = SUPER, U, workspace, e+1
-bind = SUPER, I, workspace, e-1
-bind = SUPER CTRL, down, movetoworkspace, e+1
-bind = SUPER CTRL, up, movetoworkspace, e-1
-bind = SUPER CTRL, U, movetoworkspace, e+1
-bind = SUPER CTRL, I, movetoworkspace, e-1
-
-# === Workspace Management ===
-bind = CTRL SHIFT, R, exec, dms ipc call workspace-rename open
-
-# === Move Workspaces ===
-bind = SUPER SHIFT, Page_Down, movetoworkspace, e+1
-bind = SUPER SHIFT, Page_Up, movetoworkspace, e-1
-bind = SUPER SHIFT, U, movetoworkspace, e+1
-bind = SUPER SHIFT, I, movetoworkspace, e-1
-
-# === Mouse Wheel Navigation ===
-bind = SUPER, mouse_down, workspace, e+1
-bind = SUPER, mouse_up, workspace, e-1
-bind = SUPER CTRL, mouse_down, movetoworkspace, e+1
-bind = SUPER CTRL, mouse_up, movetoworkspace, e-1
-
-# === Numbered Workspaces ===
-bind = SUPER, 1, workspace, 1
-bind = SUPER, 2, workspace, 2
-bind = SUPER, 3, workspace, 3
-bind = SUPER, 4, workspace, 4
-bind = SUPER, 5, workspace, 5
-bind = SUPER, 6, workspace, 6
-bind = SUPER, 7, workspace, 7
-bind = SUPER, 8, workspace, 8
-bind = SUPER, 9, workspace, 9
-
-# === Move to Numbered Workspaces ===
-bind = SUPER SHIFT, 1, movetoworkspace, 1
-bind = SUPER SHIFT, 2, movetoworkspace, 2
-bind = SUPER SHIFT, 3, movetoworkspace, 3
-bind = SUPER SHIFT, 4, movetoworkspace, 4
-bind = SUPER SHIFT, 5, movetoworkspace, 5
-bind = SUPER SHIFT, 6, movetoworkspace, 6
-bind = SUPER SHIFT, 7, movetoworkspace, 7
-bind = SUPER SHIFT, 8, movetoworkspace, 8
-bind = SUPER SHIFT, 9, movetoworkspace, 9
-
-# === Column Management ===
-bind = SUPER, bracketleft, layoutmsg, preselect l
-bind = SUPER, bracketright, layoutmsg, preselect r
-
-# === Sizing & Layout ===
-bind = SUPER, R, layoutmsg, togglesplit
-bind = SUPER CTRL, F, resizeactive, exact 100% 100%
-
-# === Move/resize windows with mainMod + LMB/RMB and dragging ===
-bindmd = SUPER, mouse:272, Move window, movewindow
-bindmd = SUPER, mouse:273, Resize window, resizewindow
-
-# === Move/resize windows with mainMod + LMB/RMB and dragging ===
-bindd = SUPER, code:20, Expand window left, resizeactive, -100 0
-bindd = SUPER, code:21, Shrink window left, resizeactive, 100 0
-
-# === Manual Sizing ===
-binde = SUPER, minus, resizeactive, -10% 0
-binde = SUPER, equal, resizeactive, 10% 0
-binde = SUPER SHIFT, minus, resizeactive, 0 -10%
-binde = SUPER SHIFT, equal, resizeactive, 0 10%
-
-# === Screenshots ===
-bind = , Print, exec, dms screenshot
-bind = CTRL, Print, exec, dms screenshot full
-bind = ALT, Print, exec, dms screenshot window
-
-# === Display Profiles ===
-bind = SUPER, P, exec, dms ipc outputs cycleProfile
-
-# === System Controls ===
-bind = SUPER SHIFT, P, dpms, toggle

core/internal/config/embedded/hypr-binds.lua

@@ -0,0 +1,171 @@
+-- DMS default keybinds (Hyprland 0.55+ Lua)
+
+-- === Application Launchers ===
+hl.bind("SUPER + T", hl.dsp.exec_cmd("{{TERMINAL_COMMAND}}"))
+hl.bind("SUPER + space", hl.dsp.exec_cmd("dms ipc call spotlight toggle"))
+hl.bind("ALT + space", hl.dsp.exec_cmd("dms ipc call spotlight-bar toggle"))
+hl.bind("SUPER + V", hl.dsp.exec_cmd("dms ipc call clipboard toggle"))
+hl.bind("SUPER + M", hl.dsp.exec_cmd("dms ipc call processlist focusOrToggle"))
+hl.bind("SUPER + comma", hl.dsp.exec_cmd("dms ipc call settings focusOrToggle"))
+hl.bind("SUPER + N", hl.dsp.exec_cmd("dms ipc call notifications toggle"))
+hl.bind("SUPER + SHIFT + N", hl.dsp.exec_cmd("dms ipc call notepad toggle"))
+hl.bind("SUPER + Y", hl.dsp.exec_cmd("dms ipc call dankdash wallpaper"))
+hl.bind("SUPER + TAB", hl.dsp.exec_cmd("dms ipc call hypr toggleOverview"))
+hl.bind("SUPER + O", hl.dsp.exec_cmd("dms ipc call hypr toggleOverview"))
+hl.bind("SUPER + X", hl.dsp.exec_cmd("dms ipc call powermenu toggle"))
+
+-- === Cheat sheet
+hl.bind("SUPER + SHIFT + Slash", hl.dsp.exec_cmd("dms ipc call keybinds toggle hyprland"))
+
+-- === Security ===
+hl.bind("SUPER + ALT + L", hl.dsp.exec_cmd("dms ipc call lock lock"))
+hl.bind("SUPER + SHIFT + E", hl.dsp.exit())
+hl.bind("CTRL + ALT + Delete", hl.dsp.exec_cmd("dms ipc call processlist focusOrToggle"))
+
+-- === Audio Controls ===
+hl.bind("XF86AudioRaiseVolume", hl.dsp.exec_cmd("dms ipc call audio increment 3"), { locked = true, repeating = true })
+hl.bind("XF86AudioLowerVolume", hl.dsp.exec_cmd("dms ipc call audio decrement 3"), { locked = true, repeating = true })
+hl.bind("XF86AudioMute", hl.dsp.exec_cmd("dms ipc call audio mute"), { locked = true })
+hl.bind("XF86AudioMicMute", hl.dsp.exec_cmd("dms ipc call audio micmute"), { locked = true })
+hl.bind("XF86AudioPause", hl.dsp.exec_cmd("dms ipc call mpris playPause"), { locked = true })
+hl.bind("XF86AudioPlay", hl.dsp.exec_cmd("dms ipc call mpris playPause"), { locked = true })
+hl.bind("XF86AudioPrev", hl.dsp.exec_cmd("dms ipc call mpris previous"), { locked = true })
+hl.bind("XF86AudioNext", hl.dsp.exec_cmd("dms ipc call mpris next"), { locked = true })
+hl.bind("CTRL + XF86AudioRaiseVolume", hl.dsp.exec_cmd("dms ipc call mpris increment 3"), { locked = true, repeating = true })
+hl.bind("CTRL + XF86AudioLowerVolume", hl.dsp.exec_cmd("dms ipc call mpris decrement 3"), { locked = true, repeating = true })
+
+-- === Brightness Controls ===
+hl.bind("XF86MonBrightnessUp", hl.dsp.exec_cmd([[dms ipc call brightness increment 5 ""]]), { locked = true, repeating = true })
+hl.bind("XF86MonBrightnessDown", hl.dsp.exec_cmd([[dms ipc call brightness decrement 5 ""]]), { locked = true, repeating = true })
+
+-- === Window Management ===
+hl.bind("SUPER + Q", hl.dsp.window.close())
+hl.bind("SUPER + F", hl.dsp.window.fullscreen({ mode = "maximized", action = "toggle" }))
+hl.bind("SUPER + SHIFT + F", hl.dsp.window.fullscreen({ mode = "fullscreen", action = "toggle" }))
+hl.bind("SUPER + SHIFT + T", hl.dsp.window.float({ action = "toggle" }))
+hl.bind("SUPER + W", hl.dsp.group.toggle())
+hl.bind("SUPER + SHIFT + W", hl.dsp.exec_cmd("dms ipc call window-rules toggle"))
+
+-- === Focus Navigation ===
+hl.bind("SUPER + left", hl.dsp.focus({ direction = "l" }))
+hl.bind("SUPER + down", hl.dsp.focus({ direction = "d" }))
+hl.bind("SUPER + up", hl.dsp.focus({ direction = "u" }))
+hl.bind("SUPER + right", hl.dsp.focus({ direction = "r" }))
+hl.bind("SUPER + H", hl.dsp.focus({ direction = "l" }))
+hl.bind("SUPER + J", hl.dsp.focus({ direction = "d" }))
+hl.bind("SUPER + K", hl.dsp.focus({ direction = "u" }))
+hl.bind("SUPER + L", hl.dsp.focus({ direction = "r" }))
+
+-- === Window Movement ===
+hl.bind("SUPER + SHIFT + left", hl.dsp.window.move({ direction = "l" }))
+hl.bind("SUPER + SHIFT + down", hl.dsp.window.move({ direction = "d" }))
+hl.bind("SUPER + SHIFT + up", hl.dsp.window.move({ direction = "u" }))
+hl.bind("SUPER + SHIFT + right", hl.dsp.window.move({ direction = "r" }))
+hl.bind("SUPER + SHIFT + H", hl.dsp.window.move({ direction = "l" }))
+hl.bind("SUPER + SHIFT + J", hl.dsp.window.move({ direction = "d" }))
+hl.bind("SUPER + SHIFT + K", hl.dsp.window.move({ direction = "u" }))
+hl.bind("SUPER + SHIFT + L", hl.dsp.window.move({ direction = "r" }))
+
+-- === Column Navigation ===
+hl.bind("SUPER + Home", hl.dsp.focus({ window = "first" }))
+hl.bind("SUPER + End", hl.dsp.focus({ window = "last" }))
+
+-- === Monitor Navigation ===
+hl.bind("SUPER + CTRL + left", hl.dsp.focus({ monitor = "l" }))
+hl.bind("SUPER + CTRL + right", hl.dsp.focus({ monitor = "r" }))
+hl.bind("SUPER + CTRL + H", hl.dsp.focus({ monitor = "l" }))
+hl.bind("SUPER + CTRL + J", hl.dsp.focus({ monitor = "d" }))
+hl.bind("SUPER + CTRL + K", hl.dsp.focus({ monitor = "u" }))
+hl.bind("SUPER + CTRL + L", hl.dsp.focus({ monitor = "r" }))
+
+-- === Move to Monitor ===
+hl.bind("SUPER + SHIFT + CTRL + left", hl.dsp.window.move({ monitor = "l" }))
+hl.bind("SUPER + SHIFT + CTRL + down", hl.dsp.window.move({ monitor = "d" }))
+hl.bind("SUPER + SHIFT + CTRL + up", hl.dsp.window.move({ monitor = "u" }))
+hl.bind("SUPER + SHIFT + CTRL + right", hl.dsp.window.move({ monitor = "r" }))
+hl.bind("SUPER + SHIFT + CTRL + H", hl.dsp.window.move({ monitor = "l" }))
+hl.bind("SUPER + SHIFT + CTRL + J", hl.dsp.window.move({ monitor = "d" }))
+hl.bind("SUPER + SHIFT + CTRL + K", hl.dsp.window.move({ monitor = "u" }))
+hl.bind("SUPER + SHIFT + CTRL + L", hl.dsp.window.move({ monitor = "r" }))
+
+-- === Workspace Navigation ===
+hl.bind("SUPER + Page_Down", hl.dsp.focus({ workspace = "e+1" }))
+hl.bind("SUPER + Page_Up", hl.dsp.focus({ workspace = "e-1" }))
+hl.bind("SUPER + U", hl.dsp.focus({ workspace = "e+1" }))
+hl.bind("SUPER + I", hl.dsp.focus({ workspace = "e-1" }))
+hl.bind("SUPER + CTRL + down", hl.dsp.window.move({ workspace = "e+1" }))
+hl.bind("SUPER + CTRL + up", hl.dsp.window.move({ workspace = "e-1" }))
+hl.bind("SUPER + CTRL + U", hl.dsp.window.move({ workspace = "e+1" }))
+hl.bind("SUPER + CTRL + I", hl.dsp.window.move({ workspace = "e-1" }))
+
+-- === Workspace Management ===
+hl.bind("CTRL + SHIFT + R", hl.dsp.exec_cmd("dms ipc call workspace-rename open"))
+
+-- === Move Workspaces ===
+hl.bind("SUPER + SHIFT + Page_Down", hl.dsp.window.move({ workspace = "e+1" }))
+hl.bind("SUPER + SHIFT + Page_Up", hl.dsp.window.move({ workspace = "e-1" }))
+hl.bind("SUPER + SHIFT + U", hl.dsp.window.move({ workspace = "e+1" }))
+hl.bind("SUPER + SHIFT + I", hl.dsp.window.move({ workspace = "e-1" }))
+
+-- === Mouse Wheel Navigation ===
+hl.bind("SUPER + mouse_down", hl.dsp.focus({ workspace = "e+1" }))
+hl.bind("SUPER + mouse_up", hl.dsp.focus({ workspace = "e-1" }))
+hl.bind("SUPER + CTRL + mouse_down", hl.dsp.window.move({ workspace = "e+1" }))
+hl.bind("SUPER + CTRL + mouse_up", hl.dsp.window.move({ workspace = "e-1" }))
+
+-- === Touchpad Gestures ===
+hl.gesture({ fingers = 3, direction = "horizontal", action = "workspace" })
+
+-- === Numbered Workspaces ===
+hl.bind("SUPER + 1", hl.dsp.focus({ workspace = "1" }))
+hl.bind("SUPER + 2", hl.dsp.focus({ workspace = "2" }))
+hl.bind("SUPER + 3", hl.dsp.focus({ workspace = "3" }))
+hl.bind("SUPER + 4", hl.dsp.focus({ workspace = "4" }))
+hl.bind("SUPER + 5", hl.dsp.focus({ workspace = "5" }))
+hl.bind("SUPER + 6", hl.dsp.focus({ workspace = "6" }))
+hl.bind("SUPER + 7", hl.dsp.focus({ workspace = "7" }))
+hl.bind("SUPER + 8", hl.dsp.focus({ workspace = "8" }))
+hl.bind("SUPER + 9", hl.dsp.focus({ workspace = "9" }))
+
+-- === Move to Numbered Workspaces ===
+hl.bind("SUPER + SHIFT + 1", hl.dsp.window.move({ workspace = "1" }))
+hl.bind("SUPER + SHIFT + 2", hl.dsp.window.move({ workspace = "2" }))
+hl.bind("SUPER + SHIFT + 3", hl.dsp.window.move({ workspace = "3" }))
+hl.bind("SUPER + SHIFT + 4", hl.dsp.window.move({ workspace = "4" }))
+hl.bind("SUPER + SHIFT + 5", hl.dsp.window.move({ workspace = "5" }))
+hl.bind("SUPER + SHIFT + 6", hl.dsp.window.move({ workspace = "6" }))
+hl.bind("SUPER + SHIFT + 7", hl.dsp.window.move({ workspace = "7" }))
+hl.bind("SUPER + SHIFT + 8", hl.dsp.window.move({ workspace = "8" }))
+hl.bind("SUPER + SHIFT + 9", hl.dsp.window.move({ workspace = "9" }))
+
+-- === Column Management ===
+hl.bind("SUPER + bracketleft", hl.dsp.layout("preselect l"))
+hl.bind("SUPER + bracketright", hl.dsp.layout("preselect r"))
+
+-- === Sizing & Layout ===
+hl.bind("SUPER + R", hl.dsp.layout("togglesplit"))
+hl.bind("SUPER + CTRL + F", hl.dsp.window.fullscreen({ mode = "maximized", action = "set" }))
+
+-- === Move/resize windows with mainMod + LMB/RMB and dragging ===
+hl.bind("SUPER + mouse:272", hl.dsp.window.drag(), { mouse = true, description = "Move window" })
+hl.bind("SUPER + mouse:273", hl.dsp.window.resize(), { mouse = true, description = "Resize window" })
+
+hl.bind("SUPER + code:20", hl.dsp.window.resize({ x = -100, y = 0, relative = true }), { description = "Expand window left" })
+hl.bind("SUPER + code:21", hl.dsp.window.resize({ x = 100, y = 0, relative = true }), { description = "Shrink window left" })
+
+-- === Manual Sizing ===
+hl.bind("SUPER + minus", hl.dsp.window.resize({ x = -100, y = 0, relative = true }), { repeating = true })
+hl.bind("SUPER + equal", hl.dsp.window.resize({ x = 100, y = 0, relative = true }), { repeating = true })
+hl.bind("SUPER + SHIFT + minus", hl.dsp.window.resize({ x = 0, y = -100, relative = true }), { repeating = true })
+hl.bind("SUPER + SHIFT + equal", hl.dsp.window.resize({ x = 0, y = 100, relative = true }), { repeating = true })
+
+-- === Screenshots ===
+hl.bind("Print", hl.dsp.exec_cmd("dms screenshot"))
+hl.bind("CTRL + Print", hl.dsp.exec_cmd("dms screenshot full"))
+hl.bind("ALT + Print", hl.dsp.exec_cmd("dms screenshot window"))
+
+-- === Display Profiles ===
+hl.bind("SUPER + P", hl.dsp.exec_cmd("dms ipc outputs cycleProfile"))
+
+-- === System Controls ===
+hl.bind("SUPER + SHIFT + P", hl.dsp.dpms({ action = "toggle" }))

core/internal/config/embedded/hypr-colors.conf

@@ -1,25 +0,0 @@
-# ! Auto-generated file. Do not edit directly.
-# Remove source = ./dms/colors.conf from your config to override.
-
-$primary  = rgb(d0bcff)
-$outline  = rgb(948f99)
-$error    = rgb(f2b8b5)
-
-general {
-  col.active_border   = $primary
-  col.inactive_border = $outline
-}
-
-group {
-  col.border_active   = $primary
-  col.border_inactive = $outline
-  col.border_locked_active   = $error
-  col.border_locked_inactive = $outline
-
-  groupbar {
-    col.active         = $primary
-    col.inactive       = $outline
-    col.locked_active   = $error
-    col.locked_inactive = $outline
-  }
-}

core/internal/config/embedded/hypr-colors.lua

@@ -0,0 +1,27 @@
+-- ! Auto-generated file. Do not edit directly.
+-- Regenerate via DMS theme tools or remove require("dms.colors") from hyprland.lua to override.
+
+hl.config({
+	general = {
+		col = {
+			active_border = "rgb(d0bcff)",
+			inactive_border = "rgb(948f99)",
+		},
+	},
+	group = {
+		col = {
+			border_active = "rgb(d0bcff)",
+			border_inactive = "rgb(948f99)",
+			border_locked_active = "rgb(f2b8b5)",
+			border_locked_inactive = "rgb(948f99)",
+		},
+		groupbar = {
+			col = {
+				active = "rgb(d0bcff)",
+				inactive = "rgb(948f99)",
+				locked_active = "rgb(f2b8b5)",
+				locked_inactive = "rgb(948f99)",
+			},
+		},
+	},
+})

core/internal/config/embedded/hypr-cursor.lua

@@ -0,0 +1 @@
+-- Cursor theme overrides. Deploy writes ~/.config/hypr/dms/cursor.lua

core/internal/config/embedded/hypr-layout.conf

@@ -1,11 +0,0 @@
-# Auto-generated by DMS - do not edit manually
-
-general {
-    gaps_in = 4
-    gaps_out = 4
-    border_size = 2
-}
-
-decoration {
-    rounding = 12
-}

core/internal/config/embedded/hypr-layout.lua

@@ -0,0 +1,12 @@
+-- Auto-generated by DMS — do not edit manually
+
+hl.config({
+	general = {
+		gaps_in = 4,
+		gaps_out = 4,
+		border_size = 2,
+	},
+	decoration = {
+		rounding = 12,
+	},
+})

core/internal/config/embedded/hypr-outputs.lua

@@ -0,0 +1,3 @@
+-- Per-output monitor rules — embedded sibling of the legacy outputs.conf fragment. Deploy writes ~/.config/hypr/dms/outputs.lua
+
+hl.monitor({ output = "", mode = "preferred", position = "auto", scale = "auto" })

core/internal/config/embedded/hypr-windowrules.lua

@@ -0,0 +1 @@
+-- Window rules. Deploy writes ~/.config/hypr/dms/windowrules.lua

core/internal/config/embedded/hyprland.conf

@@ -1,117 +0,0 @@
-# Hyprland Configuration
-# https://wiki.hypr.land/Configuring/
-
-# ==================
-# MONITOR CONFIG
-# ==================
-# monitor = eDP-2, 2560x1600@239.998993, 2560x0, 1, vrr, 1
-monitor = , preferred,auto,auto
-
-# ==================
-# STARTUP APPS
-# ==================
-exec-once = dbus-update-activation-environment --systemd --all
-exec-once = systemctl --user start hyprland-session.target
-
-# ==================
-# INPUT CONFIG
-# ==================
-input {
-    kb_layout = us
-    numlock_by_default = true
-}
-
-# ==================
-# GENERAL LAYOUT
-# ==================
-general {
-    gaps_in = 5
-    gaps_out = 5
-    border_size = 2
-
-    layout = dwindle
-}
-
-# ==================
-# DECORATION
-# ==================
-decoration {
-    rounding = 12
-
-    active_opacity = 1.0
-    inactive_opacity = 1.0
-
-    shadow {
-        enabled = true
-        range = 30
-        render_power = 5
-        offset = 0 5
-        color = rgba(00000070)
-    }
-}
-
-# ==================
-# ANIMATIONS
-# ==================
-animations {
-    enabled = true
-
-    animation = windowsIn, 1, 3, default
-    animation = windowsOut, 1, 3, default
-    animation = workspaces, 1, 5, default
-    animation = windowsMove, 1, 4, default
-    animation = fade, 1, 3, default
-    animation = border, 1, 3, default
-}
-
-# ==================
-# LAYOUTS
-# ==================
-dwindle {
-    preserve_split = true
-}
-
-master {
-    mfact = 0.5
-}
-
-# ==================
-# MISC
-# ==================
-misc {
-    disable_hyprland_logo = true
-    disable_splash_rendering = true
-}
-
-# ==================
-# WINDOW RULES
-# ==================
-windowrule = tile on, match:class ^(org\.wezfurlong\.wezterm)$
-
-windowrule = rounding 12, match:class ^(org\.gnome\.)
-
-windowrule = tile on, match:class ^(gnome-control-center)$
-windowrule = tile on, match:class ^(pavucontrol)$
-windowrule = tile on, match:class ^(nm-connection-editor)$
-
-windowrule = float on, match:class ^(org\.gnome\.Calculator)$
-windowrule = float on, match:class ^(gnome-calculator)$
-windowrule = float on, match:class ^(galculator)$
-windowrule = float on, match:class ^(blueman-manager)$
-windowrule = float on, match:class ^(org\.gnome\.Nautilus)$
-windowrule = float on, match:class ^(xdg-desktop-portal)$
-
-windowrule = no_initial_focus on, match:class ^(steam)$, match:title ^(notificationtoasts)
-windowrule = pin on, match:class ^(steam)$, match:title ^(notificationtoasts)
-
-windowrule = float on, match:class ^(firefox)$, match:title ^(Picture-in-Picture)$
-windowrule = float on, match:class ^(zoom)$
-
-layerrule = no_anim on, match:namespace ^(quickshell)$
-layerrule = no_anim on, match:namespace ^dms:.*
-
-source = ./dms/colors.conf
-source = ./dms/outputs.conf
-source = ./dms/layout.conf
-source = ./dms/cursor.conf
-source = ./dms/binds.conf

core/internal/config/embedded/hyprland.lua

@@ -0,0 +1,88 @@
+-- Hyprland configuration (Lua) — https://wiki.hypr.land/Configuring/Start/
+
+hl.config({ autogenerated = false })
+
+-- DMS_STARTUP_BEGIN
+hl.on("hyprland.start", function()
+	hl.exec_cmd("dbus-update-activation-environment --systemd --all")
+	hl.exec_cmd("systemctl --user start hyprland-session.target")
+end)
+-- DMS_STARTUP_END
+
+hl.config({
+	input = {
+		kb_layout = "us",
+		numlock_by_default = true,
+		touchpad = {
+			tap_to_click = true,
+			natural_scroll = true,
+		},
+	},
+	general = {
+		gaps_in = 5,
+		gaps_out = 5,
+		border_size = 2,
+		layout = "dwindle",
+	},
+	decoration = {
+		rounding = 12,
+		active_opacity = 1.0,
+		inactive_opacity = 1.0,
+		shadow = {
+			enabled = true,
+			range = 30,
+			render_power = 5,
+			offset = "0 5",
+			color = "rgba(00000070)",
+		},
+	},
+	misc = {
+		disable_hyprland_logo = true,
+		disable_splash_rendering = true,
+	},
+	dwindle = {
+		preserve_split = true,
+	},
+	master = {
+		mfact = 0.5,
+	},
+})
+
+hl.animation({ leaf = "windowsIn", enabled = true, speed = 3, bezier = "default" })
+hl.animation({ leaf = "windowsOut", enabled = true, speed = 3, bezier = "default" })
+hl.animation({ leaf = "workspaces", enabled = true, speed = 5, bezier = "default" })
+hl.animation({ leaf = "windowsMove", enabled = true, speed = 4, bezier = "default" })
+hl.animation({ leaf = "fade", enabled = true, speed = 3, bezier = "default" })
+hl.animation({ leaf = "border", enabled = true, speed = 3, bezier = "default" })
+
+hl.window_rule({ match = { class = "^(org\\.wezfurlong\\.wezterm)$" }, tile = true })
+hl.window_rule({ match = { class = "^(org\\.gnome\\.)" }, rounding = 12 })
+hl.window_rule({ match = { class = "^(gnome-control-center)$" }, tile = true })
+hl.window_rule({ match = { class = "^(pavucontrol)$" }, tile = true })
+hl.window_rule({ match = { class = "^(nm-connection-editor)$" }, tile = true })
+hl.window_rule({ match = { class = "^(org\\.gnome\\.Calculator)$" }, float = true })
+hl.window_rule({ match = { class = "^(gnome-calculator)$" }, float = true })
+hl.window_rule({ match = { class = "^(galculator)$" }, float = true })
+hl.window_rule({ match = { class = "^(blueman-manager)$" }, float = true })
+hl.window_rule({ match = { class = "^(org\\.gnome\\.Nautilus)$" }, float = true })
+hl.window_rule({ match = { class = "^(xdg-desktop-portal)$" }, float = true })
+hl.window_rule({
+	match = { class = "^(steam)$", title = "^(notificationtoasts)" },
+	no_initial_focus = true,
+	pin = true,
+})
+hl.window_rule({
+	match = { class = "^(firefox)$", title = "^(Picture-in-Picture)$" },
+	float = true,
+})
+hl.window_rule({ match = { class = "^(zoom)$" }, float = true })
+hl.layer_rule({ match = { namespace = "^(quickshell)$" }, no_anim = true })
+hl.layer_rule({ match = { namespace = "^dms:.*" }, no_anim = true })
+
+require("dms.colors")
+require("dms.outputs")
+require("dms.layout")
+require("dms.cursor")
+require("dms.binds")
+require("dms.binds-user")
+require("dms.windowrules")

core/internal/config/embedded/mango-binds.conf

@@ -0,0 +1,140 @@
+# DMS default keybinds (MangoWM) — managed by DMS, regenerated by `dms setup`.
+# Format: bind=MODS,key,action[,args]
+# Put bind descriptions above bind lines; inline # comments break Mango spawn args.
+
+# === Application Launchers ===
+# Open Terminal
+bind=SUPER,t,spawn,{{TERMINAL_COMMAND}}
+# Open Terminal
+bind=SUPER,Return,spawn,{{TERMINAL_COMMAND}}
+# Application Launcher
+bind=SUPER,space,spawn,dms ipc call spotlight toggle
+# Spotlight Bar
+bind=ALT,space,spawn,dms ipc call spotlight-bar toggle
+# Clipboard Manager
+bind=SUPER,v,spawn,dms ipc call clipboard toggle
+# Task Manager
+bind=SUPER,m,spawn,dms ipc call processlist focusOrToggle
+# Settings
+bind=SUPER,comma,spawn,dms ipc call settings focusOrToggle
+# Notification Center
+bind=SUPER,n,spawn,dms ipc call notifications toggle
+# Notepad
+bind=SUPER+SHIFT,n,spawn,dms ipc call notepad toggle
+# Browse Wallpapers
+bind=SUPER,y,spawn,dms ipc call dankdash wallpaper
+# Power Menu
+bind=SUPER,x,spawn,dms ipc call powermenu toggle
+# Cycle Display Profile
+bind=SUPER,p,spawn,dms ipc outputs cycleProfile
+
+# === Cheat sheet ===
+# Keyboard Shortcuts
+bind=SUPER+SHIFT,slash,spawn,dms ipc call keybinds toggle mangowc
+
+# === Security ===
+# Lock Screen
+bind=SUPER+ALT,l,spawn,dms ipc call lock lock
+# Task Manager
+bind=CTRL+ALT,Delete,spawn,dms ipc call processlist focusOrToggle
+
+# === Window Rules ===
+# Create Window Rule
+bind=SUPER+SHIFT,w,spawn,dms ipc call window-rules toggle
+
+# === Screenshots ===
+# Screenshot: Interactive
+bind=none,Print,spawn,dms screenshot
+# Screenshot: Full Screen
+bind=CTRL,Print,spawn,dms screenshot full
+# Screenshot: Window
+bind=ALT,Print,spawn,dms screenshot window
+
+# === Audio Controls ===
+bind=none,XF86AudioRaiseVolume,spawn,dms ipc call audio increment 3
+bind=none,XF86AudioLowerVolume,spawn,dms ipc call audio decrement 3
+bind=none,XF86AudioMute,spawn,dms ipc call audio mute
+bind=none,XF86AudioMicMute,spawn,dms ipc call audio micmute
+bind=none,XF86AudioPlay,spawn,dms ipc call mpris playPause
+bind=none,XF86AudioPause,spawn,dms ipc call mpris playPause
+bind=none,XF86AudioPrev,spawn,dms ipc call mpris previous
+bind=none,XF86AudioNext,spawn,dms ipc call mpris next
+
+# === Brightness Controls ===
+bind=none,XF86MonBrightnessUp,spawn,dms ipc call brightness increment 5
+bind=none,XF86MonBrightnessDown,spawn,dms ipc call brightness decrement 5
+
+# === Window Management ===
+# Close Window
+bind=SUPER,q,killclient,
+bind=SUPER,f,togglefullscreen,
+bind=SUPER,a,togglemaximizescreen,
+bind=SUPER+SHIFT,space,togglefloating,
+bind=SUPER,o,toggleoverview
+bind=ALT,Tab,toggleoverview
+# Exit Compositor
+bind=SUPER+SHIFT,e,quit,
+
+# === Focus Navigation ===
+bind=SUPER,Tab,focusstack,next
+bind=SUPER+SHIFT,Tab,focusstack,prev
+bind=SUPER,Left,focusdir,left
+bind=SUPER,H,focusdir,left
+bind=SUPER,Right,focusdir,right
+bind=SUPER,L,focusdir,right
+bind=SUPER,Up,focusdir,up
+bind=SUPER,K,focusdir,up
+bind=SUPER,Down,focusdir,down
+bind=SUPER,J,focusdir,down
+
+# === Window Movement ===
+bind=SUPER+SHIFT,Left,exchange_client,left
+bind=SUPER+SHIFT,Right,exchange_client,right
+bind=SUPER+SHIFT,Up,exchange_client,up
+bind=SUPER+SHIFT,Down,exchange_client,down
+bind=SUPER+SHIFT,H,exchange_client,left
+bind=SUPER+SHIFT,L,exchange_client,right
+bind=SUPER+SHIFT,K,exchange_client,up
+bind=SUPER+SHIFT,J,exchange_client,down
+
+# === Monitor Navigation ===
+bind=SUPER+ALT,Left,focusmon,left
+bind=SUPER+ALT,Right,focusmon,right
+bind=SUPER+ALT+SHIFT,Left,tagmon,left
+bind=SUPER+ALT+SHIFT,Right,tagmon,right
+
+# === Layout ===
+# Cycle Layout - Gaps, Floating, Tiling
+bind=SUPER+ALT,j,switch_layout
+bind=SUPER+SHIFT,equal,incgaps,1
+bind=SUPER+SHIFT,minus,incgaps,-1
+
+# === Tags (1-9): view tag ===
+bind=SUPER,1,view,1
+bind=SUPER,2,view,2
+bind=SUPER,3,view,3
+bind=SUPER,4,view,4
+bind=SUPER,5,view,5
+bind=SUPER,6,view,6
+bind=SUPER,7,view,7
+bind=SUPER,8,view,8
+bind=SUPER,9,view,9
+
+# === Tags (1-9): move focused window to tag ===
+bind=SUPER+SHIFT,1,tag,1
+bind=SUPER+SHIFT,2,tag,2
+bind=SUPER+SHIFT,3,tag,3
+bind=SUPER+SHIFT,4,tag,4
+bind=SUPER+SHIFT,5,tag,5
+bind=SUPER+SHIFT,6,tag,6
+bind=SUPER+SHIFT,7,tag,7
+bind=SUPER+SHIFT,8,tag,8
+bind=SUPER+SHIFT,9,tag,9
+
+# === Touchpad Gestures ===
+# 3-finger horizontal swipe: switch between occupied workspaces
+gesturebind=none,right,3,viewtoleft_have_client
+gesturebind=none,left,3,viewtoright_have_client
+# 4-finger vertical swipe: toggle the overview
+gesturebind=none,up,4,toggleoverview
+gesturebind=none,down,4,toggleoverview

core/internal/config/embedded/mango-colors.conf

@@ -0,0 +1,6 @@
+# Auto-generated by DMS. Overwritten by matugen (dms/colors.conf).
+# Remove `source=./dms/colors.conf` from config.conf to override manually.
+
+bordercolor = 0x595959ff
+focuscolor  = 0x8ab4f8ff
+urgentcolor = 0xff5555ff

core/internal/config/embedded/mango-layout.conf

@@ -0,0 +1,8 @@
+# Auto-generated by DMS. Regenerated from DMS settings (dms/layout.conf).
+
+border_radius=12
+gappih=5
+gappiv=5
+gappoh=5
+gappov=5
+borderpx=2

core/internal/config/embedded/mango.conf

@@ -0,0 +1,18 @@
+# DankMaterialShell — MangoWM configuration (managed by `dms setup`)
+# Keybinds, colors, layout, outputs, cursor and window rules are pulled from the
+# ./dms fragments below. Add your own binds/rules here; they sit alongside DMS's.
+
+env=XDG_CURRENT_DESKTOP,mango
+env=XDG_SESSION_TYPE,wayland
+
+# exec-once runs only at startup. Do NOT use exec= for the shell: mango re-runs
+# every exec= on each config reload, and DMS reloads the config, which would
+# spawn a new shell on every reload.
+exec-once=dms run
+
+source=./dms/colors.conf
+source=./dms/layout.conf
+source=./dms/cursor.conf
+source=./dms/outputs.conf
+source=./dms/windowrules.conf
+source=./dms/binds.conf

core/internal/config/embedded/niri-binds.kdl

@@ -1,6 +1,6 @@
 binds {
     // === System & Overview ===
-    Mod+D repeat=false { toggle-overview; }
+    Mod+O repeat=false { toggle-overview; }
     Mod+Tab repeat=false { toggle-overview; }
     Mod+Shift+Slash { show-hotkey-overlay; }
 
@@ -9,6 +9,9 @@ binds {
     Mod+Space hotkey-overlay-title="Application Launcher" {
         spawn "dms" "ipc" "call" "spotlight" "toggle";
     }
+    Alt+Space hotkey-overlay-title="Spotlight Bar" {
+        spawn "dms" "ipc" "call" "spotlight-bar" "toggle";
+    }
     Mod+V hotkey-overlay-title="Clipboard Manager" {
         spawn "dms" "ipc" "call" "clipboard" "toggle";
     }

core/internal/config/hyprland.go

@@ -2,14 +2,26 @@ package config
 
 import _ "embed"
 
-//go:embed embedded/hyprland.conf
-var HyprlandConfig string
+//go:embed embedded/hyprland.lua
+var HyprlandLuaConfig string
 
-//go:embed embedded/hypr-colors.conf
-var HyprColorsConfig string
+//go:embed embedded/hypr-colors.lua
+var DMSColorsLuaConfig string
 
-//go:embed embedded/hypr-layout.conf
-var HyprLayoutConfig string
+//go:embed embedded/hypr-layout.lua
+var DMSLayoutLuaConfig string
 
-//go:embed embedded/hypr-binds.conf
-var HyprBindsConfig string
+//go:embed embedded/hypr-binds.lua
+var DMSBindsLuaConfig string
+
+//go:embed embedded/hypr-outputs.lua
+var DMSOutputsLuaConfig string
+
+//go:embed embedded/hypr-cursor.lua
+var DMSCursorLuaConfig string
+
+//go:embed embedded/hypr-windowrules.lua
+var DMSWindowRulesLuaConfig string
+
+//go:embed embedded/hypr-binds-user.lua
+var DMSBindsUserLuaConfig string

core/internal/config/hyprland_lua.go

@@ -0,0 +1,197 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	hyprlandStartupBegin = "-- DMS_STARTUP_BEGIN"
+	hyprlandStartupEnd   = "-- DMS_STARTUP_END"
+)
+
+func extractHyprlangMonitorLines(hyprlang string) []string {
+	re := regexp.MustCompile(`(?m)^\s*#?\s*monitor\s*=.*$`)
+	return re.FindAllString(hyprlang, -1)
+}
+
+func hyprlangMonitorLineToLua(line string) (string, error) {
+	re := regexp.MustCompile(`(?i)^\s*#?\s*monitor\s*=\s*(.*)\s*$`)
+	m := re.FindStringSubmatch(line)
+	if m == nil {
+		return "", fmt.Errorf("not a monitor line")
+	}
+	rest := strings.TrimSpace(m[1])
+	parts := strings.Split(rest, ",")
+	for i := range parts {
+		parts[i] = strings.TrimSpace(parts[i])
+	}
+	if len(parts) < 4 {
+		if len(parts) == 2 && strings.EqualFold(parts[1], "disable") {
+			return fmt.Sprintf(`hl.monitor({ output = %s, disabled = true })`, strconv.Quote(parts[0])), nil
+		}
+		return "", fmt.Errorf("expected at least 4 comma-separated fields")
+	}
+	out := parts[0]
+	mode := parts[1]
+	pos := parts[2]
+	scaleStr := parts[3]
+
+	scaleField := formatMonitorScaleLua(scaleStr)
+	fields := []string{
+		fmt.Sprintf("output = %s", strconv.Quote(out)),
+		fmt.Sprintf("mode = %s", strconv.Quote(mode)),
+		fmt.Sprintf("position = %s", strconv.Quote(pos)),
+		scaleField,
+	}
+	for i := 4; i < len(parts); i += 2 {
+		key := strings.ToLower(strings.TrimSpace(parts[i]))
+		if key == "" {
+			continue
+		}
+		if i+1 >= len(parts) {
+			fields = append(fields, fmt.Sprintf("%s = true", hyprlangMonitorOptionToLuaKey(key)))
+			continue
+		}
+		val := strings.TrimSpace(parts[i+1])
+		if converted, ok := formatMonitorOptionLua(key, val); ok {
+			fields = append(fields, converted)
+		}
+	}
+	return fmt.Sprintf(`hl.monitor({ %s })`, strings.Join(fields, ", ")), nil
+}
+
+func formatMonitorScaleLua(scaleStr string) string {
+	if scaleStr == "auto" {
+		return `scale = "auto"`
+	}
+	if f, err := strconv.ParseFloat(scaleStr, 64); err == nil {
+		return fmt.Sprintf(`scale = %g`, f)
+	}
+	return fmt.Sprintf(`scale = %s`, strconv.Quote(scaleStr))
+}
+
+func hyprlangMonitorOptionToLuaKey(key string) string {
+	switch strings.ToLower(strings.TrimSpace(key)) {
+	case "10bit":
+		return "bitdepth"
+	default:
+		return strings.ReplaceAll(strings.ToLower(strings.TrimSpace(key)), "-", "_")
+	}
+}
+
+func formatMonitorOptionLua(key, val string) (string, bool) {
+	luaKey := hyprlangMonitorOptionToLuaKey(key)
+	switch luaKey {
+	case "transform", "vrr", "bitdepth", "supports_wide_color", "supports_hdr", "sdr_max_luminance", "max_luminance", "max_avg_luminance":
+		if _, err := strconv.Atoi(val); err == nil {
+			return fmt.Sprintf("%s = %s", luaKey, val), true
+		}
+	case "sdrbrightness", "sdrsaturation", "sdr_min_luminance", "min_luminance":
+		if _, err := strconv.ParseFloat(val, 64); err == nil {
+			return fmt.Sprintf("%s = %s", luaKey, val), true
+		}
+	case "cm", "sdr_eotf", "icc", "mirror":
+		return fmt.Sprintf("%s = %s", luaKey, strconv.Quote(val)), true
+	}
+	return "", false
+}
+
+func transformHyprlandLuaForNonSystemd(config, terminalCommand string) string {
+	start := strings.Index(config, hyprlandStartupBegin)
+	end := strings.Index(config, hyprlandStartupEnd)
+	if start == -1 || end == -1 || end <= start {
+		return config
+	}
+	endClose := end + len(hyprlandStartupEnd)
+	replacement := hyprlandStartupBegin + "\n" +
+		`hl.env("QT_QPA_PLATFORM", "wayland;xcb")` + "\n" +
+		`hl.env("ELECTRON_OZONE_PLATFORM_HINT", "auto")` + "\n" +
+		`hl.env("QT_QPA_PLATFORMTHEME", "gtk3")` + "\n" +
+		`hl.env("QT_QPA_PLATFORMTHEME_QT6", "gtk3")` + "\n" +
+		fmt.Sprintf(`hl.env("TERMINAL", %s)`, strconv.Quote(terminalCommand)) + "\n\n" +
+		`hl.on("hyprland.start", function()` + "\n" +
+		`	hl.exec_cmd("dms run")` + "\n" +
+		`end)` + "\n" +
+		hyprlandStartupEnd
+	return config[:start] + replacement + config[endClose:]
+}
+
+func readExistingHyprlandConfig(configDir string) (data string, sourcePath string, err error) {
+	luaPath := filepath.Join(configDir, "hyprland.lua")
+	if b, e := os.ReadFile(luaPath); e == nil {
+		return string(b), luaPath, nil
+	} else if !os.IsNotExist(e) {
+		return "", "", e
+	}
+	confPath := filepath.Join(configDir, "hyprland.conf")
+	if b, e := os.ReadFile(confPath); e == nil {
+		return string(b), confPath, nil
+	} else if !os.IsNotExist(e) {
+		return "", "", e
+	}
+	return "", "", nil
+}
+
+// CleanupStrayHyprlandConfFile moves stray ~/.config/hypr/hyprland.conf and
+// top-level ~/.config/hypr/dms/*.conf files into .dms-backups/<timestamp>/ only
+// when hyprland.lua also exists as the live config.
+func CleanupStrayHyprlandConfFile(logFn func(format string, v ...any)) {
+	if os.Getenv("HYPRLAND_INSTANCE_SIGNATURE") == "" {
+		return
+	}
+	home := os.Getenv("HOME")
+	if home == "" {
+		return
+	}
+	configDir := filepath.Join(home, ".config", "hypr")
+	luaPath := filepath.Join(configDir, "hyprland.lua")
+	if _, err := os.Stat(luaPath); err != nil {
+		return
+	}
+
+	var strayPaths []string
+	confPath := filepath.Join(configDir, "hyprland.conf")
+	if info, err := os.Lstat(confPath); err == nil && !info.IsDir() {
+		strayPaths = append(strayPaths, confPath)
+	}
+	dmsConfPaths, err := filepath.Glob(filepath.Join(configDir, "dms", "*.conf"))
+	if err == nil {
+		for _, p := range dmsConfPaths {
+			if info, err := os.Lstat(p); err == nil && !info.IsDir() {
+				strayPaths = append(strayPaths, p)
+			}
+		}
+	}
+	if len(strayPaths) == 0 {
+		return
+	}
+
+	ts := time.Now().Format("2006-01-02_15-04-05")
+	moved := 0
+	for _, src := range strayPaths {
+		rel, err := filepath.Rel(configDir, src)
+		if err != nil {
+			rel = filepath.Base(src)
+		}
+		dst := filepath.Join(configDir, hyprlandBackupDirName, ts, rel)
+		if err := moveHyprlandConfigFile(src, dst); err != nil {
+			if logFn != nil {
+				logFn("Could not move stray Hyprland conf file %s: %v", src, err)
+			}
+			continue
+		}
+		moved++
+		if logFn != nil {
+			logFn("Moved stray Hyprland conf file to %s", dst)
+		}
+	}
+	if moved > 0 && logFn != nil {
+		logFn("Moved %d stray Hyprland conf file(s) out of the active Lua config tree", moved)
+	}
+}

core/internal/config/mango.go

@@ -0,0 +1,15 @@
+package config
+
+import _ "embed"
+
+//go:embed embedded/mango.conf
+var MangoConfig string
+
+//go:embed embedded/mango-colors.conf
+var MangoColorsConfig string
+
+//go:embed embedded/mango-layout.conf
+var MangoLayoutConfig string
+
+//go:embed embedded/mango-binds.conf
+var MangoBindsConfig string

core/internal/deps/detector.go

@@ -35,6 +35,7 @@ type WindowManager int
 const (
 	WindowManagerHyprland WindowManager = iota
 	WindowManagerNiri
+	WindowManagerMango
 )
 
 type Terminal int

core/internal/distros/arch.go

@@ -112,6 +112,11 @@ func (a *ArchDistribution) DetectDependenciesWithTerminal(ctx context.Context, w
 		dependencies = append(dependencies, a.detectXwaylandSatellite())
 	}
 
+	// Mango-specific tools (dwl-based, uses xwayland-satellite like niri)
+	if wm == deps.WindowManagerMango {
+		dependencies = append(dependencies, a.detectXwaylandSatellite())
+	}
+
 	dependencies = append(dependencies, a.detectMatugen())
 	dependencies = append(dependencies, a.detectDgop())
 
@@ -172,6 +177,11 @@ func (a *ArchDistribution) isInSystemRepo(pkg string) bool {
 	return exec.Command("pacman", "-Si", pkg).Run() == nil
 }
 
+// isSonameProvides reports whether dep is a shared-library soname
+func isSonameProvides(dep string) bool {
+	return strings.HasSuffix(dep, ".so") || strings.Contains(dep, ".so.")
+}
+
 func (a *ArchDistribution) GetPackageMapping(wm deps.WindowManager) map[string]PackageMapping {
 	return a.GetPackageMappingWithVariants(wm, make(map[string]deps.PackageVariant))
 }
@@ -199,6 +209,9 @@ func (a *ArchDistribution) GetPackageMappingWithVariants(wm deps.WindowManager,
 	case deps.WindowManagerNiri:
 		packages["niri"] = a.getNiriMapping(variants["niri"])
 		packages["xwayland-satellite"] = PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeSystem}
+	case deps.WindowManagerMango:
+		packages["mango"] = a.getMangoMapping(variants["mango"])
+		packages["xwayland-satellite"] = PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeSystem}
 	}
 
 	return packages
@@ -222,6 +235,13 @@ func (a *ArchDistribution) getNiriMapping(variant deps.PackageVariant) PackageMa
 	return PackageMapping{Name: "niri", Repository: RepoTypeSystem}
 }
 
+func (a *ArchDistribution) getMangoMapping(variant deps.PackageVariant) PackageMapping {
+	if variant == deps.VariantGit {
+		return PackageMapping{Name: "mangowm-git", Repository: RepoTypeAUR}
+	}
+	return PackageMapping{Name: "mangowm", Repository: RepoTypeAUR}
+}
+
 func (a *ArchDistribution) getMatugenMapping(variant deps.PackageVariant) PackageMapping {
 	if runtime.GOARCH == "arm64" {
 		return PackageMapping{Name: "matugen-git", Repository: RepoTypeAUR}
@@ -724,7 +744,7 @@ func (a *ArchDistribution) installSingleAURPackageInternal(ctx context.Context,
 				continue
 			}
 			seen[dep] = true
-			if a.isInSystemRepo(dep) {
+			if isSonameProvides(dep) || a.isInSystemRepo(dep) {
 				systemPkgs = append(systemPkgs, dep)
 			} else {
 				aurPkgs = append(aurPkgs, dep)

core/internal/distros/base.go

@@ -337,6 +337,36 @@ func (b *BaseDistribution) detectWindowManager(wm deps.WindowManager) deps.Depen
 			Variant:     variant,
 			CanToggle:   true,
 		}
+	case deps.WindowManagerMango:
+		status := deps.StatusMissing
+		variant := deps.VariantStable
+		version := ""
+
+		if b.commandExists("mango") {
+			status = deps.StatusInstalled
+			cmd := exec.Command("mango", "-v")
+			if output, err := cmd.Output(); err == nil {
+				outStr := string(output)
+				if strings.Contains(outStr, "git") || strings.Contains(outStr, "dirty") {
+					variant = deps.VariantGit
+				}
+				if versionRegex := regexp.MustCompile(`(\d+\.\d+\.\d+)`); versionRegex.MatchString(outStr) {
+					matches := versionRegex.FindStringSubmatch(outStr)
+					if len(matches) > 1 {
+						version = matches[1]
+					}
+				}
+			}
+		}
+		return deps.Dependency{
+			Name:        "mango",
+			Status:      status,
+			Version:     version,
+			Description: "dwl-based dynamic tiling Wayland compositor",
+			Required:    true,
+			Variant:     variant,
+			CanToggle:   true,
+		}
 	default:
 		return deps.Dependency{
 			Name:        "unknown-wm",

core/internal/distros/fedora.go

@@ -77,7 +77,11 @@ func (f *FedoraDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 
 	// Common detections using base methods
 	dependencies = append(dependencies, f.detectGit())
-	dependencies = append(dependencies, f.detectWindowManager(wm))
+	wmDep := f.detectWindowManager(wm)
+	if wm == deps.WindowManagerMango {
+		wmDep.Description = "MangoWM (Wayland compositor) — the Terra repo will be enabled automatically to install it"
+	}
+	dependencies = append(dependencies, wmDep)
 	dependencies = append(dependencies, f.detectQuickshell())
 	dependencies = append(dependencies, f.detectDMSGreeter())
 	dependencies = append(dependencies, f.detectXDGPortal())
@@ -93,6 +97,11 @@ func (f *FedoraDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 		dependencies = append(dependencies, f.detectXwaylandSatellite())
 	}
 
+	// Mango-specific tools (dwl-based, uses xwayland-satellite like niri)
+	if wm == deps.WindowManagerMango {
+		dependencies = append(dependencies, f.detectXwaylandSatellite())
+	}
+
 	dependencies = append(dependencies, f.detectMatugen())
 	dependencies = append(dependencies, f.detectDgop())
 
@@ -139,6 +148,10 @@ func (f *FedoraDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 	case deps.WindowManagerNiri:
 		packages["niri"] = f.getNiriMapping(variants["niri"])
 		packages["xwayland-satellite"] = PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeSystem}
+	case deps.WindowManagerMango:
+		// mangowm resolves via Terra, enabled automatically by enableTerraRepo.
+		packages["mango"] = PackageMapping{Name: "mangowm", Repository: RepoTypeSystem}
+		packages["xwayland-satellite"] = PackageMapping{Name: "xwayland-satellite", Repository: RepoTypeSystem}
 	}
 
 	return packages
@@ -159,7 +172,7 @@ func (f *FedoraDistribution) getDmsMapping(variant deps.PackageVariant) PackageM
 }
 
 func (f *FedoraDistribution) getHyprlandMapping(_ deps.PackageVariant) PackageMapping {
-	return PackageMapping{Name: "hyprland", Repository: RepoTypeCOPR, RepoURL: "sdegler/hyprland"}
+	return PackageMapping{Name: "hyprland", Repository: RepoTypeCOPR, RepoURL: "lionheartp/Hyprland"}
 }
 
 func (f *FedoraDistribution) getNiriMapping(variant deps.PackageVariant) PackageMapping {
@@ -297,6 +310,22 @@ func (f *FedoraDistribution) InstallPackages(ctx context.Context, dependencies [
 		}
 	}
 
+	// Phase 2b: Enable Terra repo for MangoWM (not in Fedora's repos). Must run
+	// before the DNF phase so `mangowm` resolves.
+	if wm == deps.WindowManagerMango {
+		progressChan <- InstallProgressMsg{
+			Phase:      PhaseSystemPackages,
+			Progress:   0.25,
+			Step:       "Enabling Terra repository for MangoWM...",
+			IsComplete: false,
+			NeedsSudo:  true,
+			LogOutput:  "Setting up the Terra repo (fyralabs) to provide mango",
+		}
+		if err := f.enableTerraRepo(ctx, sudoPassword, progressChan); err != nil {
+			return fmt.Errorf("failed to enable Terra repository: %w", err)
+		}
+	}
+
 	// Phase 3: System Packages (DNF)
 	if len(dnfPkgs) > 0 {
 		progressChan <- InstallProgressMsg{
@@ -423,6 +452,30 @@ func (f *FedoraDistribution) extractPackageNames(packages []PackageMapping) []st
 	return names
 }
 
+// enableTerraRepo registers the persistent Terra repo (via terra-release) so
+// `mangowm` resolves in the DNF phase. $releasever is single-quoted so dnf, not
+// the shell, expands it.
+func (f *FedoraDistribution) enableTerraRepo(ctx context.Context, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
+	// Skip if Terra is already configured
+	if exec.CommandContext(ctx, "sh", "-c",
+		"rpm -q terra-release >/dev/null 2>&1 || test -f /etc/yum.repos.d/terra.repo").Run() == nil {
+		f.log("Terra repository already configured, skipping enable")
+		return nil
+	}
+
+	f.log("Enabling Terra repository (fyralabs) for mango...")
+	cmd := privesc.ExecCommand(ctx, sudoPassword,
+		`dnf install -y --nogpgcheck --repofrompath 'terra,https://repos.fyralabs.com/terra$releasever' terra-release 2>&1`)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		f.logError("failed to enable Terra repository", err)
+		f.log(fmt.Sprintf("Terra enable output: %s", string(output)))
+		return fmt.Errorf("failed to enable Terra repository: %w", err)
+	}
+	f.log(fmt.Sprintf("Terra repository enabled: %s", string(output)))
+	return nil
+}
+
 func (f *FedoraDistribution) enableCOPRRepos(ctx context.Context, coprPkgs []PackageMapping, sudoPassword string, progressChan chan<- InstallProgressMsg) error {
 	enabledRepos := make(map[string]bool)
 

core/internal/distros/gentoo.go

@@ -106,6 +106,11 @@ func (g *GentooDistribution) DetectDependenciesWithTerminal(ctx context.Context,
 		dependencies = append(dependencies, g.detectXwaylandSatellite())
 	}
 
+	// Mango-specific tools (dwl-based, uses xwayland-satellite like niri)
+	if wm == deps.WindowManagerMango {
+		dependencies = append(dependencies, g.detectXwaylandSatellite())
+	}
+
 	dependencies = append(dependencies, g.detectMatugen())
 	dependencies = append(dependencies, g.detectDgop())
 
@@ -176,6 +181,10 @@ func (g *GentooDistribution) GetPackageMappingWithVariants(wm deps.WindowManager
 	case deps.WindowManagerNiri:
 		packages["niri"] = g.getNiriMapping(variants["niri"])
 		packages["xwayland-satellite"] = PackageMapping{Name: "gui-apps/xwayland-satellite", Repository: RepoTypeGURU, AcceptKeywords: archKeyword}
+	case deps.WindowManagerMango:
+		packages["mango"] = g.getMangoMapping(variants["mango"])
+		packages["scenefx"] = PackageMapping{Name: "gui-libs/scenefx", Repository: RepoTypeGURU, AcceptKeywords: archKeyword}
+		packages["xwayland-satellite"] = PackageMapping{Name: "gui-apps/xwayland-satellite", Repository: RepoTypeGURU, AcceptKeywords: archKeyword}
 	}
 
 	return packages
@@ -197,6 +206,10 @@ func (g *GentooDistribution) getNiriMapping(_ deps.PackageVariant) PackageMappin
 	return PackageMapping{Name: "gui-wm/niri", Repository: RepoTypeGURU, UseFlags: "dbus screencast", AcceptKeywords: g.getArchKeyword()}
 }
 
+func (g *GentooDistribution) getMangoMapping(_ deps.PackageVariant) PackageMapping {
+	return PackageMapping{Name: "gui-wm/mangowm", Repository: RepoTypeGURU, AcceptKeywords: g.getArchKeyword()}
+}
+
 func (g *GentooDistribution) getPrerequisites() []string {
 	return []string{
 		"app-eselect/eselect-repository",

core/internal/greeter/installer.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"os/user"
 	"path/filepath"
 	"strings"
 	"time"
@@ -191,6 +192,431 @@ func upsertDefaultSession(configContent, greeterUser, command string) string {
 	return strings.Join(out, "\n")
 }
 
+func removeTomlSection(configContent, sectionName string) string {
+	lines := strings.Split(configContent, "\n")
+	var out []string
+	inSection := false
+
+	for _, line := range lines {
+		if section, ok := parseTomlSection(line); ok {
+			inSection = section == sectionName
+			if inSection {
+				continue
+			}
+			out = append(out, line)
+			continue
+		}
+
+		if inSection {
+			continue
+		}
+
+		out = append(out, line)
+	}
+
+	result := strings.TrimRight(strings.Join(out, "\n"), "\n")
+	if result != "" {
+		result += "\n"
+	}
+	return result
+}
+
+func stripDesktopExecCodes(execLine string) string {
+	fields := strings.Fields(execLine)
+	cleaned := make([]string, 0, len(fields))
+	for _, field := range fields {
+		if strings.HasPrefix(field, "%") {
+			continue
+		}
+		cleaned = append(cleaned, field)
+	}
+	return strings.Join(cleaned, " ")
+}
+
+func shellQuote(value string) string {
+	return "'" + strings.ReplaceAll(value, "'", "'\\''") + "'"
+}
+
+func stableDMSCommand() string {
+	for _, candidate := range []string{"/usr/bin/dms", "/usr/local/bin/dms"} {
+		info, err := os.Stat(candidate)
+		if err == nil && !info.IsDir() && info.Mode()&0o111 != 0 {
+			return candidate
+		}
+	}
+	return "dms"
+}
+
+func formatInitialSessionCommand(cacheDir string) string {
+	cacheDir = strings.TrimSpace(cacheDir)
+	if cacheDir == "" {
+		return `command = ""`
+	}
+	launcher := fmt.Sprintf("%s greeter launch-session --from-memory --cache-dir %s", stableDMSCommand(), shellQuote(cacheDir))
+	escaped := strings.ReplaceAll(launcher, `'`, `'\''`)
+	inner := fmt.Sprintf("env XDG_SESSION_TYPE=wayland sh -c 'exec %s'", escaped)
+	tomlEscaped := strings.ReplaceAll(inner, `\`, `\\`)
+	tomlEscaped = strings.ReplaceAll(tomlEscaped, `"`, `\"`)
+	return fmt.Sprintf(`command = "%s"`, tomlEscaped)
+}
+
+func upsertInitialSession(configContent, loginUser, cacheDir string, enabled bool) string {
+	if !enabled {
+		return removeTomlSection(configContent, "initial_session")
+	}
+
+	commandLine := formatInitialSessionCommand(cacheDir)
+	lines := strings.Split(configContent, "\n")
+	var out []string
+
+	inInitialSession := false
+	foundInitialSession := false
+	initialSessionUserSet := false
+	initialSessionCommandSet := false
+
+	appendInitialSessionFields := func() {
+		if !initialSessionUserSet {
+			out = append(out, fmt.Sprintf(`user = "%s"`, loginUser))
+		}
+		if !initialSessionCommandSet {
+			out = append(out, commandLine)
+		}
+	}
+
+	for _, line := range lines {
+		if section, ok := parseTomlSection(line); ok {
+			if inInitialSession {
+				appendInitialSessionFields()
+			}
+
+			inInitialSession = section == "initial_session"
+			if inInitialSession {
+				foundInitialSession = true
+				initialSessionUserSet = false
+				initialSessionCommandSet = false
+			}
+
+			out = append(out, line)
+			continue
+		}
+
+		if inInitialSession {
+			trimmed := stripTomlComment(line)
+			if strings.HasPrefix(trimmed, "user =") || strings.HasPrefix(trimmed, "user=") {
+				out = append(out, fmt.Sprintf(`user = "%s"`, loginUser))
+				initialSessionUserSet = true
+				continue
+			}
+
+			if strings.HasPrefix(trimmed, "command =") || strings.HasPrefix(trimmed, "command=") {
+				if !initialSessionCommandSet {
+					out = append(out, commandLine)
+					initialSessionCommandSet = true
+				}
+				continue
+			}
+		}
+
+		out = append(out, line)
+	}
+
+	if inInitialSession {
+		appendInitialSessionFields()
+	}
+
+	if !foundInitialSession {
+		if len(out) > 0 && strings.TrimSpace(out[len(out)-1]) != "" {
+			out = append(out, "")
+		}
+		out = append(out, "[initial_session]")
+		out = append(out, fmt.Sprintf(`user = "%s"`, loginUser))
+		out = append(out, commandLine)
+	}
+
+	return strings.Join(out, "\n")
+}
+
+type greeterAutoLoginConfig struct {
+	GreeterAutoLogin           bool `json:"greeterAutoLogin"`
+	GreeterRememberLastUser    bool `json:"greeterRememberLastUser"`
+	GreeterRememberLastSession bool `json:"greeterRememberLastSession"`
+}
+
+type greeterAutoLoginMemory struct {
+	LastSuccessfulUser   string `json:"lastSuccessfulUser"`
+	LastSessionID        string `json:"lastSessionId"`
+	LastSessionDesktopID string `json:"lastSessionDesktopId"`
+	LastSessionExec      string `json:"lastSessionExec"`
+	AutoLoginEnabled     bool   `json:"autoLoginEnabled"`
+}
+
+func readGreeterAutoLoginConfig(settingsPath string) (greeterAutoLoginConfig, error) {
+	cfg := greeterAutoLoginConfig{
+		GreeterRememberLastUser:    true,
+		GreeterRememberLastSession: true,
+	}
+	data, err := os.ReadFile(settingsPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return cfg, nil
+		}
+		return cfg, err
+	}
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return cfg, fmt.Errorf("failed to parse settings at %s: %w", settingsPath, err)
+	}
+	return cfg, nil
+}
+
+func readGreeterAutoLoginMemory(memoryPath string) (greeterAutoLoginMemory, error) {
+	var mem greeterAutoLoginMemory
+	data, err := os.ReadFile(memoryPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return mem, nil
+		}
+		return mem, err
+	}
+	if err := json.Unmarshal(data, &mem); err != nil {
+		return mem, fmt.Errorf("failed to parse greeter memory at %s: %w", memoryPath, err)
+	}
+	return mem, nil
+}
+
+func execFromDesktopFile(path string) (string, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	for line := range strings.SplitSeq(string(data), "\n") {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "Exec=") {
+			return strings.TrimSpace(trimmed[len("Exec="):]), nil
+		}
+	}
+	return "", fmt.Errorf("no Exec= line found in %s", path)
+}
+
+func resolveGreeterAutoLoginState(cacheDir, homeDir string) (enabled bool, loginUser string, sessionID string, err error) {
+	settingsPath := filepath.Join(cacheDir, "settings.json")
+	if _, statErr := os.Stat(settingsPath); statErr != nil {
+		settingsPath = filepath.Join(homeDir, ".config", "DankMaterialShell", "settings.json")
+	}
+
+	cfg, err := readGreeterAutoLoginConfig(settingsPath)
+	if err != nil {
+		return false, "", "", err
+	}
+
+	memoryPath := filepath.Join(cacheDir, ".local/state/memory.json")
+	mem, err := readGreeterAutoLoginMemory(memoryPath)
+	if err != nil {
+		return false, "", "", err
+	}
+
+	enabled = cfg.GreeterAutoLogin
+	if !enabled {
+		return false, "", "", nil
+	}
+
+	if !cfg.GreeterRememberLastUser || !cfg.GreeterRememberLastSession {
+		return true, "", "", nil
+	}
+
+	loginUser = mem.LastSuccessfulUser
+	if loginUser == "" {
+		current, userErr := user.Current()
+		if userErr != nil {
+			return true, "", "", userErr
+		}
+		loginUser = current.Username
+	}
+
+	sessionID = sessionDesktopIDFromMemory(mem)
+
+	return true, loginUser, sessionID, nil
+}
+
+func writeGreetdConfig(configPath, content string, logFunc func(string), sudoPassword, successMsg string) error {
+	if err := backupFileIfExists(sudoPassword, configPath, ".backup"); err != nil {
+		return fmt.Errorf("failed to backup greetd config: %w", err)
+	}
+
+	tmpFile, err := os.CreateTemp("", "greetd-config-*.toml")
+	if err != nil {
+		return fmt.Errorf("failed to create temp greetd config: %w", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	if _, err := tmpFile.WriteString(content); err != nil {
+		_ = tmpFile.Close()
+		return fmt.Errorf("failed to write temp greetd config: %w", err)
+	}
+	if err := tmpFile.Close(); err != nil {
+		return fmt.Errorf("failed to close temp greetd config: %w", err)
+	}
+
+	if err := privesc.Run(context.Background(), sudoPassword, "mkdir", "-p", "/etc/greetd"); err != nil {
+		return fmt.Errorf("failed to create /etc/greetd: %w", err)
+	}
+
+	if err := privesc.Run(context.Background(), sudoPassword, "install", "-o", "root", "-g", "root", "-m", "0644", tmpFile.Name(), configPath); err != nil {
+		return fmt.Errorf("failed to install greetd config: %w", err)
+	}
+
+	if logFunc != nil && successMsg != "" {
+		logFunc(successMsg)
+	}
+	return nil
+}
+
+func clearGreeterAutoLoginMemory(memoryPath, sudoPassword string) error {
+	data, err := readGreeterMemoryFile(memoryPath, sudoPassword)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+	if len(strings.TrimSpace(string(data))) == 0 {
+		return nil
+	}
+	var raw map[string]json.RawMessage
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return fmt.Errorf("failed to parse greeter memory at %s: %w", memoryPath, err)
+	}
+	if _, ok := raw["autoLoginEnabled"]; !ok {
+		return nil
+	}
+	delete(raw, "autoLoginEnabled")
+	encoded, err := json.MarshalIndent(raw, "", "  ")
+	if err != nil {
+		return err
+	}
+	if len(encoded) == 0 || string(encoded) == "null" {
+		encoded = []byte("{}")
+	}
+	encoded = append(encoded, '\n')
+
+	if err := os.WriteFile(memoryPath, encoded, 0o644); err == nil {
+		return nil
+	} else if !os.IsPermission(err) {
+		return err
+	}
+
+	tmpFile, err := os.CreateTemp("", "greeter-memory-*.json")
+	if err != nil {
+		return fmt.Errorf("failed to create temp greeter memory file: %w", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	if _, err := tmpFile.Write(encoded); err != nil {
+		_ = tmpFile.Close()
+		return fmt.Errorf("failed to write temp greeter memory file: %w", err)
+	}
+	if err := tmpFile.Close(); err != nil {
+		return fmt.Errorf("failed to close temp greeter memory file: %w", err)
+	}
+
+	greeterUser := DetectGreeterUser()
+	greeterGroup := DetectGreeterGroup()
+	owner := greeterUser + ":" + greeterGroup
+	if err := privesc.Run(context.Background(), sudoPassword, "install", "-o", greeterUser, "-g", greeterGroup, "-m", "0664", tmpFile.Name(), memoryPath); err != nil {
+		if fallbackErr := privesc.Run(context.Background(), sudoPassword, "install", "-o", "root", "-g", greeterGroup, "-m", "0664", tmpFile.Name(), memoryPath); fallbackErr != nil {
+			return fmt.Errorf("failed to install greeter memory file (preferred %s: %w; fallback root:%s: %v)", owner, err, greeterGroup, fallbackErr)
+		}
+	}
+	return nil
+}
+
+func readGreeterMemoryFile(memoryPath, sudoPassword string) ([]byte, error) {
+	data, err := os.ReadFile(memoryPath)
+	if err == nil || !os.IsPermission(err) {
+		return data, err
+	}
+
+	tmpFile, err := os.CreateTemp("", "greeter-memory-read-*")
+	if err != nil {
+		return nil, fmt.Errorf("failed to create temp file for greeter memory read: %w", err)
+	}
+	tmpPath := tmpFile.Name()
+	_ = tmpFile.Close()
+	defer os.Remove(tmpPath)
+
+	if err := privesc.Run(context.Background(), sudoPassword, "cp", "-f", memoryPath, tmpPath); err != nil {
+		return nil, fmt.Errorf("failed to read greeter memory at %s: %w", memoryPath, err)
+	}
+	return os.ReadFile(tmpPath)
+}
+
+func SyncGreetdAutoLogin(cacheDir, homeDir string, logFunc func(string), sudoPassword string) error {
+	enabled, loginUser, sessionID, err := resolveGreeterAutoLoginState(cacheDir, homeDir)
+	if err != nil {
+		return err
+	}
+
+	configPath := "/etc/greetd/config.toml"
+	configContent := ""
+	if data, readErr := os.ReadFile(configPath); readErr == nil {
+		configContent = string(data)
+	} else if !os.IsNotExist(readErr) {
+		return fmt.Errorf("failed to read greetd config: %w", readErr)
+	}
+
+	if !enabled {
+		memoryPath := filepath.Join(cacheDir, ".local/state/memory.json")
+		if err := clearGreeterAutoLoginMemory(memoryPath, sudoPassword); err != nil && logFunc != nil {
+			logFunc(fmt.Sprintf("⚠ Warning: Failed to clear greeter auto-login memory flag: %v", err))
+		}
+		newConfig := upsertInitialSession(configContent, "", "", false)
+		if newConfig == configContent {
+			if logFunc != nil {
+				logFunc("✓ Greeter auto-login disabled")
+			}
+			return nil
+		}
+		return writeGreetdConfig(configPath, newConfig, logFunc, sudoPassword, "✓ Disabled greeter auto-login")
+	}
+
+	if loginUser == "" || sessionID == "" {
+		if logFunc != nil {
+			logFunc("⚠ Greeter auto-login is enabled but user or session is not configured yet. Log in manually once, then run sync.")
+		}
+		newConfig := upsertInitialSession(configContent, "", "", false)
+		if newConfig != configContent {
+			return writeGreetdConfig(configPath, newConfig, nil, sudoPassword, "")
+		}
+		return nil
+	}
+
+	newConfig := upsertInitialSession(configContent, loginUser, cacheDir, true)
+	if newConfig == configContent {
+		if logFunc != nil {
+			logFunc(fmt.Sprintf("✓ Greeter auto-login already configured for %s", loginUser))
+		}
+		memoryPath := filepath.Join(cacheDir, ".local/state/memory.json")
+		_ = clearGreeterAutoLoginMemory(memoryPath, sudoPassword)
+		return nil
+	}
+
+	if err := writeGreetdConfig(configPath, newConfig, logFunc, sudoPassword, fmt.Sprintf("✓ Configured greeter auto-login for %s", loginUser)); err != nil {
+		return err
+	}
+	memoryPath := filepath.Join(cacheDir, ".local/state/memory.json")
+	if err := clearGreeterAutoLoginMemory(memoryPath, sudoPassword); err != nil && logFunc != nil {
+		logFunc(fmt.Sprintf("⚠ Warning: Failed to clear greeter auto-login memory flag: %v", err))
+	}
+	return nil
+}
+
+func SyncGreeterAutoLoginOnly(logFunc func(string), sudoPassword string) error {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get user home directory: %w", err)
+	}
+	return SyncGreetdAutoLogin(GreeterCacheDir, homeDir, logFunc, sudoPassword)
+}
+
 func DetectGreeterUser() string {
 	passwdData, err := os.ReadFile("/etc/passwd")
 	if err == nil {
@@ -264,6 +690,9 @@ func DetectCompositors() []string {
 	if utils.CommandExists("Hyprland") {
 		compositors = append(compositors, "Hyprland")
 	}
+	if utils.CommandExists("mango") {
+		compositors = append(compositors, "mango")
+	}
 
 	return compositors
 }
@@ -572,6 +1001,7 @@ func EnsureGreeterCacheDir(logFunc func(string), sudoPassword string) error {
 	}
 
 	runtimeDirs := []string{
+		filepath.Join(cacheDir, "users"),
 		filepath.Join(cacheDir, ".local"),
 		filepath.Join(cacheDir, ".local", "state"),
 		filepath.Join(cacheDir, ".local", "share"),
@@ -1255,6 +1685,20 @@ func SyncDMSConfigs(dmsPath, compositor string, logFunc func(string), sudoPasswo
 		return fmt.Errorf("greeter wallpaper override sync failed: %w", err)
 	}
 
+	currentUser, err := user.Current()
+	if err != nil {
+		return fmt.Errorf("failed to resolve syncing user for per-user greeter cache: %w", err)
+	}
+	if err := syncUserGreeterCacheSlot(homeDir, cacheDir, currentUser.Username, state, logFunc, userSlotSyncOpts{
+		sudoPassword: sudoPassword,
+	}); err != nil {
+		return fmt.Errorf("per-user greeter cache sync failed: %w", err)
+	}
+
+	if err := SyncGreetdAutoLogin(cacheDir, homeDir, logFunc, sudoPassword); err != nil {
+		logFunc(fmt.Sprintf("⚠ Warning: greeter auto-login sync failed: %v", err))
+	}
+
 	if strings.ToLower(compositor) != "niri" {
 		return nil
 	}
@@ -1719,29 +2163,10 @@ vt = 1
 	commandLine := fmt.Sprintf(`command = "%s"`, commandValue)
 	newConfig := upsertDefaultSession(configContent, greeterUser, commandLine)
 
-	tmpFile, err := os.CreateTemp("", "greetd-config-*.toml")
-	if err != nil {
-		return fmt.Errorf("failed to create temp greetd config: %w", err)
-	}
-	defer os.Remove(tmpFile.Name())
-
-	if _, err := tmpFile.WriteString(newConfig); err != nil {
-		_ = tmpFile.Close()
-		return fmt.Errorf("failed to write temp greetd config: %w", err)
-	}
-	if err := tmpFile.Close(); err != nil {
-		return fmt.Errorf("failed to close temp greetd config: %w", err)
+	if err := writeGreetdConfig(configPath, newConfig, logFunc, sudoPassword, fmt.Sprintf("✓ Updated greetd configuration (user: %s, command: %s)", greeterUser, commandValue)); err != nil {
+		return err
 	}
 
-	if err := privesc.Run(context.Background(), sudoPassword, "mkdir", "-p", "/etc/greetd"); err != nil {
-		return fmt.Errorf("failed to create /etc/greetd: %w", err)
-	}
-
-	if err := privesc.Run(context.Background(), sudoPassword, "install", "-o", "root", "-g", "root", "-m", "0644", tmpFile.Name(), configPath); err != nil {
-		return fmt.Errorf("failed to install greetd config: %w", err)
-	}
-
-	logFunc(fmt.Sprintf("✓ Updated greetd configuration (user: %s, command: %s)", greeterUser, commandValue))
 	return nil
 }
 

core/internal/greeter/installer_test.go

@@ -3,6 +3,7 @@ package greeter
 import (
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 )
 
@@ -96,3 +97,204 @@ func TestResolveGreeterThemeSyncState(t *testing.T) {
 		})
 	}
 }
+
+func TestUpsertInitialSession(t *testing.T) {
+	t.Parallel()
+
+	baseConfig := `[terminal]
+vt = 1
+
+[default_session]
+user = "greeter"
+command = "/usr/bin/dms-greeter --command niri"
+`
+
+	t.Run("inserts initial session", func(t *testing.T) {
+		t.Parallel()
+		got := upsertInitialSession(baseConfig, "alice", "/var/cache/dms-greeter", true)
+		if !strings.Contains(got, "[initial_session]") {
+			t.Fatalf("expected [initial_session] section, got:\n%s", got)
+		}
+		if !strings.Contains(got, `user = "alice"`) {
+			t.Fatalf("expected alice user in initial session, got:\n%s", got)
+		}
+		if !strings.Contains(got, `dms greeter launch-session --from-memory --cache-dir`) {
+			t.Fatalf("expected stable launch-session command, got:\n%s", got)
+		}
+		if strings.Contains(got, `exec niri`) {
+			t.Fatalf("initial session must not bake the desktop Exec command, got:\n%s", got)
+		}
+	})
+
+	t.Run("updates existing initial session", func(t *testing.T) {
+		t.Parallel()
+		existing := baseConfig + `
+[initial_session]
+user = "bob"
+command = "old-command"
+`
+		got := upsertInitialSession(existing, "alice", "/var/cache/dms-greeter", true)
+		if strings.Contains(got, `user = "bob"`) {
+			t.Fatalf("expected bob to be replaced, got:\n%s", got)
+		}
+		if !strings.Contains(got, `dms greeter launch-session --from-memory`) {
+			t.Fatalf("expected launch-session command, got:\n%s", got)
+		}
+	})
+
+	t.Run("removes initial session when disabled", func(t *testing.T) {
+		t.Parallel()
+		existing := baseConfig + `
+[initial_session]
+user = "alice"
+command = "niri"
+`
+		got := upsertInitialSession(existing, "", "", false)
+		if strings.Contains(got, "[initial_session]") {
+			t.Fatalf("expected initial session removed, got:\n%s", got)
+		}
+		if !strings.Contains(got, "[default_session]") {
+			t.Fatalf("expected default session preserved, got:\n%s", got)
+		}
+	})
+}
+
+func TestStripDesktopExecCodes(t *testing.T) {
+	t.Parallel()
+
+	got := stripDesktopExecCodes("niri --session %f")
+	want := "niri --session"
+	if got != want {
+		t.Fatalf("stripDesktopExecCodes = %q, want %q", got, want)
+	}
+}
+
+func TestResolveGreeterAutoLoginState(t *testing.T) {
+	t.Parallel()
+
+	cacheDir := t.TempDir()
+	homeDir := t.TempDir()
+
+	writeTestFile(t, filepath.Join(cacheDir, "settings.json"), `{
+  "greeterAutoLogin": true,
+  "greeterRememberLastUser": true,
+  "greeterRememberLastSession": true
+}`)
+	writeTestFile(t, filepath.Join(cacheDir, ".local/state/memory.json"), `{
+  "lastSuccessfulUser": "alice",
+  "lastSessionDesktopId": "niri.desktop"
+}`)
+
+	enabled, loginUser, sessionID, err := resolveGreeterAutoLoginState(cacheDir, homeDir)
+	if err != nil {
+		t.Fatalf("resolveGreeterAutoLoginState returned error: %v", err)
+	}
+	if !enabled || loginUser != "alice" || sessionID != "niri.desktop" {
+		t.Fatalf("got enabled=%v user=%q session=%q", enabled, loginUser, sessionID)
+	}
+}
+
+func TestResolveGreeterAutoLoginStateIgnoresStaleSessionExec(t *testing.T) {
+	t.Parallel()
+
+	cacheDir := t.TempDir()
+	homeDir := t.TempDir()
+
+	writeTestFile(t, filepath.Join(cacheDir, "settings.json"), `{
+  "greeterAutoLogin": true,
+  "greeterRememberLastUser": true,
+  "greeterRememberLastSession": true
+}`)
+	writeTestFile(t, filepath.Join(cacheDir, ".local/state/memory.json"), `{
+  "lastSuccessfulUser": "alice",
+  "lastSessionId": "/nix/store/old-session/share/wayland-sessions/example.desktop",
+  "lastSessionExec": "/nix/store/old-session/bin/start-example-session"
+}`)
+
+	enabled, loginUser, sessionID, err := resolveGreeterAutoLoginState(cacheDir, homeDir)
+	if err != nil {
+		t.Fatalf("resolveGreeterAutoLoginState returned error: %v", err)
+	}
+	if !enabled || loginUser != "alice" || sessionID != "example.desktop" {
+		t.Fatalf("got enabled=%v user=%q session=%q", enabled, loginUser, sessionID)
+	}
+
+	got := upsertInitialSession("", loginUser, cacheDir, true)
+	if strings.Contains(got, "/nix/store/old-session") {
+		t.Fatalf("initial session must not include stale store path, got:\n%s", got)
+	}
+}
+
+func TestResolveGreeterAutoLoginStateIgnoresMemoryFlag(t *testing.T) {
+	t.Parallel()
+
+	cacheDir := t.TempDir()
+	homeDir := t.TempDir()
+
+	writeTestFile(t, filepath.Join(cacheDir, "settings.json"), `{
+  "greeterAutoLogin": false,
+  "greeterRememberLastUser": true,
+  "greeterRememberLastSession": true
+}`)
+	writeTestFile(t, filepath.Join(cacheDir, ".local/state/memory.json"), `{
+  "autoLoginEnabled": true,
+  "lastSuccessfulUser": "alice",
+  "lastSessionExec": "niri"
+}`)
+
+	enabled, loginUser, sessionID, err := resolveGreeterAutoLoginState(cacheDir, homeDir)
+	if err != nil {
+		t.Fatalf("resolveGreeterAutoLoginState returned error: %v", err)
+	}
+	if enabled || loginUser != "" || sessionID != "" {
+		t.Fatalf("expected disabled with empty user/session, got enabled=%v user=%q session=%q", enabled, loginUser, sessionID)
+	}
+}
+
+func TestResolveSessionExecInDirs(t *testing.T) {
+	t.Parallel()
+
+	oldDir := filepath.Join(t.TempDir(), "wayland-sessions")
+	newDir := filepath.Join(t.TempDir(), "wayland-sessions")
+	writeTestFile(t, filepath.Join(oldDir, "example.desktop"), `[Desktop Entry]
+Name=Example Session
+Exec=/nix/store/old-session/bin/start-example-session
+`)
+	writeTestFile(t, filepath.Join(newDir, "example.desktop"), `[Desktop Entry]
+Name=Example Session
+Exec=/run/current-system/sw/bin/start-example-session
+`)
+
+	got, err := resolveSessionExecInDirs("example.desktop", []string{newDir, oldDir})
+	if err != nil {
+		t.Fatalf("resolveSessionExecInDirs returned error: %v", err)
+	}
+	if got != "/run/current-system/sw/bin/start-example-session" {
+		t.Fatalf("resolveSessionExecInDirs = %q", got)
+	}
+}
+
+func TestClearGreeterAutoLoginMemory(t *testing.T) {
+	t.Parallel()
+
+	memoryPath := filepath.Join(t.TempDir(), "memory.json")
+	writeTestFile(t, memoryPath, `{
+  "autoLoginEnabled": true,
+  "lastSuccessfulUser": "alice"
+}`)
+
+	if err := clearGreeterAutoLoginMemory(memoryPath, ""); err != nil {
+		t.Fatalf("clearGreeterAutoLoginMemory returned error: %v", err)
+	}
+
+	data, err := os.ReadFile(memoryPath)
+	if err != nil {
+		t.Fatalf("failed to read memory file: %v", err)
+	}
+	if strings.Contains(string(data), "autoLoginEnabled") {
+		t.Fatalf("expected autoLoginEnabled removed, got: %s", string(data))
+	}
+	if !strings.Contains(string(data), "lastSuccessfulUser") {
+		t.Fatalf("expected other memory fields preserved, got: %s", string(data))
+	}
+}

core/internal/greeter/session_launcher.go

@@ -0,0 +1,122 @@
+package greeter
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"syscall"
+)
+
+func sessionDesktopIDFromPath(path string) string {
+	id := strings.TrimSpace(path)
+	if id == "" {
+		return ""
+	}
+	if strings.ContainsAny(id, "/\\") {
+		id = filepath.Base(id)
+	}
+	if id == "" {
+		return ""
+	}
+	if !strings.HasSuffix(id, ".desktop") {
+		id += ".desktop"
+	}
+	return id
+}
+
+func sessionDesktopIDFromMemory(mem greeterAutoLoginMemory) string {
+	if id := sessionDesktopIDFromPath(mem.LastSessionDesktopID); id != "" {
+		return id
+	}
+	return sessionDesktopIDFromPath(mem.LastSessionID)
+}
+
+func sessionDesktopDirs() []string {
+	seen := make(map[string]bool)
+	dirs := make([]string, 0, 8)
+
+	addBase := func(base string) {
+		base = strings.TrimSpace(base)
+		if base == "" {
+			return
+		}
+		for _, sub := range []string{"wayland-sessions", "xsessions"} {
+			dir := filepath.Join(base, sub)
+			if seen[dir] {
+				continue
+			}
+			seen[dir] = true
+			dirs = append(dirs, dir)
+		}
+	}
+
+	if dataHome := os.Getenv("XDG_DATA_HOME"); dataHome != "" {
+		addBase(dataHome)
+	} else if home, err := os.UserHomeDir(); err == nil && home != "" {
+		addBase(filepath.Join(home, ".local", "share"))
+	}
+
+	if dataDirs := os.Getenv("XDG_DATA_DIRS"); dataDirs != "" {
+		for _, dir := range strings.Split(dataDirs, ":") {
+			addBase(dir)
+		}
+	} else {
+		addBase("/usr/local/share")
+		addBase("/usr/share")
+	}
+
+	return dirs
+}
+
+func ResolveSessionExec(sessionID string) (string, error) {
+	return resolveSessionExecInDirs(sessionID, sessionDesktopDirs())
+}
+
+func resolveSessionExecInDirs(sessionID string, dirs []string) (string, error) {
+	id := sessionDesktopIDFromPath(sessionID)
+	if id == "" {
+		return "", fmt.Errorf("session id is empty")
+	}
+
+	for _, dir := range dirs {
+		path := filepath.Join(dir, id)
+		execLine, err := execFromDesktopFile(path)
+		if err == nil {
+			return execLine, nil
+		}
+		if !os.IsNotExist(err) {
+			return "", err
+		}
+	}
+
+	return "", fmt.Errorf("session desktop file %q was not found", id)
+}
+
+func LaunchSessionByID(sessionID string) error {
+	execLine, err := ResolveSessionExec(sessionID)
+	if err != nil {
+		return err
+	}
+	execLine = strings.TrimSpace(stripDesktopExecCodes(execLine))
+	if execLine == "" {
+		return fmt.Errorf("session %q has an empty Exec command", sessionID)
+	}
+
+	env := append(os.Environ(), "XDG_SESSION_TYPE=wayland")
+	return syscall.Exec("/bin/sh", []string{"sh", "-c", "exec " + execLine}, env)
+}
+
+func LaunchSessionFromMemory(cacheDir, homeDir string) error {
+	enabled, _, sessionID, err := resolveGreeterAutoLoginState(cacheDir, homeDir)
+	if err != nil {
+		return err
+	}
+	if !enabled {
+		return fmt.Errorf("greeter auto-login is disabled")
+	}
+	if sessionID == "" {
+		return fmt.Errorf("greeter auto-login has no remembered session")
+	}
+	return LaunchSessionByID(sessionID)
+}

core/internal/greeter/user_cache_sync.go

@@ -0,0 +1,548 @@
+package greeter
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"os/user"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
+)
+
+var monitorWallpaperSanitizer = regexp.MustCompile(`[^a-zA-Z0-9]+`)
+
+func userGreeterCacheDir(cacheDir, username string) string {
+	return filepath.Join(cacheDir, "users", username)
+}
+
+func isUserOwnedGreeterCacheSlot(path, username string) bool {
+	if strings.TrimSpace(username) == "" {
+		return false
+	}
+	userDir, err := filepath.Abs(userGreeterCacheDir(GreeterCacheDir, username))
+	if err != nil {
+		return false
+	}
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return false
+	}
+	return abs == userDir || strings.HasPrefix(abs, userDir+string(filepath.Separator))
+}
+
+func UserIsInGreeterGroup(username string) bool {
+	group := DetectGreeterGroup()
+	if !utils.HasGroup(group) {
+		return false
+	}
+	groupsCmd := exec.Command("groups", username)
+	groupsOutput, err := groupsCmd.Output()
+	if err != nil {
+		return false
+	}
+	return strings.Contains(string(groupsOutput), group)
+}
+
+func CanSyncOwnUserGreeterProfile(username string) bool {
+	currentUser, err := user.Current()
+	if err != nil || currentUser.Username != username {
+		return false
+	}
+	if !UserIsInGreeterGroup(username) {
+		return false
+	}
+	usersDir := filepath.Join(GreeterCacheDir, "users")
+	if st, err := os.Stat(usersDir); err != nil || !st.IsDir() {
+		return false
+	}
+	testFile := filepath.Join(usersDir, ".write-test-"+username)
+	file, err := os.OpenFile(testFile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o660)
+	if err != nil {
+		return false
+	}
+	_ = file.Close()
+	_ = os.Remove(testFile)
+	return true
+}
+
+func GreeterProfileSyncReady() bool {
+	if command := readGreeterSessionCommand(); command != "" && strings.Contains(command, "dms-greeter") {
+		return true
+	}
+	usersDir := filepath.Join(GreeterCacheDir, "users")
+	st, err := os.Stat(usersDir)
+	return err == nil && st.IsDir()
+}
+
+func readGreeterSessionCommand() string {
+	data, err := os.ReadFile("/etc/greetd/config.toml")
+	if err != nil {
+		return ""
+	}
+	inDefaultSession := false
+	for line := range strings.SplitSeq(string(data), "\n") {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "[") && strings.HasSuffix(trimmed, "]") {
+			inDefaultSession = strings.EqualFold(strings.Trim(trimmed, "[]"), "default_session")
+			continue
+		}
+		if !inDefaultSession {
+			continue
+		}
+		if idx := strings.Index(trimmed, "#"); idx >= 0 {
+			trimmed = strings.TrimSpace(trimmed[:idx])
+		}
+		if !strings.HasPrefix(trimmed, "command") {
+			continue
+		}
+		parts := strings.SplitN(trimmed, "=", 2)
+		if len(parts) != 2 {
+			continue
+		}
+		command := strings.Trim(strings.TrimSpace(parts[1]), `"`)
+		if command != "" {
+			return command
+		}
+	}
+	return ""
+}
+
+// SyncUserProfileCache writes the current user's theme slot under users/<username>/
+// without modifying greetd or other system configuration. Requires membership in the
+// greeter group and a prior full greeter setup by an administrator.
+func SyncUserProfileCache(logFunc func(string)) error {
+	if logFunc == nil {
+		logFunc = func(string) {}
+	}
+	if !GreeterProfileSyncReady() {
+		return fmt.Errorf("greeter is not set up on this system yet; an administrator must run 'dms greeter install' or 'dms greeter sync' once first")
+	}
+
+	currentUser, err := user.Current()
+	if err != nil {
+		return fmt.Errorf("failed to resolve current user: %w", err)
+	}
+	if !CanSyncOwnUserGreeterProfile(currentUser.Username) {
+		group := DetectGreeterGroup()
+		return fmt.Errorf("cannot sync greeter profile: you must be in the %s group with write access to %s/users\nAsk an administrator to run:\n  sudo usermod -aG %s %s\nThen log out and back in before running:\n  dms greeter sync --profile",
+			group, GreeterCacheDir, group, currentUser.Username)
+	}
+
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get user home directory: %w", err)
+	}
+
+	state, err := resolveGreeterThemeSyncState(homeDir)
+	if err != nil {
+		return fmt.Errorf("failed to resolve greeter color source: %w", err)
+	}
+
+	if err := syncUserGreeterCacheSlot(homeDir, GreeterCacheDir, currentUser.Username, state, logFunc, userSlotSyncOpts{
+		profileOnly: true,
+	}); err != nil {
+		return err
+	}
+
+	logFunc(fmt.Sprintf("  → %s/users/%s/", GreeterCacheDir, currentUser.Username))
+	return nil
+}
+
+func canWriteUserGreeterCacheSlot(dest, username string) bool {
+	return isUserOwnedGreeterCacheSlot(dest, username) && CanSyncOwnUserGreeterProfile(username)
+}
+
+type userSlotSyncOpts struct {
+	sudoPassword string
+	profileOnly  bool
+	username     string
+}
+
+func (o userSlotSyncOpts) useDirectWrite(dest string) bool {
+	if !o.profileOnly {
+		return false
+	}
+	return canWriteUserGreeterCacheSlot(dest, o.username)
+}
+
+func isGreeterCachePath(path string) bool {
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return true
+	}
+	cacheAbs, err := filepath.Abs(GreeterCacheDir)
+	if err != nil {
+		return true
+	}
+	if abs == cacheAbs {
+		return true
+	}
+	return strings.HasPrefix(abs, cacheAbs+string(filepath.Separator))
+}
+
+func greeterCacheOwner() string {
+	greeterGroup := DetectGreeterGroup()
+	daemonUser := DetectGreeterUser()
+	return daemonUser + ":" + greeterGroup
+}
+
+func ensureGreeterCacheSubdir(dir string, opts userSlotSyncOpts) error {
+	if opts.useDirectWrite(dir) {
+		if err := os.MkdirAll(dir, 0o770); err != nil {
+			return fmt.Errorf("failed to create cache directory %s: %w", dir, err)
+		}
+		return nil
+	}
+
+	if err := privesc.Run(context.Background(), opts.sudoPassword, "mkdir", "-p", dir); err != nil {
+		return fmt.Errorf("failed to create cache directory %s: %w", dir, err)
+	}
+
+	owner := greeterCacheOwner()
+	if err := privesc.Run(context.Background(), opts.sudoPassword, "chown", owner, dir); err != nil {
+		if fallbackErr := privesc.Run(context.Background(), opts.sudoPassword, "chown", "root:"+DetectGreeterGroup(), dir); fallbackErr != nil {
+			return fmt.Errorf("failed to set ownership on %s: %w", dir, err)
+		}
+	}
+	if err := privesc.Run(context.Background(), opts.sudoPassword, "chmod", "2770", dir); err != nil {
+		return fmt.Errorf("failed to set permissions on %s: %w", dir, err)
+	}
+	return nil
+}
+
+func setGreeterCacheFileOwnership(path, sudoPassword string) error {
+	owner := greeterCacheOwner()
+	if err := privesc.Run(context.Background(), sudoPassword, "chown", owner, path); err != nil {
+		if fallbackErr := privesc.Run(context.Background(), sudoPassword, "chown", "root:"+DetectGreeterGroup(), path); fallbackErr != nil {
+			return fmt.Errorf("failed to set ownership on %s: %w", path, err)
+		}
+	}
+	if err := privesc.Run(context.Background(), sudoPassword, "chmod", "644", path); err != nil {
+		return fmt.Errorf("failed to set permissions on %s: %w", path, err)
+	}
+	return nil
+}
+
+func syncUserGreeterCacheSlot(homeDir, cacheDir, username string, state greeterThemeSyncState, logFunc func(string), opts userSlotSyncOpts) error {
+	if strings.TrimSpace(username) == "" {
+		return nil
+	}
+	opts.username = username
+
+	userDir := userGreeterCacheDir(cacheDir, username)
+	if err := ensureGreeterCacheSubdir(userDir, opts); err != nil {
+		return err
+	}
+
+	settingsPath := filepath.Join(homeDir, ".config", "DankMaterialShell", "settings.json")
+	settingsBytes, err := os.ReadFile(settingsPath)
+	if err != nil {
+		return fmt.Errorf("failed to read settings for user cache slot: %w", err)
+	}
+
+	settingsMap := map[string]any{}
+	if strings.TrimSpace(string(settingsBytes)) != "" {
+		if err := json.Unmarshal(settingsBytes, &settingsMap); err != nil {
+			return fmt.Errorf("failed to parse settings for user cache slot: %w", err)
+		}
+	}
+
+	if customTheme, ok := settingsMap["customThemeFile"].(string); ok && strings.TrimSpace(customTheme) != "" {
+		resolvedTheme := customTheme
+		if !filepath.IsAbs(resolvedTheme) {
+			resolvedTheme = filepath.Join(homeDir, resolvedTheme)
+		}
+		if st, statErr := os.Stat(resolvedTheme); statErr == nil && !st.IsDir() {
+			destTheme := filepath.Join(userDir, "custom-theme.json")
+			if err := copyFileWithPrivesc(resolvedTheme, destTheme, opts); err != nil {
+				return err
+			}
+			settingsMap["customThemeFile"] = destTheme
+		}
+	}
+
+	settingsBytes, err = json.Marshal(settingsMap)
+	if err != nil {
+		return fmt.Errorf("failed to marshal settings for user cache slot: %w", err)
+	}
+	if err := writeFileWithPrivesc(filepath.Join(userDir, "settings.json"), settingsBytes, opts); err != nil {
+		return err
+	}
+
+	sessionPath := filepath.Join(homeDir, ".local", "state", "DankMaterialShell", "session.json")
+	sessionBytes, err := os.ReadFile(sessionPath)
+	if err != nil {
+		return fmt.Errorf("failed to read session for user cache slot: %w", err)
+	}
+
+	sessionMap := map[string]any{}
+	if strings.TrimSpace(string(sessionBytes)) != "" {
+		if err := json.Unmarshal(sessionBytes, &sessionMap); err != nil {
+			return fmt.Errorf("failed to parse session for user cache slot: %w", err)
+		}
+	}
+
+	if err := localizeSessionWallpapers(sessionMap, userDir, opts); err != nil {
+		return err
+	}
+
+	sessionBytes, err = json.Marshal(sessionMap)
+	if err != nil {
+		return fmt.Errorf("failed to marshal session for user cache slot: %w", err)
+	}
+	if err := writeFileWithPrivesc(filepath.Join(userDir, "session.json"), sessionBytes, opts); err != nil {
+		return err
+	}
+
+	colorsSource := state.effectiveColorsSource(homeDir)
+	if err := copyFileWithPrivesc(colorsSource, filepath.Join(userDir, "colors.json"), opts); err != nil {
+		return fmt.Errorf("failed to copy colors for user cache slot: %w", err)
+	}
+
+	if err := syncUserProfileImage(homeDir, userDir, opts); err != nil {
+		return err
+	}
+
+	rootOverride := filepath.Join(cacheDir, "greeter_wallpaper_override.jpg")
+	userOverride := filepath.Join(userDir, "greeter_wallpaper_override.jpg")
+	if st, statErr := os.Stat(rootOverride); statErr == nil && !st.IsDir() {
+		if err := copyFileWithPrivesc(rootOverride, userOverride, opts); err != nil {
+			return fmt.Errorf("failed to copy greeter wallpaper override for user cache slot: %w", err)
+		}
+	} else if opts.useDirectWrite(userOverride) {
+		_ = os.Remove(userOverride)
+	} else {
+		_ = privesc.Run(context.Background(), opts.sudoPassword, "rm", "-f", userOverride)
+	}
+
+	logFunc(fmt.Sprintf("✓ Synced per-user greeter cache for %s", username))
+	return nil
+}
+
+func localizeSessionWallpapers(session map[string]any, userDir string, opts userSlotSyncOpts) error {
+	stringKeys := []struct {
+		key    string
+		prefix string
+	}{
+		{"wallpaperPath", "wallpaper"},
+		{"wallpaperPathLight", "wallpaper-light"},
+		{"wallpaperPathDark", "wallpaper-dark"},
+	}
+	for _, item := range stringKeys {
+		if err := localizeWallpaperStringField(session, item.key, userDir, item.prefix, opts); err != nil {
+			return err
+		}
+	}
+
+	mapKeys := []struct {
+		key    string
+		prefix string
+	}{
+		{"monitorWallpapers", "wallpaper-monitor"},
+		{"monitorWallpapersLight", "wallpaper-monitor-light"},
+		{"monitorWallpapersDark", "wallpaper-monitor-dark"},
+	}
+	for _, item := range mapKeys {
+		if err := localizeWallpaperMapField(session, item.key, userDir, item.prefix, opts); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func localizeWallpaperStringField(session map[string]any, key, userDir, prefix string, opts userSlotSyncOpts) error {
+	raw, ok := session[key]
+	if !ok {
+		return nil
+	}
+	path, ok := raw.(string)
+	if !ok || strings.TrimSpace(path) == "" {
+		return nil
+	}
+	dest, err := copyWallpaperIntoUserCache(path, userDir, prefix, opts)
+	if err != nil {
+		return err
+	}
+	if dest != "" {
+		session[key] = dest
+	}
+	return nil
+}
+
+func localizeWallpaperMapField(session map[string]any, key, userDir, prefix string, opts userSlotSyncOpts) error {
+	raw, ok := session[key]
+	if !ok || raw == nil {
+		return nil
+	}
+	values, ok := raw.(map[string]any)
+	if !ok {
+		return nil
+	}
+	for monitor, rawPath := range values {
+		path, ok := rawPath.(string)
+		if !ok || strings.TrimSpace(path) == "" {
+			continue
+		}
+		safeMonitor := monitorWallpaperSanitizer.ReplaceAllString(monitor, "-")
+		dest, err := copyWallpaperIntoUserCache(path, userDir, prefix+"-"+safeMonitor, opts)
+		if err != nil {
+			return err
+		}
+		if dest != "" {
+			values[monitor] = dest
+		}
+	}
+	return nil
+}
+
+func copyWallpaperIntoUserCache(srcPath, userDir, prefix string, opts userSlotSyncOpts) (string, error) {
+	if strings.TrimSpace(srcPath) == "" {
+		return "", nil
+	}
+	st, err := os.Stat(srcPath)
+	if err != nil || st.IsDir() {
+		return "", nil
+	}
+	ext := filepath.Ext(srcPath)
+	if ext == "" {
+		ext = ".jpg"
+	}
+	dest := filepath.Join(userDir, prefix+ext)
+	if err := copyFileWithPrivesc(srcPath, dest, opts); err != nil {
+		return "", err
+	}
+	return dest, nil
+}
+
+func copyFileWithPrivesc(src, dest string, opts userSlotSyncOpts) error {
+	if opts.useDirectWrite(dest) {
+		if err := os.MkdirAll(filepath.Dir(dest), 0o770); err != nil {
+			return fmt.Errorf("failed to create parent dir for %s: %w", dest, err)
+		}
+		data, err := os.ReadFile(src)
+		if err != nil {
+			return fmt.Errorf("failed to read %s: %w", src, err)
+		}
+		if err := os.WriteFile(dest, data, 0o644); err != nil {
+			return fmt.Errorf("failed to write %s: %w", dest, err)
+		}
+		return nil
+	}
+
+	if !isGreeterCachePath(dest) {
+		if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+			return fmt.Errorf("failed to create parent dir for %s: %w", dest, err)
+		}
+		data, err := os.ReadFile(src)
+		if err != nil {
+			return fmt.Errorf("failed to read %s: %w", src, err)
+		}
+		if err := os.WriteFile(dest, data, 0o644); err != nil {
+			return fmt.Errorf("failed to write %s: %w", dest, err)
+		}
+		return nil
+	}
+
+	_ = privesc.Run(context.Background(), opts.sudoPassword, "rm", "-f", dest)
+	if err := privesc.Run(context.Background(), opts.sudoPassword, "cp", src, dest); err != nil {
+		return fmt.Errorf("failed to copy %s to %s: %w", src, dest, err)
+	}
+	return setGreeterCacheFileOwnership(dest, opts.sudoPassword)
+}
+
+func writeFileWithPrivesc(path string, data []byte, opts userSlotSyncOpts) error {
+	if opts.useDirectWrite(path) {
+		if err := os.MkdirAll(filepath.Dir(path), 0o770); err != nil {
+			return fmt.Errorf("failed to create parent dir for %s: %w", path, err)
+		}
+		if err := os.WriteFile(path, data, 0o644); err != nil {
+			return fmt.Errorf("failed to write %s: %w", path, err)
+		}
+		return nil
+	}
+
+	if !isGreeterCachePath(path) {
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			return fmt.Errorf("failed to create parent dir for %s: %w", path, err)
+		}
+		if err := os.WriteFile(path, data, 0o644); err != nil {
+			return fmt.Errorf("failed to write %s: %w", path, err)
+		}
+		return nil
+	}
+
+	tmp, err := os.CreateTemp("", "dms-greeter-user-cache-*")
+	if err != nil {
+		return fmt.Errorf("failed to create temp file for %s: %w", path, err)
+	}
+	tmpPath := tmp.Name()
+	if _, err := tmp.Write(data); err != nil {
+		_ = tmp.Close()
+		_ = os.Remove(tmpPath)
+		return fmt.Errorf("failed to write temp file for %s: %w", path, err)
+	}
+	if err := tmp.Close(); err != nil {
+		_ = os.Remove(tmpPath)
+		return fmt.Errorf("failed to close temp file for %s: %w", path, err)
+	}
+	defer os.Remove(tmpPath)
+
+	_ = privesc.Run(context.Background(), opts.sudoPassword, "rm", "-f", path)
+	if err := privesc.Run(context.Background(), opts.sudoPassword, "cp", tmpPath, path); err != nil {
+		return fmt.Errorf("failed to install %s: %w", path, err)
+	}
+	return setGreeterCacheFileOwnership(path, opts.sudoPassword)
+}
+
+func resolveUserProfileImageSource(homeDir string) string {
+	candidates := []string{
+		filepath.Join(homeDir, ".face"),
+		filepath.Join(homeDir, ".face.icon"),
+	}
+	if homeDir != "" {
+		username := filepath.Base(homeDir)
+		if username != "" && username != "." && username != string(filepath.Separator) {
+			candidates = append([]string{filepath.Join("/var/lib/AccountsService/icons", username)}, candidates...)
+		}
+	}
+	for _, src := range candidates {
+		st, err := os.Stat(src)
+		if err == nil && !st.IsDir() && st.Size() > 0 {
+			return src
+		}
+	}
+	return ""
+}
+
+func syncUserProfileImage(homeDir, userDir string, opts userSlotSyncOpts) error {
+	for _, name := range []string{"profile.jpg", "profile.jpeg", "profile.png", "profile.webp"} {
+		path := filepath.Join(userDir, name)
+		if opts.useDirectWrite(path) {
+			_ = os.Remove(path)
+		} else {
+			_ = privesc.Run(context.Background(), opts.sudoPassword, "rm", "-f", path)
+		}
+	}
+
+	src := resolveUserProfileImageSource(homeDir)
+	if src == "" {
+		return nil
+	}
+
+	ext := filepath.Ext(src)
+	if ext == "" {
+		ext = ".jpg"
+	}
+	dest := filepath.Join(userDir, "profile"+ext)
+	if err := copyFileWithPrivesc(src, dest, opts); err != nil {
+		return fmt.Errorf("failed to copy profile image for user cache slot: %w", err)
+	}
+	return nil
+}

core/internal/greeter/user_cache_sync_test.go

@@ -0,0 +1,81 @@
+package greeter
+
+import (
+	"path/filepath"
+	"testing"
+)
+
+func TestUserGreeterCacheDir(t *testing.T) {
+	t.Parallel()
+
+	got := userGreeterCacheDir("/var/cache/dms-greeter", "alice")
+	want := filepath.Join("/var/cache/dms-greeter", "users", "alice")
+	if got != want {
+		t.Fatalf("userGreeterCacheDir() = %q, want %q", got, want)
+	}
+}
+
+func TestResolveUserProfileImageSource(t *testing.T) {
+	t.Parallel()
+
+	homeDir := t.TempDir()
+	facePath := filepath.Join(homeDir, ".face")
+	writeTestFile(t, facePath, "face")
+
+	got := resolveUserProfileImageSource(homeDir)
+	if got != facePath {
+		t.Fatalf("resolveUserProfileImageSource() = %q, want %q", got, facePath)
+	}
+}
+
+func TestIsUserOwnedGreeterCacheSlot(t *testing.T) {
+	t.Parallel()
+
+	slot := filepath.Join(GreeterCacheDir, "users", "alice", "settings.json")
+	if !isUserOwnedGreeterCacheSlot(slot, "alice") {
+		t.Fatalf("expected alice to own %q", slot)
+	}
+	if isUserOwnedGreeterCacheSlot(slot, "bob") {
+		t.Fatalf("expected bob not to own alice slot")
+	}
+	if isUserOwnedGreeterCacheSlot(filepath.Join(GreeterCacheDir, "settings.json"), "alice") {
+		t.Fatalf("expected root cache file not to be a user slot")
+	}
+}
+
+func TestLocalizeSessionWallpapers(t *testing.T) {
+	t.Parallel()
+
+	homeDir := t.TempDir()
+	userDir := filepath.Join(homeDir, "users", "alice")
+	wallpaperPath := filepath.Join(homeDir, "wall.jpg")
+	writeTestFile(t, wallpaperPath, "wallpaper")
+
+	session := map[string]any{
+		"wallpaperPath": wallpaperPath,
+		"monitorWallpapers": map[string]any{
+			"DP-1": wallpaperPath,
+		},
+	}
+
+	if err := localizeSessionWallpapers(session, userDir, userSlotSyncOpts{}); err != nil {
+		t.Fatalf("localizeSessionWallpapers returned error: %v", err)
+	}
+
+	gotPath, ok := session["wallpaperPath"].(string)
+	if !ok || gotPath == "" {
+		t.Fatalf("expected localized wallpaperPath, got %#v", session["wallpaperPath"])
+	}
+	if gotPath == wallpaperPath {
+		t.Fatalf("expected copied wallpaper path, still points to source")
+	}
+
+	monitorMap, ok := session["monitorWallpapers"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected monitorWallpapers map")
+	}
+	monitorPath, ok := monitorMap["DP-1"].(string)
+	if !ok || monitorPath == "" || monitorPath == wallpaperPath {
+		t.Fatalf("expected localized monitor wallpaper, got %#v", monitorMap["DP-1"])
+	}
+}

core/internal/headless/runner.go

@@ -364,8 +364,10 @@ func (r *Runner) parseWindowManager() (deps.WindowManager, error) {
 		return deps.WindowManagerNiri, nil
 	case "hyprland":
 		return deps.WindowManagerHyprland, nil
+	case "mango", "mangowc":
+		return deps.WindowManagerMango, nil
 	default:
-		return 0, fmt.Errorf("invalid --compositor value %q: must be 'niri' or 'hyprland'", r.cfg.Compositor)
+		return 0, fmt.Errorf("invalid --compositor value %q: must be 'niri', 'hyprland', or 'mango'", r.cfg.Compositor)
 	}
 }
 

core/internal/keybinds/providers/hyprland_parser_test.go

@@ -3,7 +3,10 @@ package providers
 import (
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
 )
 
 func TestHyprlandAutogenerateComment(t *testing.T) {
@@ -60,6 +63,599 @@ func TestHyprlandAutogenerateComment(t *testing.T) {
 	}
 }
 
+func TestHyprlandLuaBindRoundTripHelpers(t *testing.T) {
+	tests := []struct {
+		expr           string
+		wantDispatcher string
+		wantParams     string
+	}{
+		{`hl.dsp.exec_cmd([[dms ipc call brightness increment 5 ""]])`, "exec", `dms ipc call brightness increment 5 ""`},
+		{`hl.dsp.exec_cmd([[hyprctl dispatch workspace 1]])`, "workspace", "1"},
+		{`hl.dispatch("workspace 2")`, "workspace", "2"},
+		{`hl.dispatch([[customdispatcher arg one]])`, "customdispatcher", "arg one"},
+		{`hl.dsp.window.fullscreen({ mode = "maximized", action = "toggle" })`, "fullscreen", "1"},
+		{`hl.dsp.window.float({ action = "on" })`, "setfloating", ""},
+		{`hl.dsp.window.close()`, "killactive", ""},
+		{`hl.dsp.window.kill()`, "forcekillactive", ""},
+		{`hl.dsp.window.close({ window = "class:^(kitty)$" })`, "closewindow", "class:^(kitty)$"},
+		{`hl.dsp.focus({ workspace = "e+1" })`, "workspace", "e+1"},
+		{`hl.dsp.focus({ workspace = "2", on_current_monitor = true })`, "focusworkspaceoncurrentmonitor", "2"},
+		{`hl.dsp.window.move({ monitor = "l" })`, "movewindow", "mon:l"},
+		{`hl.dsp.window.move({ direction = "r", group_aware = true })`, "movewindoworgroup", "r"},
+		{`hl.dsp.window.move({ into_group = "l" })`, "moveintogroup", "l"},
+		{`hl.dsp.window.move({ out_of_group = true })`, "moveoutofgroup", ""},
+		{`hl.dsp.window.move({ workspace = "special:magic", follow = false })`, "movetoworkspacesilent", "special:magic"},
+		{`hl.dsp.window.resize({ x = -100, y = 0, relative = true })`, "resizeactive", "-100 0"},
+		{`hl.dsp.window.resize({ x = 1280, y = 720, relative = false })`, "resizeactive", "exact 1280 720"},
+		{`hl.dsp.window.resize({ x = 100, y = 50, relative = true, window = "class:^(app)$" })`, "resizewindowpixel", "100 50,class:^(app)$"},
+		{`hl.dsp.window.cycle_next({ next = false, tiled = true })`, "cyclenext", "prev tiled"},
+		{`hl.dsp.group.next()`, "changegroupactive", "f"},
+		{`hl.dsp.group.prev()`, "changegroupactive", "b"},
+		{`hl.dsp.group.active({ index = 2 })`, "changegroupactive", "2"},
+		{`hl.dsp.group.move_window({ forward = false })`, "movegroupwindow", "b"},
+		{`hl.dsp.group.lock({ action = "on" })`, "lockgroups", "lock"},
+		{`hl.dsp.group.lock_active({ action = "off" })`, "lockactivegroup", "unlock"},
+		{`hl.dsp.window.deny_from_group({ action = "toggle" })`, "denywindowfromgroup", "toggle"},
+		{`function() hl.exec_cmd("hyprctl dispatch splitratio +0.1") end`, "splitratio", "+0.1"},
+		{`hl.dsp.layout("togglesplit")`, "layoutmsg", "togglesplit"},
+		{`hl.dsp.dpms({ action = "toggle" })`, "dpms", "toggle"},
+		{`hl.dsp.workspace.rename({ workspace = "1", name = "work" })`, "renameworkspace", "1 work"},
+		{`hl.dsp.no_op()`, "hl.dsp.no_op()", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			gotDispatcher, gotParams := luaExprToDispatcherParams(tt.expr)
+			if gotDispatcher != tt.wantDispatcher || gotParams != tt.wantParams {
+				t.Fatalf("luaExprToDispatcherParams() = %q, %q; want %q, %q", gotDispatcher, gotParams, tt.wantDispatcher, tt.wantParams)
+			}
+		})
+	}
+}
+
+func TestWriteLuaBindLineOptionsInsideCall(t *testing.T) {
+	var sb strings.Builder
+	writeLuaBindLine(&sb, &hyprlandOverrideBind{
+		Key:         "Super+k",
+		Action:      "exec kitty",
+		Description: "Open terminal",
+		Flags:       "led",
+	})
+
+	want := `hl.unbind("SUPER + K")
+hl.bind("SUPER + K", hl.dsp.exec_cmd("kitty"), { locked = true, repeating = true, description = "Open terminal" })`
+	if got := strings.TrimSpace(sb.String()); got != want {
+		t.Fatalf("writeLuaBindLine() = %q, want %q", got, want)
+	}
+}
+
+func TestWriteLuaBindLineMapsSpawnActionForHyprland(t *testing.T) {
+	var sb strings.Builder
+	writeLuaBindLine(&sb, &hyprlandOverrideBind{
+		Key:         "Super+n",
+		Action:      "spawn dms ipc call notepad toggle",
+		Description: "Notepad: Toggle",
+	})
+
+	want := `hl.unbind("SUPER + N")
+hl.bind("SUPER + N", hl.dsp.exec_cmd("dms ipc call notepad toggle"), { description = "Notepad: Toggle" })`
+	if got := strings.TrimSpace(sb.String()); got != want {
+		t.Fatalf("writeLuaBindLine() = %q, want %q", got, want)
+	}
+}
+
+func TestWriteLuaBindLineLeavesCustomLuaDispatcherRaw(t *testing.T) {
+	var sb strings.Builder
+	writeLuaBindLine(&sb, &hyprlandOverrideBind{
+		Key:         "Super+u",
+		Action:      "hl.dsp.no_op()",
+		Description: "Custom Lua",
+	})
+
+	want := `hl.unbind("SUPER + U")
+hl.bind("SUPER + U", hl.dsp.no_op(), { description = "Custom Lua" })`
+	if got := strings.TrimSpace(sb.String()); got != want {
+		t.Fatalf("writeLuaBindLine() = %q, want %q", got, want)
+	}
+}
+
+func TestLuaActionStringFromHyprlangActionUsesNativeDispatchers(t *testing.T) {
+	tests := []struct {
+		action string
+		want   string
+	}{
+		{"killactive", `hl.dsp.window.close()`},
+		{"forcekillactive", `hl.dsp.window.kill()`},
+		{"workspace 1", `hl.dsp.focus({ workspace = "1" })`},
+		{"movetoworkspace 2", `hl.dsp.window.move({ workspace = "2" })`},
+		{"movetoworkspacesilent special:magic", `hl.dsp.window.move({ workspace = "special:magic", follow = false })`},
+		{"focusmonitor DP-1", `hl.dsp.focus({ monitor = "DP-1" })`},
+		{"resizeactive exact 1280 720", `hl.dsp.window.resize({ x = 1280, y = 720, relative = false })`},
+		{"dpms toggle", `hl.dsp.dpms({ action = "toggle" })`},
+		{"renameworkspace 1 work", `hl.dsp.workspace.rename({ workspace = "1", name = "work" })`},
+		{"changegroupactive f", `hl.dsp.group.next()`},
+		{"changegroupactive b", `hl.dsp.group.prev()`},
+		{"changegroupactive 2", `hl.dsp.group.active({ index = 2 })`},
+		{"moveintogroup l", `hl.dsp.window.move({ into_group = "l" })`},
+		{"moveoutofgroup", `hl.dsp.window.move({ out_of_group = true })`},
+		{"movewindoworgroup r", `hl.dsp.window.move({ direction = "r", group_aware = true })`},
+		{"movegroupwindow b", `hl.dsp.group.move_window({ forward = false })`},
+		{"lockgroups lock", `hl.dsp.group.lock({ action = "on" })`},
+		{"lockactivegroup unlock", `hl.dsp.group.lock_active({ action = "off" })`},
+		{"denywindowfromgroup toggle", `hl.dsp.window.deny_from_group({ action = "toggle" })`},
+		{"cyclenext prev", `hl.dsp.window.cycle_next({ next = false })`},
+		{"setfloating", `hl.dsp.window.float({ action = "on" })`},
+		{"settiled", `hl.dsp.window.float({ action = "off" })`},
+		{"bringactivetotop", `hl.dsp.window.bring_to_top()`},
+		{"toggleswallow", `hl.dsp.window.toggle_swallow()`},
+		{"forceidle 300", `hl.dsp.force_idle(300)`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.action, func(t *testing.T) {
+			got := luaActionStringFromHyprlangAction(tt.action)
+			if got != tt.want {
+				t.Fatalf("luaActionStringFromHyprlangAction(%q) = %q, want %q", tt.action, got, tt.want)
+			}
+			if strings.Contains(got, "hyprctl dispatch") {
+				t.Fatalf("expected native Lua dispatcher, got legacy dispatch wrapper: %q", got)
+			}
+		})
+	}
+}
+
+func TestLuaActionStringFallsBackForUnsupportedResizePercentages(t *testing.T) {
+	got := luaActionStringFromHyprlangAction("resizeactive exact 100% 100%")
+	want := `function() hl.exec_cmd("hyprctl dispatch resizeactive exact 100% 100%") end`
+	if got != want {
+		t.Fatalf("luaActionStringFromHyprlangAction() = %q, want %q", got, want)
+	}
+}
+
+func TestParseLuaBindLineHandlesFunctionDispatcherFallback(t *testing.T) {
+	line := `hl.bind("SUPER + R", function() hl.exec_cmd("hyprctl dispatch resizeactive exact 100% 100%") end, { description = "Unsupported Resize" })`
+	got, ok := parseLuaBindOverrideLine(line)
+	if !ok {
+		t.Fatalf("expected line to parse")
+	}
+	if got.Action != "resizeactive exact 100% 100%" {
+		t.Fatalf("Action = %q, want resizeactive exact 100%% 100%%", got.Action)
+	}
+	if got.Description != "Unsupported Resize" {
+		t.Fatalf("Description = %q, want Unsupported Resize", got.Description)
+	}
+}
+
+func TestLuaActionStringLeavesCustomLuaDispatcherRaw(t *testing.T) {
+	got := luaActionStringFromHyprlangAction("hl.dsp.no_op()")
+	want := `hl.dsp.no_op()`
+	if got != want {
+		t.Fatalf("luaActionStringFromHyprlangAction() = %q, want %q", got, want)
+	}
+	if strings.Contains(got, "hl.dispatch") || strings.Contains(got, "hyprctl dispatch") {
+		t.Fatalf("expected custom Lua dispatcher expression to stay raw, got %q", got)
+	}
+}
+
+func TestReadLuaOverrideMigratesTrailingCommentToDescription(t *testing.T) {
+	tmpDir := t.TempDir()
+	overridePath := filepath.Join(tmpDir, "binds-user.lua")
+	contents := `hl.unbind("SUPER + N")
+hl.bind("SUPER + N", hl.dsp.exec_cmd("dms ipc call notepad toggle")) -- Notepad: Toggle
+hl.bind("SUPER + H", hl.dsp.exec_cmd("app --help"))
+`
+	if err := os.WriteFile(overridePath, []byte(contents), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	binds, err := readLuaOrHyprlangOverride(overridePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := binds["super+n"]
+	if got == nil {
+		t.Fatalf("expected SUPER+N override, got %#v", binds)
+	}
+	if got.Description != "Notepad: Toggle" {
+		t.Fatalf("expected trailing comment to be preserved as description, got %q", got.Description)
+	}
+	if got := binds["super+h"]; got == nil || got.Description != "" {
+		t.Fatalf("expected -- inside a Lua string to stay out of the description, got %#v", got)
+	}
+}
+
+func TestHyprlandLuaBindsUserOverridesDefaults(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(tmpDir, "hyprland.lua"), []byte(`
+require("dms.binds")
+require("dms.binds-user")
+`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds.lua"), []byte(`hl.bind("SUPER + T", hl.dsp.exec_cmd("kitty"))`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds-user.lua"), []byte(`hl.bind("SUPER + T", hl.dsp.exec_cmd("foot"), { description = "User terminal" })`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := ParseHyprlandKeysWithDMS(tmpDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var found []HyprlandKeyBinding
+	var walk func(HyprlandSection)
+	walk = func(section HyprlandSection) {
+		for _, kb := range section.Keybinds {
+			if strings.EqualFold(strings.Join(append(kb.Mods, kb.Key), "+"), "SUPER+T") {
+				found = append(found, kb)
+			}
+		}
+		for _, child := range section.Children {
+			walk(child)
+		}
+	}
+	walk(*result.Section)
+
+	if len(found) != 1 {
+		t.Fatalf("expected one effective SUPER+T bind, got %d: %#v", len(found), found)
+	}
+	if found[0].Params != "foot" || found[0].Comment != "User terminal" {
+		t.Fatalf("expected user override bind, got %#v", found[0])
+	}
+}
+
+func TestWriteLuaBindLineEmitsUnbindOnlyForNegativeOverride(t *testing.T) {
+	var sb strings.Builder
+	writeLuaBindLine(&sb, &hyprlandOverrideBind{Key: "Super+i", Unbind: true})
+
+	want := `hl.unbind("SUPER + I")`
+	if got := strings.TrimSpace(sb.String()); got != want {
+		t.Fatalf("writeLuaBindLine() = %q, want %q", got, want)
+	}
+}
+
+func TestReadLuaOverrideRecognizesLoneUnbindAsNegativeOverride(t *testing.T) {
+	tmpDir := t.TempDir()
+	overridePath := filepath.Join(tmpDir, "binds-user.lua")
+	contents := `-- DMS user keybind overrides
+hl.unbind("SUPER + I")
+hl.unbind("SUPER + N")
+hl.bind("SUPER + N", hl.dsp.exec_cmd("dms ipc call notepad toggle"))
+`
+	if err := os.WriteFile(overridePath, []byte(contents), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	binds, err := readLuaOrHyprlangOverride(overridePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	got, ok := binds["super+i"]
+	if !ok {
+		t.Fatalf("expected SUPER+I entry in override map, got: %#v", binds)
+	}
+	if !got.Unbind {
+		t.Fatalf("expected SUPER+I to be marked Unbind, got: %#v", got)
+	}
+	if rebind, ok := binds["super+n"]; !ok || rebind.Unbind {
+		t.Fatalf("expected SUPER+N to be a normal rebind override, got: %#v", rebind)
+	}
+}
+
+func TestParserDropsDMSDefaultsSuppressedByBindsUserUnbind(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(tmpDir, "hyprland.lua"), []byte(`
+require("dms.binds")
+require("dms.binds-user")
+`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds.lua"), []byte(
+		`hl.bind("SUPER + I", hl.dsp.focus({ workspace = "e-1" }))
+hl.bind("SUPER + T", hl.dsp.exec_cmd("kitty"))`,
+	), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds-user.lua"), []byte(`hl.unbind("SUPER + I")`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := ParseHyprlandKeysWithDMS(tmpDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var keys []string
+	var walk func(HyprlandSection)
+	walk = func(section HyprlandSection) {
+		for _, kb := range section.Keybinds {
+			keys = append(keys, strings.ToUpper(strings.Join(append(kb.Mods, kb.Key), "+")))
+		}
+		for _, child := range section.Children {
+			walk(child)
+		}
+	}
+	walk(*result.Section)
+
+	for _, k := range keys {
+		if k == "SUPER+I" {
+			t.Fatalf("expected SUPER+I to be suppressed by binds-user.lua unbind, got: %v", keys)
+		}
+	}
+	foundT := false
+	for _, k := range keys {
+		if k == "SUPER+T" {
+			foundT = true
+		}
+	}
+	if !foundT {
+		t.Fatalf("expected SUPER+T to remain (only SUPER+I was unbound), got: %v", keys)
+	}
+}
+
+func TestHyprlandRemoveBindWritesNegativeOverrideForDefault(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	provider := NewHyprlandProvider(tmpDir)
+	if err := provider.RemoveBind("SUPER+I"); err != nil {
+		t.Fatal(err)
+	}
+
+	data, err := os.ReadFile(filepath.Join(dmsDir, "binds-user.lua"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(data), `hl.unbind("SUPER + I")`) {
+		t.Fatalf("expected negative override hl.unbind line, got:\n%s", string(data))
+	}
+	if strings.Contains(string(data), `hl.bind("SUPER + I"`) {
+		t.Fatalf("expected NO hl.bind for SUPER+I, got:\n%s", string(data))
+	}
+}
+
+func TestHyprlandSetBindLeavesConfOnlyInstallReadOnly(t *testing.T) {
+	tmpDir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(tmpDir, "hyprland.conf"), []byte("bind = SUPER, T, exec, kitty\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	provider := NewHyprlandProvider(tmpDir)
+	err := provider.SetBind("SUPER+N", "workspace 1", "Workspace 1", nil)
+	if err == nil {
+		t.Fatal("expected SetBind to reject conf-only Hyprland config")
+	}
+	if !strings.Contains(err.Error(), "read-only") {
+		t.Fatalf("expected read-only error, got %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(tmpDir, "dms", "binds-user.lua")); !os.IsNotExist(err) {
+		t.Fatalf("expected no Lua override to be created for conf-only config, stat err=%v", err)
+	}
+}
+
+func TestHyprlandSetBindUpdatesSpacedLuaOverrideWithoutDuplicates(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	override := `-- DMS user keybind overrides
+
+hl.unbind("SUPER + SHIFT + S")
+hl.bind("SUPER + 1", hl.dsp.exec_cmd("hyprctl dispatch workspace 1"))
+`
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds-user.lua"), []byte(override), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	provider := NewHyprlandProvider(tmpDir)
+	if err := provider.SetBind("SUPER + 1", "workspace 1", "", nil); err != nil {
+		t.Fatal(err)
+	}
+
+	data, err := os.ReadFile(filepath.Join(dmsDir, "binds-user.lua"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := string(data)
+	if strings.Count(got, `hl.unbind("SUPER + 1")`) != 1 {
+		t.Fatalf("expected one SUPER+1 unbind, got:\n%s", got)
+	}
+	if strings.Count(got, `hl.bind("SUPER + 1", hl.dsp.focus({ workspace = "1" }))`) != 1 {
+		t.Fatalf("expected one native SUPER+1 bind, got:\n%s", got)
+	}
+	if strings.Contains(got, "hyprctl dispatch workspace 1") {
+		t.Fatalf("expected old hyprctl workspace dispatcher to be replaced, got:\n%s", got)
+	}
+	if !strings.Contains(got, `hl.unbind("SUPER + SHIFT + S")`) {
+		t.Fatalf("expected unrelated override to be preserved, got:\n%s", got)
+	}
+}
+
+func TestHyprlandSetBindTranslatesScrollWheelToMouse(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	bindsUser := filepath.Join(dmsDir, "binds-user.lua")
+	if err := os.WriteFile(bindsUser, []byte("-- DMS user keybind overrides\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	provider := NewHyprlandProvider(tmpDir)
+	if err := provider.SetBind("SUPER + WheelScrollDown", "workspace 1", "", nil); err != nil {
+		t.Fatal(err)
+	}
+
+	got := readFile(t, bindsUser)
+	if !strings.Contains(got, `hl.bind("SUPER + mouse_down"`) {
+		t.Fatalf("expected scroll key translated to mouse_down, got:\n%s", got)
+	}
+	if strings.Contains(got, "WheelScroll") {
+		t.Fatalf("expected no raw niri scroll keysym in hyprland output, got:\n%s", got)
+	}
+
+	if err := provider.SetBind("SUPER + WheelScrollDown", "workspace 2", "", nil); err != nil {
+		t.Fatal(err)
+	}
+	got = readFile(t, bindsUser)
+	if strings.Count(got, `hl.bind("SUPER + mouse_down"`) != 1 {
+		t.Fatalf("expected exactly one mouse_down bind after re-save, got:\n%s", got)
+	}
+}
+
+func TestHyprlandScrollWheelRoundTrips(t *testing.T) {
+	for native, canonical := range map[string]string{
+		"mouse_up":    "WheelScrollUp",
+		"mouse_down":  "WheelScrollDown",
+		"mouse_left":  "WheelScrollLeft",
+		"mouse_right": "WheelScrollRight",
+	} {
+		if got := luaKeyComboToInternalKey("SUPER + " + native); got != "SUPER+"+canonical {
+			t.Errorf("luaKeyComboToInternalKey(%q) = %q, want SUPER+%s", native, got, canonical)
+		}
+	}
+}
+
+func readFile(t *testing.T, path string) string {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(data)
+}
+
+func TestHyprlandRemoveBindReplacesExistingOverrideWithNegativeOverride(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	override := `hl.unbind("SUPER + N")
+hl.bind("SUPER + N", hl.dsp.exec_cmd("dms ipc call notepad toggle"))
+`
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds-user.lua"), []byte(override), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	provider := NewHyprlandProvider(tmpDir)
+	if err := provider.RemoveBind("SUPER+N"); err != nil {
+		t.Fatal(err)
+	}
+
+	data, err := os.ReadFile(filepath.Join(dmsDir, "binds-user.lua"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(data), `hl.unbind("SUPER + N")`) {
+		t.Fatalf("expected negative override hl.unbind line, got:\n%s", string(data))
+	}
+	if strings.Contains(string(data), `hl.bind("SUPER + N"`) {
+		t.Fatalf("expected NO hl.bind for SUPER+N after remove, got:\n%s", string(data))
+	}
+}
+
+func TestHyprlandResetBindRevertsExistingOverrideToDefault(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	override := `hl.unbind("SUPER + N")
+hl.bind("SUPER + N", hl.dsp.exec_cmd("dms ipc call notepad toggle"))
+`
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds-user.lua"), []byte(override), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	provider := NewHyprlandProvider(tmpDir)
+	if err := provider.ResetBind("SUPER+N"); err != nil {
+		t.Fatal(err)
+	}
+
+	data, err := os.ReadFile(filepath.Join(dmsDir, "binds-user.lua"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(data), `SUPER + N`) {
+		t.Fatalf("expected SUPER+N to be fully removed (revert to default), got:\n%s", string(data))
+	}
+}
+
+func TestHyprlandHasDefaultSetForOverrideOfDefaultKey(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(tmpDir, "hyprland.lua"), []byte(`
+require("dms.binds")
+require("dms.binds-user")
+`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds.lua"), []byte(
+		`hl.bind("SUPER + T", hl.dsp.exec_cmd("kitty"))`,
+	), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds-user.lua"), []byte(
+		`hl.unbind("SUPER + T")
+hl.bind("SUPER + T", hl.dsp.exec_cmd("foot"))
+hl.bind("SUPER + Z", hl.dsp.exec_cmd("custom"))`,
+	), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	provider := NewHyprlandProvider(tmpDir)
+	sheet, err := provider.GetCheatSheet()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var foundT, foundZ *keybinds.Keybind
+	for _, group := range sheet.Binds {
+		for i := range group {
+			kb := group[i]
+			keyUpper := strings.ToUpper(kb.Key)
+			if keyUpper == "SUPER+T" {
+				foundT = &group[i]
+			}
+			if keyUpper == "SUPER+Z" {
+				foundZ = &group[i]
+			}
+		}
+	}
+	if foundT == nil {
+		t.Fatalf("expected SUPER+T override in cheatsheet")
+	}
+	if !foundT.HasDefault {
+		t.Fatalf("expected SUPER+T HasDefault=true (default exists in binds.lua), got %+v", foundT)
+	}
+	if foundZ == nil {
+		t.Fatalf("expected SUPER+Z (user-only) in cheatsheet")
+	}
+	if foundZ.HasDefault {
+		t.Fatalf("expected SUPER+Z HasDefault=false (no default), got %+v", foundZ)
+	}
+}
+
 func TestHyprlandGetKeybindAtLine(t *testing.T) {
 	tests := []struct {
 		name     string

core/internal/keybinds/providers/mangowc.go

@@ -7,6 +7,7 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/keybinds"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/utils"
 )
@@ -141,7 +142,7 @@ func (m *MangoWCProvider) convertKeybind(kb *MangoWCKeyBinding, conflicts map[st
 
 	source := "config"
 	if strings.Contains(kb.Source, "dms/binds.conf") || strings.Contains(kb.Source, "dms"+string(filepath.Separator)+"binds.conf") {
-		source = "dms"
+		source = "dms-default"
 	}
 
 	bind := keybinds.Keybind{
@@ -151,7 +152,7 @@ func (m *MangoWCProvider) convertKeybind(kb *MangoWCKeyBinding, conflicts map[st
 		Source:      source,
 	}
 
-	if source == "dms" && conflicts != nil {
+	if source == "dms-default" && conflicts != nil {
 		normalizedKey := strings.ToLower(keyStr)
 		if conflictKb, ok := conflicts[normalizedKey]; ok {
 			bind.Conflict = &keybinds.Keybind{
@@ -228,11 +229,23 @@ func (m *MangoWCProvider) SetBind(key, action, description string, options map[s
 	}
 
 	normalizedKey := strings.ToLower(key)
+	prefix := "bind"
+	if existing, ok := existingBinds[normalizedKey]; ok && existing.Prefix != "" {
+		prefix = existing.Prefix
+	}
+	if optionPrefix := m.bindPrefixFromOptions(options); optionPrefix != "" {
+		prefix = optionPrefix
+	}
+	if _, leaf := m.parseKeyString(key); isScrollKey(leaf) {
+		prefix = mangowcAxisBindPrefix
+	}
+
 	existingBinds[normalizedKey] = &mangowcOverrideBind{
 		Key:         key,
 		Action:      action,
 		Description: description,
 		Options:     options,
+		Prefix:      prefix,
 	}
 
 	return m.writeOverrideBinds(existingBinds)
@@ -246,7 +259,11 @@ func (m *MangoWCProvider) RemoveBind(key string) error {
 
 	normalizedKey := strings.ToLower(key)
 	delete(existingBinds, normalizedKey)
-	return m.writeOverrideBinds(existingBinds)
+	return m.writeOverrideBindsWithRemoved(existingBinds, map[string]bool{normalizedKey: true})
+}
+
+func (m *MangoWCProvider) ResetBind(key string) error {
+	return m.RemoveBind(key)
 }
 
 type mangowcOverrideBind struct {
@@ -254,6 +271,7 @@ type mangowcOverrideBind struct {
 	Action      string
 	Description string
 	Options     map[string]any
+	Prefix      string
 }
 
 func (m *MangoWCProvider) loadOverrideBinds() (map[string]*mangowcOverrideBind, error) {
@@ -268,62 +286,108 @@ func (m *MangoWCProvider) loadOverrideBinds() (map[string]*mangowcOverrideBind,
 		return nil, err
 	}
 
-	lines := strings.Split(string(data), "\n")
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
+	var pendingComment string
+	for _, line := range strings.Split(string(data), "\n") {
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" {
+			pendingComment = ""
+			continue
+		}
+		if strings.HasPrefix(trimmed, "#") {
+			pendingComment = strings.TrimSpace(strings.TrimPrefix(trimmed, "#"))
+			if isMangoWCSectionComment(pendingComment) {
+				pendingComment = ""
+			}
 			continue
 		}
 
-		if !strings.HasPrefix(line, "bind") {
+		bind, ok := m.parseOverrideBindLine(line, pendingComment)
+		pendingComment = ""
+		if !ok || bind == nil {
 			continue
 		}
 
-		parts := strings.SplitN(line, "=", 2)
-		if len(parts) < 2 {
-			continue
-		}
-
-		content := strings.TrimSpace(parts[1])
-		commentParts := strings.SplitN(content, "#", 2)
-		bindContent := strings.TrimSpace(commentParts[0])
-
-		var comment string
-		if len(commentParts) > 1 {
-			comment = strings.TrimSpace(commentParts[1])
-		}
-
-		fields := strings.SplitN(bindContent, ",", 4)
-		if len(fields) < 3 {
-			continue
-		}
-
-		mods := strings.TrimSpace(fields[0])
-		keyName := strings.TrimSpace(fields[1])
-		command := strings.TrimSpace(fields[2])
-
-		var params string
-		if len(fields) > 3 {
-			params = strings.TrimSpace(fields[3])
-		}
-
-		keyStr := m.buildKeyString(mods, keyName)
-		normalizedKey := strings.ToLower(keyStr)
-		action := command
-		if params != "" {
-			action = command + " " + params
-		}
-
-		binds[normalizedKey] = &mangowcOverrideBind{
-			Key:         keyStr,
-			Action:      action,
-			Description: comment,
-		}
+		binds[strings.ToLower(bind.Key)] = bind
 	}
 
 	return binds, nil
 }
 
+func (m *MangoWCProvider) parseOverrideBindLine(line, precedingComment string) (*mangowcOverrideBind, bool) {
+	trimmed := strings.TrimSpace(line)
+	parts := strings.SplitN(trimmed, "=", 2)
+	if len(parts) < 2 {
+		return nil, false
+	}
+
+	prefix := strings.TrimSpace(parts[0])
+	if !m.isBindPrefix(prefix) {
+		return nil, false
+	}
+
+	content := strings.TrimSpace(parts[1])
+	commentParts := strings.SplitN(content, "#", 2)
+	bindContent := strings.TrimSpace(commentParts[0])
+
+	description := strings.TrimSpace(precedingComment)
+	if isMangoWCSectionComment(description) {
+		description = ""
+	}
+	if len(commentParts) > 1 {
+		description = strings.TrimSpace(commentParts[1])
+	}
+	if strings.HasPrefix(description, MangoWCHideComment) {
+		return nil, true
+	}
+
+	fields := strings.SplitN(bindContent, ",", 4)
+	if len(fields) < 3 {
+		return nil, false
+	}
+
+	mods := strings.TrimSpace(fields[0])
+	keyName := strings.TrimSpace(fields[1])
+	command := strings.TrimSpace(fields[2])
+
+	if prefix == mangowcAxisBindPrefix {
+		if canonical, ok := mangowcDirectionToScroll(keyName); ok {
+			keyName = canonical
+		}
+	}
+
+	var params string
+	if len(fields) > 3 {
+		params = strings.TrimSpace(fields[3])
+	}
+
+	action := command
+	if params != "" {
+		action = command + " " + params
+	}
+
+	return &mangowcOverrideBind{
+		Key:         m.buildKeyString(mods, keyName),
+		Action:      action,
+		Description: description,
+		Prefix:      prefix,
+	}, true
+}
+
+func (m *MangoWCProvider) isBindPrefix(prefix string) bool {
+	if prefix == mangowcAxisBindPrefix {
+		return true
+	}
+	if !strings.HasPrefix(prefix, "bind") {
+		return false
+	}
+	for _, ch := range strings.TrimPrefix(prefix, "bind") {
+		if !strings.ContainsRune("lsrp", ch) {
+			return false
+		}
+	}
+	return true
+}
+
 func (m *MangoWCProvider) buildKeyString(mods, key string) string {
 	if mods == "" || strings.EqualFold(mods, "none") {
 		return key
@@ -358,21 +422,113 @@ func (m *MangoWCProvider) getBindSortPriority(action string) int {
 }
 
 func (m *MangoWCProvider) writeOverrideBinds(binds map[string]*mangowcOverrideBind) error {
+	return m.writeOverrideBindsWithRemoved(binds, nil)
+}
+
+func (m *MangoWCProvider) writeOverrideBindsWithRemoved(binds map[string]*mangowcOverrideBind, removed map[string]bool) error {
 	overridePath := m.GetOverridePath()
-	content := m.generateBindsContent(binds)
+	existingContent := ""
+	if data, err := os.ReadFile(overridePath); err == nil {
+		existingContent = string(data)
+	}
+
+	content := m.generatePreservedBindsContent(existingContent, binds, removed)
 	return os.WriteFile(overridePath, []byte(content), 0o644)
 }
 
-func (m *MangoWCProvider) generateBindsContent(binds map[string]*mangowcOverrideBind) string {
-	if len(binds) == 0 {
-		return ""
+func (m *MangoWCProvider) generatePreservedBindsContent(existingContent string, binds map[string]*mangowcOverrideBind, removed map[string]bool) string {
+	useStockScaffold := m.shouldUseStockScaffold(existingContent)
+	source := existingContent
+	if useStockScaffold {
+		source = m.stockBindsScaffold(binds)
 	}
 
+	remaining := make(map[string]*mangowcOverrideBind, len(binds))
+	for key, bind := range binds {
+		remaining[key] = bind
+	}
+	if useStockScaffold {
+		m.dropReplacedStockBinds(remaining)
+	}
+
+	var lines []string
+	for _, line := range strings.Split(source, "\n") {
+		templateBind, ok := m.parseOverrideBindLine(line, m.previousComment(lines))
+		if !ok || templateBind == nil {
+			lines = append(lines, line)
+			continue
+		}
+
+		normalizedKey := strings.ToLower(templateBind.Key)
+		m.dropPreviousDescriptionComment(&lines)
+
+		if bind, exists := remaining[normalizedKey]; exists {
+			if useStockScaffold && bind.Description == "" {
+				bind = m.copyBindWithDescription(bind, templateBind.Description)
+			}
+			m.writeBindLineToLines(&lines, bind)
+			delete(remaining, normalizedKey)
+			continue
+		}
+
+		if useStockScaffold && !removed[normalizedKey] {
+			m.writeBindLineToLines(&lines, templateBind)
+		}
+	}
+
+	if len(remaining) > 0 {
+		m.trimTrailingEmptyLines(&lines)
+		if len(lines) > 0 {
+			lines = append(lines, "")
+		}
+		lines = append(lines, "# === Custom Keybinds ===")
+		for _, bind := range m.sortedBinds(remaining) {
+			m.writeBindLineToLines(&lines, bind)
+		}
+	}
+
+	m.trimTrailingEmptyLines(&lines)
+	if len(lines) == 0 {
+		return ""
+	}
+	return strings.Join(lines, "\n") + "\n"
+}
+
+func (m *MangoWCProvider) shouldUseStockScaffold(content string) bool {
+	if strings.TrimSpace(content) == "" {
+		return true
+	}
+	if strings.Contains(content, "gesturebind=") && strings.Contains(content, "# ===") {
+		return false
+	}
+	return !strings.Contains(content, "gesturebind=") && (strings.Count(content, "\nbind=")+strings.Count(content, "\nbindl=")+strings.Count(content, "\nbinds=")+strings.Count(content, "\nbindr=")+strings.Count(content, "\nbindp=") >= 10 || strings.Contains(content, "dms ipc call"))
+}
+
+func (m *MangoWCProvider) stockBindsScaffold(binds map[string]*mangowcOverrideBind) string {
+	terminalCommand := "ghostty"
+	for _, key := range []string{"super+t", "super+return"} {
+		if bind, ok := binds[key]; ok {
+			command, params := m.parseAction(bind.Action)
+			if command == "spawn" && strings.TrimSpace(params) != "" && !strings.Contains(params, "dms ") {
+				terminalCommand = params
+				break
+			}
+		}
+	}
+	return strings.ReplaceAll(config.MangoBindsConfig, "{{TERMINAL_COMMAND}}", terminalCommand)
+}
+
+func (m *MangoWCProvider) dropReplacedStockBinds(binds map[string]*mangowcOverrideBind) {
+	if bind, ok := binds["super+j"]; ok && bind.Action == "switch_layout" {
+		delete(binds, "super+j")
+	}
+}
+
+func (m *MangoWCProvider) sortedBinds(binds map[string]*mangowcOverrideBind) []*mangowcOverrideBind {
 	bindList := make([]*mangowcOverrideBind, 0, len(binds))
 	for _, bind := range binds {
 		bindList = append(bindList, bind)
 	}
-
 	sort.Slice(bindList, func(i, j int) bool {
 		pi, pj := m.getBindSortPriority(bindList[i].Action), m.getBindSortPriority(bindList[j].Action)
 		if pi != pj {
@@ -380,20 +536,80 @@ func (m *MangoWCProvider) generateBindsContent(binds map[string]*mangowcOverride
 		}
 		return bindList[i].Key < bindList[j].Key
 	})
+	return bindList
+}
 
+func (m *MangoWCProvider) writeBindLineToLines(lines *[]string, bind *mangowcOverrideBind) {
 	var sb strings.Builder
-	for _, bind := range bindList {
-		m.writeBindLine(&sb, bind)
+	m.writeBindLine(&sb, bind)
+	text := strings.TrimSuffix(sb.String(), "\n")
+	if text == "" {
+		return
 	}
+	*lines = append(*lines, strings.Split(text, "\n")...)
+}
 
-	return sb.String()
+func (m *MangoWCProvider) previousComment(lines []string) string {
+	if len(lines) == 0 {
+		return ""
+	}
+	trimmed := strings.TrimSpace(lines[len(lines)-1])
+	if !strings.HasPrefix(trimmed, "#") {
+		return ""
+	}
+	comment := strings.TrimSpace(strings.TrimPrefix(trimmed, "#"))
+	if isMangoWCSectionComment(comment) {
+		return ""
+	}
+	return comment
+}
+
+func (m *MangoWCProvider) dropPreviousDescriptionComment(lines *[]string) {
+	if len(*lines) == 0 {
+		return
+	}
+	trimmed := strings.TrimSpace((*lines)[len(*lines)-1])
+	if !strings.HasPrefix(trimmed, "#") || strings.HasPrefix(trimmed, "# ===") {
+		return
+	}
+	*lines = (*lines)[:len(*lines)-1]
+}
+
+func (m *MangoWCProvider) trimTrailingEmptyLines(lines *[]string) {
+	for len(*lines) > 0 && strings.TrimSpace((*lines)[len(*lines)-1]) == "" {
+		*lines = (*lines)[:len(*lines)-1]
+	}
+}
+
+func (m *MangoWCProvider) copyBindWithDescription(bind *mangowcOverrideBind, description string) *mangowcOverrideBind {
+	copy := *bind
+	copy.Description = description
+	return &copy
 }
 
 func (m *MangoWCProvider) writeBindLine(sb *strings.Builder, bind *mangowcOverrideBind) {
 	mods, key := m.parseKeyString(bind.Key)
 	command, params := m.parseAction(bind.Action)
 
-	sb.WriteString("bind=")
+	// Description goes on the line ABOVE the bind: mango doesn't strip inline `#`
+	// comments from a value, so a trailing comment would break spawn (extra argv).
+	if bind.Description != "" {
+		sb.WriteString("# ")
+		sb.WriteString(bind.Description)
+		sb.WriteString("\n")
+	}
+
+	prefix := bind.Prefix
+	if prefix == "" {
+		prefix = "bind"
+	}
+	if prefix == mangowcAxisBindPrefix {
+		if direction, ok := mangowcScrollToDirection(key); ok {
+			key = direction
+		}
+	}
+	sb.WriteString(prefix)
+	sb.WriteString("=")
 	if mods == "" {
 		sb.WriteString("none")
 	} else {
@@ -409,14 +625,39 @@ func (m *MangoWCProvider) writeBindLine(sb *strings.Builder, bind *mangowcOverri
 		sb.WriteString(params)
 	}
 
-	if bind.Description != "" {
-		sb.WriteString(" # ")
-		sb.WriteString(bind.Description)
-	}
-
 	sb.WriteString("\n")
 }
 
+func (m *MangoWCProvider) bindPrefixFromOptions(options map[string]any) string {
+	if options == nil {
+		return ""
+	}
+	value, ok := options["flags"]
+	if !ok {
+		return ""
+	}
+	flags := ""
+	switch v := value.(type) {
+	case string:
+		flags = v
+	case fmt.Stringer:
+		flags = v.String()
+	default:
+		return ""
+	}
+	flags = strings.TrimSpace(flags)
+	if flags == "" {
+		return "bind"
+	}
+	var clean strings.Builder
+	for _, ch := range flags {
+		if strings.ContainsRune("lsrp", ch) && !strings.ContainsRune(clean.String(), ch) {
+			clean.WriteRune(ch)
+		}
+	}
+	return "bind" + clean.String()
+}
+
 func (m *MangoWCProvider) parseKeyString(keyStr string) (mods, key string) {
 	parts := strings.Split(keyStr, "+")
 	switch len(parts) {

core/internal/keybinds/providers/mangowc_parser.go

@@ -15,6 +15,10 @@ const (
 
 var MangoWCModSeparators = []rune{'+', ' '}
 
+func isMangoWCSectionComment(comment string) bool {
+	return strings.HasPrefix(strings.TrimSpace(comment), "===")
+}
+
 type MangoWCKeyBinding struct {
 	Mods    []string `json:"mods"`
 	Key     string   `json:"key"`
@@ -216,101 +220,40 @@ func mangowcAutogenerateComment(command, params string) string {
 	}
 }
 
-func (p *MangoWCParser) getKeybindAtLine(lineNumber int) *MangoWCKeyBinding {
+func (p *MangoWCParser) getKeybindAtLine(lineNumber int, precedingComment string) *MangoWCKeyBinding {
 	if lineNumber >= len(p.contentLines) {
 		return nil
 	}
-
-	line := p.contentLines[lineNumber]
-
-	bindMatch := regexp.MustCompile(`^(bind[lsr]*)\s*=\s*(.+)$`)
-	matches := bindMatch.FindStringSubmatch(line)
-	if len(matches) < 3 {
-		return nil
-	}
-
-	bindType := matches[1]
-	content := matches[2]
-
-	parts := strings.SplitN(content, "#", 2)
-	keys := parts[0]
-
-	var comment string
-	if len(parts) > 1 {
-		comment = strings.TrimSpace(parts[1])
-	}
-
-	if strings.HasPrefix(comment, MangoWCHideComment) {
-		return nil
-	}
-
-	keyFields := strings.SplitN(keys, ",", 4)
-	if len(keyFields) < 3 {
-		return nil
-	}
-
-	mods := strings.TrimSpace(keyFields[0])
-	key := strings.TrimSpace(keyFields[1])
-	command := strings.TrimSpace(keyFields[2])
-
-	var params string
-	if len(keyFields) > 3 {
-		params = strings.TrimSpace(keyFields[3])
-	}
-
-	if comment == "" {
-		comment = mangowcAutogenerateComment(command, params)
-	}
-
-	var modList []string
-	if mods != "" && !strings.EqualFold(mods, "none") {
-		modstring := mods + string(MangoWCModSeparators[0])
-		p := 0
-		for index, char := range modstring {
-			isModSep := false
-			for _, sep := range MangoWCModSeparators {
-				if char == sep {
-					isModSep = true
-					break
-				}
-			}
-			if isModSep {
-				if index-p > 1 {
-					modList = append(modList, modstring[p:index])
-				}
-				p = index + 1
-			}
-		}
-	}
-
-	_ = bindType
-
-	return &MangoWCKeyBinding{
-		Mods:    modList,
-		Key:     key,
-		Command: command,
-		Params:  params,
-		Comment: comment,
-	}
+	return p.getKeybindAtLineContent(p.contentLines[lineNumber], precedingComment)
 }
 
 func (p *MangoWCParser) ParseKeys() []MangoWCKeyBinding {
 	var keybinds []MangoWCKeyBinding
+	var pendingComment string
 
 	for lineNumber := 0; lineNumber < len(p.contentLines); lineNumber++ {
-		line := p.contentLines[lineNumber]
-		if line == "" || strings.HasPrefix(strings.TrimSpace(line), "#") {
+		trimmed := strings.TrimSpace(p.contentLines[lineNumber])
+		if trimmed == "" {
+			pendingComment = ""
+			continue
+		}
+		if strings.HasPrefix(trimmed, "#") {
+			pendingComment = strings.TrimSpace(strings.TrimPrefix(trimmed, "#"))
+			if isMangoWCSectionComment(pendingComment) {
+				pendingComment = ""
+			}
+			continue
+		}
+		if !strings.HasPrefix(trimmed, "bind") && !strings.HasPrefix(trimmed, mangowcAxisBindPrefix) {
+			pendingComment = ""
 			continue
 		}
 
-		if !strings.HasPrefix(strings.TrimSpace(line), "bind") {
-			continue
-		}
-
-		keybind := p.getKeybindAtLine(lineNumber)
+		keybind := p.getKeybindAtLine(lineNumber, pendingComment)
 		if keybind != nil {
 			keybinds = append(keybinds, *keybind)
 		}
+		pendingComment = ""
 	}
 
 	return keybinds
@@ -459,21 +402,38 @@ func (p *MangoWCParser) parseFileWithSource(filePath string) ([]MangoWCKeyBindin
 	p.currentSource = absPath
 
 	var keybinds []MangoWCKeyBinding
+	var pendingComment string
 	lines := strings.Split(string(data), "\n")
 
-	for lineNum, line := range lines {
+	for _, line := range lines {
 		trimmed := strings.TrimSpace(line)
 
+		if trimmed == "" {
+			pendingComment = ""
+			continue
+		}
+
 		if strings.HasPrefix(trimmed, "source") {
 			p.handleSource(trimmed, filepath.Dir(absPath), &keybinds)
+			pendingComment = ""
 			continue
 		}
 
-		if !strings.HasPrefix(trimmed, "bind") {
+		if strings.HasPrefix(trimmed, "#") {
+			pendingComment = strings.TrimSpace(strings.TrimPrefix(trimmed, "#"))
+			if isMangoWCSectionComment(pendingComment) {
+				pendingComment = ""
+			}
 			continue
 		}
 
-		kb := p.getKeybindAtLineContent(line, lineNum)
+		if !strings.HasPrefix(trimmed, "bind") && !strings.HasPrefix(trimmed, mangowcAxisBindPrefix) {
+			pendingComment = ""
+			continue
+		}
+
+		kb := p.getKeybindAtLineContent(line, pendingComment)
+		pendingComment = ""
 		if kb == nil {
 			continue
 		}
@@ -529,8 +489,11 @@ func (p *MangoWCParser) parseDMSBindsDirectly(dmsBindsPath string) []MangoWCKeyB
 	return keybinds
 }
 
-func (p *MangoWCParser) getKeybindAtLineContent(line string, _ int) *MangoWCKeyBinding {
-	bindMatch := regexp.MustCompile(`^(bind[lsr]*)\s*=\s*(.+)$`)
+// getKeybindAtLineContent parses one `bind=` line. precedingComment (a `# ...`
+// line directly above) is the description: mango feeds inline comments to spawn
+// as argv, so DMS keeps descriptions on the line above; inline `#` is a fallback.
+func (p *MangoWCParser) getKeybindAtLineContent(line string, precedingComment string) *MangoWCKeyBinding {
+	bindMatch := regexp.MustCompile(`^(bind[lsrp]*|axisbind)\s*=\s*(.+)$`)
 	matches := bindMatch.FindStringSubmatch(line)
 	if len(matches) < 3 {
 		return nil
@@ -544,6 +507,12 @@ func (p *MangoWCParser) getKeybindAtLineContent(line string, _ int) *MangoWCKeyB
 	if len(parts) > 1 {
 		comment = strings.TrimSpace(parts[1])
 	}
+	if comment == "" {
+		comment = strings.TrimSpace(precedingComment)
+		if isMangoWCSectionComment(comment) {
+			comment = ""
+		}
+	}
 
 	if strings.HasPrefix(comment, MangoWCHideComment) {
 		return nil
@@ -558,6 +527,12 @@ func (p *MangoWCParser) getKeybindAtLineContent(line string, _ int) *MangoWCKeyB
 	key := strings.TrimSpace(keyFields[1])
 	command := strings.TrimSpace(keyFields[2])
 
+	if matches[1] == mangowcAxisBindPrefix {
+		if canonical, ok := mangowcDirectionToScroll(key); ok {
+			key = canonical
+		}
+	}
+
 	var params string
 	if len(keyFields) > 3 {
 		params = strings.TrimSpace(keyFields[3])

core/internal/keybinds/providers/mangowc_parser_test.go

@@ -6,6 +6,29 @@ import (
 	"testing"
 )
 
+func TestMangoWCParseAxisBindToScrollKey(t *testing.T) {
+	tmpDir := t.TempDir()
+	cfg := filepath.Join(tmpDir, "config.conf")
+	content := "axisbind=SUPER,UP,spawn,dms ipc call test\n"
+	if err := os.WriteFile(cfg, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	binds, err := ParseMangoWCKeys(cfg)
+	if err != nil {
+		t.Fatalf("ParseMangoWCKeys failed: %v", err)
+	}
+	if len(binds) != 1 {
+		t.Fatalf("expected 1 bind, got %d", len(binds))
+	}
+	if binds[0].Key != "WheelScrollUp" {
+		t.Fatalf("expected axis direction parsed as WheelScrollUp, got %q", binds[0].Key)
+	}
+	if len(binds[0].Mods) != 1 || binds[0].Mods[0] != "SUPER" {
+		t.Fatalf("expected SUPER mod, got %v", binds[0].Mods)
+	}
+}
+
 func TestMangoWCAutogenerateComment(t *testing.T) {
 	tests := []struct {
 		command  string
@@ -71,9 +94,10 @@ func TestMangoWCAutogenerateComment(t *testing.T) {
 
 func TestMangoWCGetKeybindAtLine(t *testing.T) {
 	tests := []struct {
-		name     string
-		line     string
-		expected *MangoWCKeyBinding
+		name             string
+		line             string
+		precedingComment string
+		expected         *MangoWCKeyBinding
 	}{
 		{
 			name: "basic_keybind",
@@ -157,6 +181,41 @@ func TestMangoWCGetKeybindAtLine(t *testing.T) {
 				Comment: "dms ipc call lock lock",
 			},
 		},
+		{
+			name: "bindp_flag",
+			line: "bindp=SUPER,p,spawn,pass-through",
+			expected: &MangoWCKeyBinding{
+				Mods:    []string{"SUPER"},
+				Key:     "p",
+				Command: "spawn",
+				Params:  "pass-through",
+				Comment: "pass-through",
+			},
+		},
+		{
+			name:             "preceding_comment",
+			line:             "bind=SUPER+SHIFT,S,spawn,dms screenshot",
+			precedingComment: "Screenshot: Interactive",
+			expected: &MangoWCKeyBinding{
+				Mods:    []string{"SUPER", "SHIFT"},
+				Key:     "S",
+				Command: "spawn",
+				Params:  "dms screenshot",
+				Comment: "Screenshot: Interactive",
+			},
+		},
+		{
+			name:             "section_header_not_description",
+			line:             "bind=none,XF86AudioRaiseVolume,spawn,dms ipc call audio increment 3",
+			precedingComment: "=== Audio Controls ===",
+			expected: &MangoWCKeyBinding{
+				Mods:    []string{},
+				Key:     "XF86AudioRaiseVolume",
+				Command: "spawn",
+				Params:  "dms ipc call audio increment 3",
+				Comment: "dms ipc call audio increment 3",
+			},
+		},
 		{
 			name: "keybind_with_spaces",
 			line: "bind = SUPER, r, reload_config",
@@ -174,7 +233,7 @@ func TestMangoWCGetKeybindAtLine(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			parser := NewMangoWCParser("")
 			parser.contentLines = []string{tt.line}
-			result := parser.getKeybindAtLine(0)
+			result := parser.getKeybindAtLine(0, tt.precedingComment)
 
 			if tt.expected == nil {
 				if result != nil {
@@ -421,7 +480,7 @@ func TestMangoWCInvalidBindLines(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			parser := NewMangoWCParser("")
 			parser.contentLines = []string{tt.line}
-			result := parser.getKeybindAtLine(0)
+			result := parser.getKeybindAtLine(0, "")
 
 			if result != nil {
 				t.Errorf("expected nil for invalid line, got %+v", result)

core/internal/keybinds/providers/mangowc_test.go

@@ -3,7 +3,10 @@ package providers
 import (
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/config"
 )
 
 func TestMangoWCProviderName(t *testing.T) {
@@ -318,3 +321,172 @@ bind=Ctrl,1,view,1,0
 		t.Error("Did not find terminal keybind with correct key and description")
 	}
 }
+
+func TestMangoWCSetBindPreservesStockCommentsAndGestures(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatalf("failed to create dms dir: %v", err)
+	}
+	bindsPath := filepath.Join(dmsDir, "binds.conf")
+	stock := strings.ReplaceAll(config.MangoBindsConfig, "{{TERMINAL_COMMAND}}", "ghostty")
+	if err := os.WriteFile(bindsPath, []byte(stock), 0o644); err != nil {
+		t.Fatalf("failed to write stock binds: %v", err)
+	}
+
+	provider := NewMangoWCProvider(tmpDir)
+	if err := provider.SetBind("SUPER+SHIFT+S", "spawn dms screenshot", "Screenshot: Interactive", nil); err != nil {
+		t.Fatalf("SetBind failed: %v", err)
+	}
+
+	contentBytes, err := os.ReadFile(bindsPath)
+	if err != nil {
+		t.Fatalf("failed to read binds: %v", err)
+	}
+	content := string(contentBytes)
+
+	for _, want := range []string{
+		"# === Application Launchers ===",
+		"# === Touchpad Gestures ===",
+		"gesturebind=none,right,3,viewtoleft_have_client",
+		"gesturebind=none,left,3,viewtoright_have_client",
+		"# Screenshot: Interactive\nbind=SUPER+SHIFT,S,spawn,dms screenshot",
+	} {
+		if !strings.Contains(content, want) {
+			t.Fatalf("expected saved binds to contain %q\ncontent:\n%s", want, content)
+		}
+	}
+	if strings.Contains(content, "# === Audio Controls ===\n# === Audio Controls ===") {
+		t.Fatalf("section header should not be duplicated as a bind description\ncontent:\n%s", content)
+	}
+}
+
+func TestMangoWCSetBindRestoresScaffoldForStrippedFile(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatalf("failed to create dms dir: %v", err)
+	}
+	bindsPath := filepath.Join(dmsDir, "binds.conf")
+	stripped := `bind=SUPER,t,spawn,ghostty
+bind=SUPER,Return,spawn,ghostty
+bind=SUPER,space,spawn,dms ipc call spotlight toggle
+bind=SUPER,v,spawn,dms ipc call clipboard toggle
+bind=SUPER,q,killclient
+bind=SUPER,Left,focusdir,left
+bind=SUPER,Right,focusdir,right
+bind=SUPER,Up,focusdir,up
+bind=SUPER,Down,focusdir,down
+bind=SUPER,1,view,1
+bind=SUPER,2,view,2
+bind=SUPER,3,view,3
+`
+	if err := os.WriteFile(bindsPath, []byte(stripped), 0o644); err != nil {
+		t.Fatalf("failed to write stripped binds: %v", err)
+	}
+
+	provider := NewMangoWCProvider(tmpDir)
+	if err := provider.SetBind("SUPER+SHIFT+S", "spawn dms screenshot", "Screenshot: Interactive", nil); err != nil {
+		t.Fatalf("SetBind failed: %v", err)
+	}
+
+	contentBytes, err := os.ReadFile(bindsPath)
+	if err != nil {
+		t.Fatalf("failed to read binds: %v", err)
+	}
+	content := string(contentBytes)
+
+	for _, want := range []string{
+		"# DMS default keybinds (MangoWM)",
+		"# === Touchpad Gestures ===",
+		"gesturebind=none,right,3,viewtoleft_have_client",
+		"bind=SUPER,H,focusdir,left",
+		"bind=SUPER,J,focusdir,down",
+		"bind=SUPER,K,focusdir,up",
+		"bind=SUPER,L,focusdir,right",
+		"# === Custom Keybinds ===",
+		"# Screenshot: Interactive\nbind=SUPER+SHIFT,S,spawn,dms screenshot",
+		"bind=SUPER,t,spawn,ghostty",
+	} {
+		if !strings.Contains(content, want) {
+			t.Fatalf("expected restored binds to contain %q\ncontent:\n%s", want, content)
+		}
+	}
+	if strings.Contains(content, "{{TERMINAL_COMMAND}}") {
+		t.Fatalf("terminal placeholder should have been resolved\ncontent:\n%s", content)
+	}
+}
+
+func TestMangoWCSetBindTranslatesScrollWheelToAxisBind(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatalf("failed to create dms dir: %v", err)
+	}
+	bindsPath := filepath.Join(dmsDir, "binds.conf")
+	seed := "# === Custom Keybinds ===\nbind=SUPER,t,spawn,ghostty\ngesturebind=none,left,3,focusdir,left\n"
+	if err := os.WriteFile(bindsPath, []byte(seed), 0o644); err != nil {
+		t.Fatalf("failed to write seed binds: %v", err)
+	}
+
+	provider := NewMangoWCProvider(tmpDir)
+	if err := provider.SetBind("SUPER+WheelScrollDown", "spawn dms ipc call test", "Scroll down", nil); err != nil {
+		t.Fatalf("SetBind failed: %v", err)
+	}
+
+	content := readFile(t, bindsPath)
+	if !strings.Contains(content, "axisbind=SUPER,DOWN,spawn,dms ipc call test") {
+		t.Fatalf("expected scroll bind written as axisbind direction, got:\n%s", content)
+	}
+	if strings.Contains(content, "WheelScroll") {
+		t.Fatalf("expected no raw niri scroll keysym in mango output, got:\n%s", content)
+	}
+
+	if err := provider.SetBind("SUPER+WheelScrollDown", "spawn dms ipc call test2", "Scroll down", nil); err != nil {
+		t.Fatalf("SetBind failed: %v", err)
+	}
+	content = readFile(t, bindsPath)
+	if strings.Count(content, "axisbind=SUPER,DOWN,") != 1 {
+		t.Fatalf("expected exactly one axisbind after re-save, got:\n%s", content)
+	}
+}
+
+func TestMangoWCRemoveBindPreservesNonBindLines(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatalf("failed to create dms dir: %v", err)
+	}
+	bindsPath := filepath.Join(dmsDir, "binds.conf")
+	stock := strings.ReplaceAll(config.MangoBindsConfig, "{{TERMINAL_COMMAND}}", "ghostty")
+	if err := os.WriteFile(bindsPath, []byte(stock), 0o644); err != nil {
+		t.Fatalf("failed to write stock binds: %v", err)
+	}
+
+	provider := NewMangoWCProvider(tmpDir)
+	if err := provider.RemoveBind("SUPER+Tab"); err != nil {
+		t.Fatalf("RemoveBind failed: %v", err)
+	}
+
+	contentBytes, err := os.ReadFile(bindsPath)
+	if err != nil {
+		t.Fatalf("failed to read binds: %v", err)
+	}
+	content := string(contentBytes)
+
+	if strings.Contains(content, "bind=SUPER,Tab,focusstack,next") {
+		t.Fatalf("removed bind should be absent\ncontent:\n%s", content)
+	}
+	if strings.Contains(content, "# Focus Next Window") {
+		t.Fatalf("removed bind description should be absent\ncontent:\n%s", content)
+	}
+	for _, want := range []string{
+		"# === Focus Navigation ===",
+		"# === Touchpad Gestures ===",
+		"gesturebind=none,down,4,toggleoverview",
+	} {
+		if !strings.Contains(content, want) {
+			t.Fatalf("expected non-bind line %q to be preserved\ncontent:\n%s", want, content)
+		}
+	}
+}

core/internal/keybinds/providers/niri.go

@@ -149,7 +149,7 @@ func (n *NiriProvider) convertKeybind(kb *NiriKeyBinding, subcategory string, co
 
 	source := "config"
 	if strings.Contains(kb.Source, "dms/binds.kdl") {
-		source = "dms"
+		source = "dms-default"
 	}
 
 	bind := keybinds.Keybind{
@@ -165,8 +165,8 @@ func (n *NiriProvider) convertKeybind(kb *NiriKeyBinding, subcategory string, co
 		Repeat:          kb.Repeat,
 	}
 
-	if source == "dms" && conflicts != nil {
-		if conflictKb, ok := conflicts[keyStr]; ok {
+	if source == "dms-default" && conflicts != nil {
+		if conflictKb, ok := conflicts[normalizeNiriBindKey(keyStr)]; ok {
 			bind.Conflict = &keybinds.Keybind{
 				Key:         keyStr,
 				Description: conflictKb.Description,
@@ -249,7 +249,7 @@ func (n *NiriProvider) SetBind(key, action, description string, options map[stri
 		existingBinds = make(map[string]*overrideBind)
 	}
 
-	existingBinds[key] = &overrideBind{
+	existingBinds[normalizeNiriBindKey(key)] = &overrideBind{
 		Key:         key,
 		Action:      action,
 		Description: description,
@@ -265,10 +265,14 @@ func (n *NiriProvider) RemoveBind(key string) error {
 		return nil
 	}
 
-	delete(existingBinds, key)
+	delete(existingBinds, normalizeNiriBindKey(key))
 	return n.writeOverrideBinds(existingBinds)
 }
 
+func (n *NiriProvider) ResetBind(key string) error {
+	return n.RemoveBind(key)
+}
+
 type overrideBind struct {
 	Key         string
 	Action      string
@@ -312,7 +316,7 @@ func (n *NiriProvider) loadOverrideBinds() (map[string]*overrideBind, error) {
 				action = n.formatRawAction(kb.Action, kb.Args)
 			}
 
-			binds[keyStr] = &overrideBind{
+			binds[normalizeNiriBindKey(keyStr)] = &overrideBind{
 				Key:         keyStr,
 				Action:      action,
 				Description: kb.Description,

core/internal/keybinds/providers/niri_parser.go

@@ -51,7 +51,7 @@ type NiriParser struct {
 }
 
 func parseKDL(data []byte) (*document.Document, error) {
-	return kdl.Parse(strings.NewReader(normalizeKDLBraces(string(data))))
+	return kdl.Parse(strings.NewReader(normalizeKDLBraces(quoteLeadingUnderscoreIdents(string(data)))))
 }
 
 func normalizeKDLBraces(input string) string {
@@ -94,6 +94,93 @@ func normalizeKDLBraces(input string) string {
 	return sb.String()
 }
 
+// quoteLeadingUnderscoreIdents wraps bare KDL identifiers that begin with '_'
+// in double quotes. kdl-go rejects '_' as the first character of a bare
+// identifier (e.g. the common `_JAVA_AWT_WM_NONREPARENTING "1"` environment
+// node), even though niri's own parser and the KDL spec accept it — so without
+// this the whole config fails to parse and no keybinds load. Quoting lets
+// kdl-go parse it; this is safe because the niri parser only dispatches on
+// fixed node/section names (binds, recent-windows, include, ...) that never
+// start with '_', so re-quoting such a name cannot change what DMS reads.
+// Underscores elsewhere in an identifier (XDG_CURRENT_DESKTOP) are left
+// untouched, and underscores inside strings or comments are skipped. Only a
+// leading '_' is handled; other start characters kdl-go over-rejects (e.g. '.'
+// or '?') do not occur in niri configs.
+func quoteLeadingUnderscoreIdents(input string) string {
+	var sb strings.Builder
+	sb.Grow(len(input))
+
+	var prev byte
+	n := len(input)
+	for i := 0; i < n; {
+		c := input[i]
+
+		switch {
+		case c == '"':
+			end := findStringEnd(input, i)
+			sb.WriteString(input[i:end])
+			prev = '"'
+			i = end
+		case c == '/' && i+1 < n && input[i+1] == '/':
+			end := findLineCommentEnd(input, i)
+			sb.WriteString(input[i:end])
+			prev = '\n'
+			i = end
+		case c == '/' && i+1 < n && input[i+1] == '*':
+			end := findBlockCommentEnd(input, i)
+			sb.WriteString(input[i:end])
+			prev = ' '
+			i = end
+		case c == '/' && i+1 < n && input[i+1] == '-':
+			// KDL slashdash: /- comments out the next node/value. Keep the
+			// marker but treat what follows as a fresh token start, so a
+			// slashdashed leading-underscore node (e.g. `/-_FOO "1"`) still
+			// gets quoted instead of crashing kdl-go.
+			sb.WriteByte('/')
+			sb.WriteByte('-')
+			prev = ' '
+			i += 2
+		case c == '_' && isIdentBoundary(prev):
+			end := scanBareIdent(input, i)
+			sb.WriteByte('"')
+			sb.WriteString(input[i:end])
+			sb.WriteByte('"')
+			prev = '"'
+			i = end
+		default:
+			sb.WriteByte(c)
+			prev = c
+			i++
+		}
+	}
+
+	return sb.String()
+}
+
+// isIdentBoundary reports whether the previously emitted byte ends a token, so
+// that a following '_' starts a fresh bare identifier rather than sitting in
+// the middle of one.
+func isIdentBoundary(prev byte) bool {
+	switch prev {
+	case 0, ' ', '\t', '\n', '\r', '{', '}', ';', '=', '(', ')', ',':
+		return true
+	}
+	return false
+}
+
+// scanBareIdent returns the index just past the bare identifier starting at
+// start, stopping at whitespace or any KDL delimiter.
+func scanBareIdent(s string, start int) int {
+	n := len(s)
+	for i := start; i < n; i++ {
+		switch s[i] {
+		case ' ', '\t', '\n', '\r', '"', '{', '}', '(', ')', ';', '=', ',', '/', '\\', '<', '>', '[', ']':
+			return i
+		}
+	}
+	return n
+}
+
 func findStringEnd(s string, start int) int {
 	n := len(s)
 	for i := start + 1; i < n; {
@@ -162,6 +249,14 @@ func NewNiriParser(configDir string) *NiriParser {
 	}
 }
 
+func normalizeNiriBindKey(key string) string {
+	parts := strings.Split(key, "+")
+	for i := range parts {
+		parts[i] = strings.ToLower(strings.TrimSpace(parts[i]))
+	}
+	return strings.Join(parts, "+")
+}
+
 func (p *NiriParser) Parse() (*NiriSection, error) {
 	dmsBindsPath := filepath.Join(p.configDir, "dms", "binds.kdl")
 	if _, err := os.Stat(dmsBindsPath); err == nil {
@@ -213,24 +308,25 @@ func (p *NiriParser) finalizeBinds() []NiriKeyBinding {
 
 func (p *NiriParser) addBind(kb *NiriKeyBinding) {
 	key := p.formatBindKey(kb)
+	normalizedKey := normalizeNiriBindKey(key)
 	isDMSBind := strings.Contains(kb.Source, "dms/binds.kdl")
 
 	if isDMSBind {
-		p.dmsBindKeys[key] = true
-		p.dmsBindMap[key] = kb
-	} else if p.dmsBindKeys[key] {
+		p.dmsBindKeys[normalizedKey] = true
+		p.dmsBindMap[normalizedKey] = kb
+	} else if p.dmsBindKeys[normalizedKey] {
 		p.bindsAfterDMS++
-		p.conflictingConfigs[key] = kb
-		p.configBindKeys[key] = true
+		p.conflictingConfigs[normalizedKey] = kb
+		p.configBindKeys[normalizedKey] = true
 		return
 	} else {
-		p.configBindKeys[key] = true
+		p.configBindKeys[normalizedKey] = true
 	}
 
-	if _, exists := p.bindMap[key]; !exists {
-		p.bindOrder = append(p.bindOrder, key)
+	if _, exists := p.bindMap[normalizedKey]; !exists {
+		p.bindOrder = append(p.bindOrder, normalizedKey)
 	}
-	p.bindMap[key] = kb
+	p.bindMap[normalizedKey] = kb
 }
 
 func (p *NiriParser) formatBindKey(kb *NiriKeyBinding) string {

core/internal/keybinds/providers/niri_parser_test.go

@@ -71,6 +71,101 @@ func TestNormalizeKDLBraces(t *testing.T) {
 	}
 }
 
+func TestQuoteLeadingUnderscoreIdents(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		out  string
+	}{
+		{"leading underscore node", `_JAVA_AWT_WM_NONREPARENTING "1"`, `"_JAVA_AWT_WM_NONREPARENTING" "1"`},
+		{"mid underscore untouched", `XDG_CURRENT_DESKTOP "niri"`, `XDG_CURRENT_DESKTOP "niri"`},
+		{"indented node", "environment {\n  _FOO \"1\"\n}", "environment {\n  \"_FOO\" \"1\"\n}"},
+		{"underscore in string", `spawn "_not_a_node"`, `spawn "_not_a_node"`},
+		{"underscore in line comment", "// _comment\n_FOO \"1\"", "// _comment\n\"_FOO\" \"1\""},
+		{"underscore in block comment", "/* _x */ _FOO \"1\"", "/* _x */ \"_FOO\" \"1\""},
+		{"block comment abuts node", `/* x */_FOO "1"`, `/* x */"_FOO" "1"`},
+		{"slashdash before node", `/-_FOO "1"`, `/-"_FOO" "1"`},
+		{"node after closing paren", "node (u8)_v", `node (u8)"_v"`},
+		{"node before brace without space", "_FOO{ }", `"_FOO"{ }`},
+		{"lone underscore", `_ "x"`, `"_" "x"`},
+		{"property value", "node key=_val", `node key="_val"`},
+		{"no underscores", "node child", "node child"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := quoteLeadingUnderscoreIdents(tc.in)
+			if got != tc.out {
+				t.Errorf("quoteLeadingUnderscoreIdents(%q) = %q, want %q", tc.in, got, tc.out)
+			}
+		})
+	}
+}
+
+func TestNiriParseLeadingUnderscoreEnvironment(t *testing.T) {
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "config.kdl")
+
+	// A leading-underscore environment node (a common Java/tiling-WM fix) must
+	// not abort parsing of the rest of the config — keybinds still have to load.
+	content := `environment {
+    XDG_CURRENT_DESKTOP "niri"
+    _JAVA_AWT_WM_NONREPARENTING "1"
+}
+binds {
+    Mod+Q { close-window; }
+    Mod+KP_Home { focus-workspace 1; }
+}
+`
+	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+		t.Fatalf("Failed to write test config: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("ParseNiriKeys failed on config with leading-underscore env node: %v", err)
+	}
+
+	if len(result.Section.Keybinds) != 2 {
+		t.Errorf("Expected 2 keybinds, got %d", len(result.Section.Keybinds))
+	}
+
+	foundClose := false
+	for _, kb := range result.Section.Keybinds {
+		if kb.Action == "close-window" {
+			foundClose = true
+		}
+	}
+	if !foundClose {
+		t.Error("close-window keybind not found — leading-underscore env node broke parsing")
+	}
+}
+
+func TestNiriParseSlashdashLeadingUnderscore(t *testing.T) {
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "config.kdl")
+
+	// A slashdashed leading-underscore node must not abort parsing either.
+	content := `environment {
+    /-_JAVA_AWT_WM_NONREPARENTING "1"
+}
+binds {
+    Mod+Q { close-window; }
+}
+`
+	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+		t.Fatalf("Failed to write test config: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("ParseNiriKeys failed on config with slashdashed leading-underscore node: %v", err)
+	}
+
+	if len(result.Section.Keybinds) != 1 {
+		t.Errorf("Expected 1 keybind, got %d", len(result.Section.Keybinds))
+	}
+}
+
 func TestNiriParseKeyCombo(t *testing.T) {
 	tests := []struct {
 		combo        string
@@ -526,6 +621,50 @@ binds {
 	}
 }
 
+func TestNiriKeyIdentityIsCaseInsensitive(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatalf("Failed to create dms dir: %v", err)
+	}
+
+	config := `binds {
+    Alt+Space hotkey-overlay-title="Spotlight Bar" { spawn "dms" "ipc" "call" "spotlight-bar" "toggle"; }
+}
+include "dms/binds.kdl"
+`
+	if err := os.WriteFile(filepath.Join(tmpDir, "config.kdl"), []byte(config), 0o644); err != nil {
+		t.Fatalf("Failed to write config: %v", err)
+	}
+	include := `binds {
+    Alt+space hotkey-overlay-title="Default Launcher" { spawn "dms" "ipc" "call" "spotlight" "toggle"; }
+}
+`
+	if err := os.WriteFile(filepath.Join(dmsDir, "binds.kdl"), []byte(include), 0o644); err != nil {
+		t.Fatalf("Failed to write binds include: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("ParseNiriKeys failed: %v", err)
+	}
+
+	var altSpaceBinds []NiriKeyBinding
+	parser := NewNiriParser("")
+	for _, kb := range result.Section.Keybinds {
+		if normalizeNiriBindKey(parser.formatBindKey(&kb)) == "alt+space" {
+			altSpaceBinds = append(altSpaceBinds, kb)
+		}
+	}
+
+	if len(altSpaceBinds) != 1 {
+		t.Fatalf("Expected one Alt+Space identity, got %d", len(altSpaceBinds))
+	}
+	if got := altSpaceBinds[0].Args; len(got) < 5 || got[3] != "spotlight" || got[4] != "toggle" {
+		t.Fatalf("Expected later DMS include to win with spotlight toggle, got action=%s args=%v", altSpaceBinds[0].Action, got)
+	}
+}
+
 func TestNiriParseMultipleArgs(t *testing.T) {
 	tmpDir := t.TempDir()
 	configFile := filepath.Join(tmpDir, "config.kdl")

core/internal/keybinds/providers/niri_test.go

@@ -367,7 +367,7 @@ func TestNiriEmptyArgsPreservation(t *testing.T) {
 	}
 
 	for key, expected := range binds {
-		loaded, ok := loadedBinds[key]
+		loaded, ok := loadedBinds[normalizeNiriBindKey(key)]
 		if !ok {
 			t.Errorf("Missing bind for key %s", key)
 			continue

core/internal/keybinds/providers/scroll.go

@@ -0,0 +1,74 @@
+package providers
+
+import "strings"
+
+// Scroll-wheel binds are captured by the shell as niri's keysym names
+// (WheelScrollUp/Down/Left/Right) regardless of the active compositor. Niri
+// consumes them natively; every other provider speaks a different dialect, so the
+// raw niri token must be translated on write and back again on read. Without this
+// the token is emitted verbatim and the compositor rejects the bind (issue #2683).
+
+var canonicalScrollKeys = map[string]string{
+	"wheelscrollup":    "WheelScrollUp",
+	"wheelscrolldown":  "WheelScrollDown",
+	"wheelscrollleft":  "WheelScrollLeft",
+	"wheelscrollright": "WheelScrollRight",
+}
+
+func isScrollKey(token string) bool {
+	_, ok := canonicalScrollKeys[strings.ToLower(token)]
+	return ok
+}
+
+// Hyprland binds the wheel inside a regular bind using mouse_up/down/left/right.
+var hyprlandScrollNative = map[string]string{
+	"wheelscrollup":    "mouse_up",
+	"wheelscrolldown":  "mouse_down",
+	"wheelscrollleft":  "mouse_left",
+	"wheelscrollright": "mouse_right",
+}
+
+var hyprlandScrollCanonical = map[string]string{
+	"mouse_up":    "WheelScrollUp",
+	"mouse_down":  "WheelScrollDown",
+	"mouse_left":  "WheelScrollLeft",
+	"mouse_right": "WheelScrollRight",
+}
+
+func hyprlandScrollToNative(token string) (string, bool) {
+	v, ok := hyprlandScrollNative[strings.ToLower(token)]
+	return v, ok
+}
+
+func hyprlandScrollToCanonical(token string) (string, bool) {
+	v, ok := hyprlandScrollCanonical[strings.ToLower(token)]
+	return v, ok
+}
+
+// MangoWC binds the wheel through a dedicated axisbind directive whose key field
+// is a direction (UP/DOWN/LEFT/RIGHT) rather than a keysym.
+const mangowcAxisBindPrefix = "axisbind"
+
+var mangowcScrollDirection = map[string]string{
+	"wheelscrollup":    "UP",
+	"wheelscrolldown":  "DOWN",
+	"wheelscrollleft":  "LEFT",
+	"wheelscrollright": "RIGHT",
+}
+
+var mangowcScrollCanonical = map[string]string{
+	"up":    "WheelScrollUp",
+	"down":  "WheelScrollDown",
+	"left":  "WheelScrollLeft",
+	"right": "WheelScrollRight",
+}
+
+func mangowcScrollToDirection(token string) (string, bool) {
+	v, ok := mangowcScrollDirection[strings.ToLower(token)]
+	return v, ok
+}
+
+func mangowcDirectionToScroll(direction string) (string, bool) {
+	v, ok := mangowcScrollCanonical[strings.ToLower(direction)]
+	return v, ok
+}

core/internal/keybinds/types.go

@@ -13,6 +13,7 @@ type Keybind struct {
 	AllowInhibiting *bool    `json:"allowInhibiting,omitempty"` // nil=default(true), false=explicitly disabled
 	Repeat          *bool    `json:"repeat,omitempty"`          // nil=default(true), false=explicitly disabled
 	Conflict        *Keybind `json:"conflict,omitempty"`
+	HasDefault      bool     `json:"hasDefault,omitempty"` // override has a DMS default to revert to
 }
 
 type DMSBindsStatus struct {
@@ -24,6 +25,8 @@ type DMSBindsStatus struct {
 	Effective       bool   `json:"effective"`
 	OverriddenBy    int    `json:"overriddenBy"`
 	StatusMessage   string `json:"statusMessage"`
+	ConfigFormat    string `json:"configFormat,omitempty"`
+	ReadOnly        bool   `json:"readOnly,omitempty"`
 }
 
 type CheatSheet struct {
@@ -42,6 +45,11 @@ type Provider interface {
 type WritableProvider interface {
 	Provider
 	SetBind(key, action, description string, options map[string]any) error
+	// RemoveBind removes the bind. Hyprland writes a negative override to
+	// dms/binds-user.lua; single-file providers delete the line.
 	RemoveBind(key string) error
+	// ResetBind reverts a user override to its DMS default. On single-file
+	// providers this aliases to RemoveBind.
+	ResetBind(key string) error
 	GetOverridePath() string
 }

core/internal/luaconfig/lua.go

@@ -0,0 +1,129 @@
+package luaconfig
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+var luaRequireRE = regexp.MustCompile(`(?i)\brequire\s*\(\s*["']([^"']+)["']\s*\)`)
+
+func ModuleToRelPath(module string) string {
+	module = strings.TrimSpace(module)
+	if module == "" {
+		return ""
+	}
+	module = strings.NewReplacer(".", string(filepath.Separator), "/", string(filepath.Separator)).Replace(module)
+	return filepath.Clean(module + ".lua")
+}
+
+func ModuleToPath(baseDir, module string) string {
+	rel := ModuleToRelPath(module)
+	if rel == "" {
+		return ""
+	}
+	return filepath.Clean(filepath.Join(baseDir, rel))
+}
+
+func Requires(line string) []string {
+	line = stripLineComment(line)
+	if strings.TrimSpace(line) == "" {
+		return nil
+	}
+	matches := luaRequireRE.FindAllStringSubmatch(line, -1)
+	if len(matches) == 0 {
+		return nil
+	}
+	modules := make([]string, 0, len(matches))
+	for _, match := range matches {
+		if len(match) > 1 && strings.TrimSpace(match[1]) != "" {
+			modules = append(modules, strings.TrimSpace(match[1]))
+		}
+	}
+	return modules
+}
+
+func Require(line string) (string, bool) {
+	modules := Requires(line)
+	if len(modules) != 1 {
+		return "", false
+	}
+	return modules[0], true
+}
+
+func RequiresTarget(filePath, targetAbs string, processed map[string]bool) bool {
+	absPath, err := filepath.Abs(filePath)
+	if err != nil {
+		return false
+	}
+	return requiresTarget(absPath, filepath.Dir(absPath), targetAbs, processed)
+}
+
+func requiresTarget(filePath, rootDir, targetAbs string, processed map[string]bool) bool {
+	absPath, err := filepath.Abs(filePath)
+	if err != nil {
+		return false
+	}
+	targetAbsClean := filepath.Clean(targetAbs)
+
+	if processed[absPath] {
+		return false
+	}
+	processed[absPath] = true
+
+	data, err := os.ReadFile(absPath)
+	if err != nil {
+		return false
+	}
+
+	for _, raw := range strings.Split(string(data), "\n") {
+		for _, module := range Requires(raw) {
+			candidate := ModuleToPath(rootDir, module)
+			if candidate == "" {
+				continue
+			}
+			if filepath.Clean(candidate) == targetAbsClean {
+				return true
+			}
+			if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
+				if requiresTarget(candidate, rootDir, targetAbs, processed) {
+					return true
+				}
+			}
+		}
+	}
+
+	return false
+}
+
+func stripLineComment(line string) string {
+	inStr := byte(0)
+	esc := false
+	for i := 0; i+1 < len(line); i++ {
+		c := line[i]
+		if inStr != 0 {
+			if esc {
+				esc = false
+				continue
+			}
+			if c == '\\' && inStr == '"' {
+				esc = true
+				continue
+			}
+			if c == inStr {
+				inStr = 0
+			}
+			continue
+		}
+		switch c {
+		case '"', '\'':
+			inStr = c
+		case '-':
+			if line[i+1] == '-' {
+				return line[:i]
+			}
+		}
+	}
+	return line
+}

core/internal/luaconfig/lua_test.go

@@ -0,0 +1,56 @@
+package luaconfig
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestModuleToRelPath(t *testing.T) {
+	tests := map[string]string{
+		"dms.binds":       filepath.Join("dms", "binds.lua"),
+		"dms/binds-user":  filepath.Join("dms", "binds-user.lua"),
+		"awesome/anim":    filepath.Join("awesome", "anim.lua"),
+		"awesome.colors":  filepath.Join("awesome", "colors.lua"),
+		" awesome.binds ": filepath.Join("awesome", "binds.lua"),
+	}
+
+	for input, want := range tests {
+		if got := ModuleToRelPath(input); got != want {
+			t.Fatalf("ModuleToRelPath(%q) = %q, want %q", input, got, want)
+		}
+	}
+}
+
+func TestRequiresSkipsComments(t *testing.T) {
+	if modules := Requires(`-- require("dms.binds")`); len(modules) != 0 {
+		t.Fatalf("expected commented require to be ignored, got %#v", modules)
+	}
+
+	modules := Requires(`print("-- not a comment") require("dms.binds") -- require("ignored")`)
+	if len(modules) != 1 || modules[0] != "dms.binds" {
+		t.Fatalf("unexpected modules: %#v", modules)
+	}
+}
+
+func TestRequiresTargetRecurses(t *testing.T) {
+	tmpDir := t.TempDir()
+	dmsDir := filepath.Join(tmpDir, "dms")
+	if err := os.MkdirAll(dmsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	target := filepath.Join(dmsDir, "windowrules.lua")
+	if err := os.WriteFile(filepath.Join(tmpDir, "hyprland.lua"), []byte(`require("dms.extra")`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dmsDir, "extra.lua"), []byte(`require("dms.windowrules")`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(target, []byte(`-- rules`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if !RequiresTarget(filepath.Join(tmpDir, "hyprland.lua"), target, make(map[string]bool)) {
+		t.Fatal("expected recursive require lookup to find target")
+	}
+}

core/internal/matugen/matugen.go

@@ -47,13 +47,14 @@ type TemplateDef struct {
 	ConfigFile         string
 	Kind               TemplateKind
 	RunUnconditionally bool
+	RequiredEnv        string
 }
 
 var templateRegistry = []TemplateDef{
 	{ID: "gtk", Kind: TemplateKindGTK, RunUnconditionally: true},
 	{ID: "niri", Commands: []string{"niri"}, ConfigFile: "niri.toml"},
 	{ID: "hyprland", Commands: []string{"Hyprland"}, ConfigFile: "hyprland.toml"},
-	{ID: "mangowc", Commands: []string{"mango"}, ConfigFile: "mangowc.toml"},
+	{ID: "mangowc", Commands: []string{"mango"}, ConfigFile: "mangowc.toml", RequiredEnv: "MANGO_INSTANCE_SIGNATURE"},
 	{ID: "qt5ct", Commands: []string{"qt5ct"}, ConfigFile: "qt5ct.toml"},
 	{ID: "qt6ct", Commands: []string{"qt6ct"}, ConfigFile: "qt6ct.toml"},
 	{ID: "firefox", Commands: []string{"firefox"}, ConfigFile: "firefox.toml"},
@@ -356,6 +357,9 @@ output_path = '%s'
 		if opts.ShouldSkipTemplate(tmpl.ID) {
 			continue
 		}
+		if !templateSessionActive(tmpl) {
+			continue
+		}
 
 		switch tmpl.Kind {
 		case TemplateKindGTK:
@@ -489,6 +493,18 @@ func appendTerminalConfig(opts *Options, cfgFile *os.File, tmpDir string, checkC
 	cfgFile.WriteString("\n")
 }
 
+func templateSessionActive(tmpl TemplateDef) bool {
+	if tmpl.RequiredEnv == "" {
+		return true
+	}
+	socket := os.Getenv(tmpl.RequiredEnv)
+	if socket == "" {
+		return false
+	}
+	_, err := os.Stat(socket)
+	return err == nil
+}
+
 func appExists(checker utils.AppChecker, checkCmd []string, checkFlatpaks []string) bool {
 	// Both nil is treated as "skip check" / unconditionally run
 	if checkCmd == nil && checkFlatpaks == nil {
@@ -951,7 +967,7 @@ func CheckTemplates(checker utils.AppChecker) []TemplateCheck {
 		case tmpl.Kind == TemplateKindEmacs:
 			detected = appExists(checker, tmpl.Commands, tmpl.Flatpaks) && utils.EmacsConfigDir() != ""
 		default:
-			detected = appExists(checker, tmpl.Commands, tmpl.Flatpaks)
+			detected = appExists(checker, tmpl.Commands, tmpl.Flatpaks) && templateSessionActive(tmpl)
 		}
 
 		checks = append(checks, TemplateCheck{ID: tmpl.ID, Detected: detected})

core/internal/matugen/matugen_test.go

@@ -441,3 +441,49 @@ func TestBuildMergedConfigColorsOnly(t *testing.T) {
 	assert.NotContains(t, content, "[templates.gtk]")
 	assert.False(t, strings.Contains(content, "output_path = 'CONFIG_DIR/"), "colors-only config should not emit app template outputs")
 }
+
+func TestBuildMergedConfigSkipsMangowcWithoutActiveSession(t *testing.T) {
+	t.Setenv("MANGO_INSTANCE_SIGNATURE", "")
+
+	tempDir := t.TempDir()
+	shellDir := filepath.Join(tempDir, "shell")
+	configsDir := filepath.Join(shellDir, "matugen", "configs")
+	if err := os.MkdirAll(configsDir, 0o755); err != nil {
+		t.Fatalf("failed to create configs dir: %v", err)
+	}
+
+	if err := os.WriteFile(filepath.Join(configsDir, "base.toml"), []byte("[config]\n"), 0o644); err != nil {
+		t.Fatalf("failed to write base config: %v", err)
+	}
+	mangowcConfig := "[templates.dmsmango]\ninput_path = 'in'\noutput_path = 'out'\n"
+	if err := os.WriteFile(filepath.Join(configsDir, "mangowc.toml"), []byte(mangowcConfig), 0o644); err != nil {
+		t.Fatalf("failed to write mangowc config: %v", err)
+	}
+
+	cfgFile, err := os.CreateTemp(tempDir, "merged-*.toml")
+	if err != nil {
+		t.Fatalf("failed to create temp config: %v", err)
+	}
+	defer os.Remove(cfgFile.Name())
+	defer cfgFile.Close()
+
+	opts := &Options{
+		ShellDir:      shellDir,
+		ConfigDir:     filepath.Join(tempDir, "config"),
+		StateDir:      filepath.Join(tempDir, "state"),
+		SkipTemplates: "gtk,niri,hyprland,qt5ct,qt6ct,firefox,pywalfox,zenbrowser,vesktop,vencord,equibop,ghostty,kitty,foot,alacritty,wezterm,nvim,dgop,kcolorscheme,vscode,emacs,zed",
+	}
+
+	if err := buildMergedConfig(opts, cfgFile, filepath.Join(tempDir, "templates")); err != nil {
+		t.Fatalf("buildMergedConfig failed: %v", err)
+	}
+	if err := cfgFile.Close(); err != nil {
+		t.Fatalf("failed to close merged config: %v", err)
+	}
+
+	output, err := os.ReadFile(cfgFile.Name())
+	if err != nil {
+		t.Fatalf("failed to read merged config: %v", err)
+	}
+	assert.NotContains(t, string(output), "[templates.dmsmango]")
+}

core/internal/mocks/brightness/mock_DBusConn.go

@@ -1,12 +1,28 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks_brightness
 
 import (
-	dbus "github.com/godbus/dbus/v5"
+	"github.com/godbus/dbus/v5"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockDBusConn creates a new instance of MockDBusConn. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockDBusConn(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockDBusConn {
+	mock := &MockDBusConn{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockDBusConn is an autogenerated mock type for the DBusConn type
 type MockDBusConn struct {
 	mock.Mock
@@ -20,21 +36,20 @@ func (_m *MockDBusConn) EXPECT() *MockDBusConn_Expecter {
 	return &MockDBusConn_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with no fields
-func (_m *MockDBusConn) Close() error {
-	ret := _m.Called()
+// Close provides a mock function for the type MockDBusConn
+func (_mock *MockDBusConn) Close() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Close")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -55,8 +70,8 @@ func (_c *MockDBusConn_Close_Call) Run(run func()) *MockDBusConn_Close_Call {
 	return _c
 }
 
-func (_c *MockDBusConn_Close_Call) Return(_a0 error) *MockDBusConn_Close_Call {
-	_c.Call.Return(_a0)
+func (_c *MockDBusConn_Close_Call) Return(err error) *MockDBusConn_Close_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -65,23 +80,22 @@ func (_c *MockDBusConn_Close_Call) RunAndReturn(run func() error) *MockDBusConn_
 	return _c
 }
 
-// Object provides a mock function with given fields: dest, path
-func (_m *MockDBusConn) Object(dest string, path dbus.ObjectPath) dbus.BusObject {
-	ret := _m.Called(dest, path)
+// Object provides a mock function for the type MockDBusConn
+func (_mock *MockDBusConn) Object(dest string, path dbus.ObjectPath) dbus.BusObject {
+	ret := _mock.Called(dest, path)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Object")
 	}
 
 	var r0 dbus.BusObject
-	if rf, ok := ret.Get(0).(func(string, dbus.ObjectPath) dbus.BusObject); ok {
-		r0 = rf(dest, path)
+	if returnFunc, ok := ret.Get(0).(func(string, dbus.ObjectPath) dbus.BusObject); ok {
+		r0 = returnFunc(dest, path)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(dbus.BusObject)
 		}
 	}
-
 	return r0
 }
 
@@ -99,32 +113,28 @@ func (_e *MockDBusConn_Expecter) Object(dest any, path any) *MockDBusConn_Object
 
 func (_c *MockDBusConn_Object_Call) Run(run func(dest string, path dbus.ObjectPath)) *MockDBusConn_Object_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(dbus.ObjectPath))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 dbus.ObjectPath
+		if args[1] != nil {
+			arg1 = args[1].(dbus.ObjectPath)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *MockDBusConn_Object_Call) Return(_a0 dbus.BusObject) *MockDBusConn_Object_Call {
-	_c.Call.Return(_a0)
+func (_c *MockDBusConn_Object_Call) Return(busObject dbus.BusObject) *MockDBusConn_Object_Call {
+	_c.Call.Return(busObject)
 	return _c
 }
 
-func (_c *MockDBusConn_Object_Call) RunAndReturn(run func(string, dbus.ObjectPath) dbus.BusObject) *MockDBusConn_Object_Call {
+func (_c *MockDBusConn_Object_Call) RunAndReturn(run func(dest string, path dbus.ObjectPath) dbus.BusObject) *MockDBusConn_Object_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockDBusConn creates a new instance of MockDBusConn. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockDBusConn(t interface {
-	mock.TestingT
-	Cleanup(func())
-},
-) *MockDBusConn {
-	mock := &MockDBusConn{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/evdev/mock_EvdevDevice.go

@@ -1,12 +1,28 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks_evdev
 
 import (
-	go_evdev "github.com/holoplot/go-evdev"
+	"github.com/holoplot/go-evdev"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockEvdevDevice creates a new instance of MockEvdevDevice. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockEvdevDevice(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockEvdevDevice {
+	mock := &MockEvdevDevice{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockEvdevDevice is an autogenerated mock type for the EvdevDevice type
 type MockEvdevDevice struct {
 	mock.Mock
@@ -20,21 +36,20 @@ func (_m *MockEvdevDevice) EXPECT() *MockEvdevDevice_Expecter {
 	return &MockEvdevDevice_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with no fields
-func (_m *MockEvdevDevice) Close() error {
-	ret := _m.Called()
+// Close provides a mock function for the type MockEvdevDevice
+func (_mock *MockEvdevDevice) Close() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Close")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -55,8 +70,8 @@ func (_c *MockEvdevDevice_Close_Call) Run(run func()) *MockEvdevDevice_Close_Cal
 	return _c
 }
 
-func (_c *MockEvdevDevice_Close_Call) Return(_a0 error) *MockEvdevDevice_Close_Call {
-	_c.Call.Return(_a0)
+func (_c *MockEvdevDevice_Close_Call) Return(err error) *MockEvdevDevice_Close_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -65,9 +80,9 @@ func (_c *MockEvdevDevice_Close_Call) RunAndReturn(run func() error) *MockEvdevD
 	return _c
 }
 
-// Name provides a mock function with no fields
-func (_m *MockEvdevDevice) Name() (string, error) {
-	ret := _m.Called()
+// Name provides a mock function for the type MockEvdevDevice
+func (_mock *MockEvdevDevice) Name() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Name")
@@ -75,21 +90,19 @@ func (_m *MockEvdevDevice) Name() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -110,8 +123,8 @@ func (_c *MockEvdevDevice_Name_Call) Run(run func()) *MockEvdevDevice_Name_Call
 	return _c
 }
 
-func (_c *MockEvdevDevice_Name_Call) Return(_a0 string, _a1 error) *MockEvdevDevice_Name_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockEvdevDevice_Name_Call) Return(s string, err error) *MockEvdevDevice_Name_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -120,21 +133,20 @@ func (_c *MockEvdevDevice_Name_Call) RunAndReturn(run func() (string, error)) *M
 	return _c
 }
 
-// Path provides a mock function with no fields
-func (_m *MockEvdevDevice) Path() string {
-	ret := _m.Called()
+// Path provides a mock function for the type MockEvdevDevice
+func (_mock *MockEvdevDevice) Path() string {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Path")
 	}
 
 	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
 	return r0
 }
 
@@ -155,8 +167,8 @@ func (_c *MockEvdevDevice_Path_Call) Run(run func()) *MockEvdevDevice_Path_Call
 	return _c
 }
 
-func (_c *MockEvdevDevice_Path_Call) Return(_a0 string) *MockEvdevDevice_Path_Call {
-	_c.Call.Return(_a0)
+func (_c *MockEvdevDevice_Path_Call) Return(s string) *MockEvdevDevice_Path_Call {
+	_c.Call.Return(s)
 	return _c
 }
 
@@ -165,33 +177,31 @@ func (_c *MockEvdevDevice_Path_Call) RunAndReturn(run func() string) *MockEvdevD
 	return _c
 }
 
-// ReadOne provides a mock function with no fields
-func (_m *MockEvdevDevice) ReadOne() (*go_evdev.InputEvent, error) {
-	ret := _m.Called()
+// ReadOne provides a mock function for the type MockEvdevDevice
+func (_mock *MockEvdevDevice) ReadOne() (*evdev.InputEvent, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for ReadOne")
 	}
 
-	var r0 *go_evdev.InputEvent
+	var r0 *evdev.InputEvent
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (*go_evdev.InputEvent, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (*evdev.InputEvent, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() *go_evdev.InputEvent); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() *evdev.InputEvent); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*go_evdev.InputEvent)
+			r0 = ret.Get(0).(*evdev.InputEvent)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -212,43 +222,41 @@ func (_c *MockEvdevDevice_ReadOne_Call) Run(run func()) *MockEvdevDevice_ReadOne
 	return _c
 }
 
-func (_c *MockEvdevDevice_ReadOne_Call) Return(_a0 *go_evdev.InputEvent, _a1 error) *MockEvdevDevice_ReadOne_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockEvdevDevice_ReadOne_Call) Return(inputEvent *evdev.InputEvent, err error) *MockEvdevDevice_ReadOne_Call {
+	_c.Call.Return(inputEvent, err)
 	return _c
 }
 
-func (_c *MockEvdevDevice_ReadOne_Call) RunAndReturn(run func() (*go_evdev.InputEvent, error)) *MockEvdevDevice_ReadOne_Call {
+func (_c *MockEvdevDevice_ReadOne_Call) RunAndReturn(run func() (*evdev.InputEvent, error)) *MockEvdevDevice_ReadOne_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// State provides a mock function with given fields: t
-func (_m *MockEvdevDevice) State(t go_evdev.EvType) (go_evdev.StateMap, error) {
-	ret := _m.Called(t)
+// State provides a mock function for the type MockEvdevDevice
+func (_mock *MockEvdevDevice) State(t evdev.EvType) (evdev.StateMap, error) {
+	ret := _mock.Called(t)
 
 	if len(ret) == 0 {
 		panic("no return value specified for State")
 	}
 
-	var r0 go_evdev.StateMap
+	var r0 evdev.StateMap
 	var r1 error
-	if rf, ok := ret.Get(0).(func(go_evdev.EvType) (go_evdev.StateMap, error)); ok {
-		return rf(t)
+	if returnFunc, ok := ret.Get(0).(func(evdev.EvType) (evdev.StateMap, error)); ok {
+		return returnFunc(t)
 	}
-	if rf, ok := ret.Get(0).(func(go_evdev.EvType) go_evdev.StateMap); ok {
-		r0 = rf(t)
+	if returnFunc, ok := ret.Get(0).(func(evdev.EvType) evdev.StateMap); ok {
+		r0 = returnFunc(t)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(go_evdev.StateMap)
+			r0 = ret.Get(0).(evdev.StateMap)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(go_evdev.EvType) error); ok {
-		r1 = rf(t)
+	if returnFunc, ok := ret.Get(1).(func(evdev.EvType) error); ok {
+		r1 = returnFunc(t)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -258,38 +266,30 @@ type MockEvdevDevice_State_Call struct {
 }
 
 // State is a helper method to define mock.On call
-//   - t go_evdev.EvType
-func (_e *MockEvdevDevice_Expecter) State(t interface{}) *MockEvdevDevice_State_Call {
+//   - t evdev.EvType
+func (_e *MockEvdevDevice_Expecter) State(t any) *MockEvdevDevice_State_Call {
 	return &MockEvdevDevice_State_Call{Call: _e.mock.On("State", t)}
 }
 
-func (_c *MockEvdevDevice_State_Call) Run(run func(t go_evdev.EvType)) *MockEvdevDevice_State_Call {
+func (_c *MockEvdevDevice_State_Call) Run(run func(t evdev.EvType)) *MockEvdevDevice_State_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(go_evdev.EvType))
+		var arg0 evdev.EvType
+		if args[0] != nil {
+			arg0 = args[0].(evdev.EvType)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockEvdevDevice_State_Call) Return(_a0 go_evdev.StateMap, _a1 error) *MockEvdevDevice_State_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockEvdevDevice_State_Call) Return(stateMap evdev.StateMap, err error) *MockEvdevDevice_State_Call {
+	_c.Call.Return(stateMap, err)
 	return _c
 }
 
-func (_c *MockEvdevDevice_State_Call) RunAndReturn(run func(go_evdev.EvType) (go_evdev.StateMap, error)) *MockEvdevDevice_State_Call {
+func (_c *MockEvdevDevice_State_Call) RunAndReturn(run func(t evdev.EvType) (evdev.StateMap, error)) *MockEvdevDevice_State_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockEvdevDevice creates a new instance of MockEvdevDevice. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockEvdevDevice(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockEvdevDevice {
-	mock := &MockEvdevDevice{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/geolocation/mock_Client.go

@@ -1,12 +1,28 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks_geolocation
 
 import (
-	geolocation "github.com/AvengeMedia/DankMaterialShell/core/internal/geolocation"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/geolocation"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockClient {
+	mock := &MockClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockClient is an autogenerated mock type for the Client type
 type MockClient struct {
 	mock.Mock
@@ -20,9 +36,10 @@ func (_m *MockClient) EXPECT() *MockClient_Expecter {
 	return &MockClient_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with no fields
-func (_m *MockClient) Close() {
-	_m.Called()
+// Close provides a mock function for the type MockClient
+func (_mock *MockClient) Close() {
+	_mock.Called()
+	return
 }
 
 // MockClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
@@ -52,9 +69,9 @@ func (_c *MockClient_Close_Call) RunAndReturn(run func()) *MockClient_Close_Call
 	return _c
 }
 
-// GetLocation provides a mock function with no fields
-func (_m *MockClient) GetLocation() (geolocation.Location, error) {
-	ret := _m.Called()
+// GetLocation provides a mock function for the type MockClient
+func (_mock *MockClient) GetLocation() (geolocation.Location, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetLocation")
@@ -62,21 +79,19 @@ func (_m *MockClient) GetLocation() (geolocation.Location, error) {
 
 	var r0 geolocation.Location
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (geolocation.Location, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (geolocation.Location, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() geolocation.Location); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() geolocation.Location); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(geolocation.Location)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -97,8 +112,8 @@ func (_c *MockClient_GetLocation_Call) Run(run func()) *MockClient_GetLocation_C
 	return _c
 }
 
-func (_c *MockClient_GetLocation_Call) Return(_a0 geolocation.Location, _a1 error) *MockClient_GetLocation_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockClient_GetLocation_Call) Return(location geolocation.Location, err error) *MockClient_GetLocation_Call {
+	_c.Call.Return(location, err)
 	return _c
 }
 
@@ -107,23 +122,22 @@ func (_c *MockClient_GetLocation_Call) RunAndReturn(run func() (geolocation.Loca
 	return _c
 }
 
-// Subscribe provides a mock function with given fields: id
-func (_m *MockClient) Subscribe(id string) chan geolocation.Location {
-	ret := _m.Called(id)
+// Subscribe provides a mock function for the type MockClient
+func (_mock *MockClient) Subscribe(id string) chan geolocation.Location {
+	ret := _mock.Called(id)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Subscribe")
 	}
 
 	var r0 chan geolocation.Location
-	if rf, ok := ret.Get(0).(func(string) chan geolocation.Location); ok {
-		r0 = rf(id)
+	if returnFunc, ok := ret.Get(0).(func(string) chan geolocation.Location); ok {
+		r0 = returnFunc(id)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(chan geolocation.Location)
 		}
 	}
-
 	return r0
 }
 
@@ -134,30 +148,37 @@ type MockClient_Subscribe_Call struct {
 
 // Subscribe is a helper method to define mock.On call
 //   - id string
-func (_e *MockClient_Expecter) Subscribe(id interface{}) *MockClient_Subscribe_Call {
+func (_e *MockClient_Expecter) Subscribe(id any) *MockClient_Subscribe_Call {
 	return &MockClient_Subscribe_Call{Call: _e.mock.On("Subscribe", id)}
 }
 
 func (_c *MockClient_Subscribe_Call) Run(run func(id string)) *MockClient_Subscribe_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockClient_Subscribe_Call) Return(_a0 chan geolocation.Location) *MockClient_Subscribe_Call {
-	_c.Call.Return(_a0)
+func (_c *MockClient_Subscribe_Call) Return(locationCh chan geolocation.Location) *MockClient_Subscribe_Call {
+	_c.Call.Return(locationCh)
 	return _c
 }
 
-func (_c *MockClient_Subscribe_Call) RunAndReturn(run func(string) chan geolocation.Location) *MockClient_Subscribe_Call {
+func (_c *MockClient_Subscribe_Call) RunAndReturn(run func(id string) chan geolocation.Location) *MockClient_Subscribe_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Unsubscribe provides a mock function with given fields: id
-func (_m *MockClient) Unsubscribe(id string) {
-	_m.Called(id)
+// Unsubscribe provides a mock function for the type MockClient
+func (_mock *MockClient) Unsubscribe(id string) {
+	_mock.Called(id)
+	return
 }
 
 // MockClient_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe'
@@ -167,13 +188,19 @@ type MockClient_Unsubscribe_Call struct {
 
 // Unsubscribe is a helper method to define mock.On call
 //   - id string
-func (_e *MockClient_Expecter) Unsubscribe(id interface{}) *MockClient_Unsubscribe_Call {
+func (_e *MockClient_Expecter) Unsubscribe(id any) *MockClient_Unsubscribe_Call {
 	return &MockClient_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe", id)}
 }
 
 func (_c *MockClient_Unsubscribe_Call) Run(run func(id string)) *MockClient_Unsubscribe_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -183,21 +210,7 @@ func (_c *MockClient_Unsubscribe_Call) Return() *MockClient_Unsubscribe_Call {
 	return _c
 }
 
-func (_c *MockClient_Unsubscribe_Call) RunAndReturn(run func(string)) *MockClient_Unsubscribe_Call {
+func (_c *MockClient_Unsubscribe_Call) RunAndReturn(run func(id string)) *MockClient_Unsubscribe_Call {
 	_c.Run(run)
 	return _c
 }
-
-// NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockClient {
-	mock := &MockClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_AccessPoint.go

@@ -1,14 +1,29 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package gonetworkmanager
 
 import (
-	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
-	dbus "github.com/godbus/dbus/v5"
-
+	"github.com/Wifx/gonetworkmanager/v2"
+	"github.com/godbus/dbus/v5"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockAccessPoint creates a new instance of MockAccessPoint. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockAccessPoint(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockAccessPoint {
+	mock := &MockAccessPoint{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockAccessPoint is an autogenerated mock type for the AccessPoint type
 type MockAccessPoint struct {
 	mock.Mock
@@ -22,21 +37,20 @@ func (_m *MockAccessPoint) EXPECT() *MockAccessPoint_Expecter {
 	return &MockAccessPoint_Expecter{mock: &_m.Mock}
 }
 
-// GetPath provides a mock function with no fields
-func (_m *MockAccessPoint) GetPath() dbus.ObjectPath {
-	ret := _m.Called()
+// GetPath provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPath() dbus.ObjectPath {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPath")
 	}
 
 	var r0 dbus.ObjectPath
-	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(dbus.ObjectPath)
 	}
-
 	return r0
 }
 
@@ -57,8 +71,8 @@ func (_c *MockAccessPoint_GetPath_Call) Run(run func()) *MockAccessPoint_GetPath
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockAccessPoint_GetPath_Call {
-	_c.Call.Return(_a0)
+func (_c *MockAccessPoint_GetPath_Call) Return(objectPath dbus.ObjectPath) *MockAccessPoint_GetPath_Call {
+	_c.Call.Return(objectPath)
 	return _c
 }
 
@@ -67,9 +81,9 @@ func (_c *MockAccessPoint_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath)
 	return _c
 }
 
-// GetPropertyFlags provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyFlags() (uint32, error) {
-	ret := _m.Called()
+// GetPropertyFlags provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyFlags() (uint32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyFlags")
@@ -77,21 +91,19 @@ func (_m *MockAccessPoint) GetPropertyFlags() (uint32, error) {
 
 	var r0 uint32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -112,8 +124,8 @@ func (_c *MockAccessPoint_GetPropertyFlags_Call) Run(run func()) *MockAccessPoin
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyFlags_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyFlags_Call) Return(v uint32, err error) *MockAccessPoint_GetPropertyFlags_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -122,9 +134,9 @@ func (_c *MockAccessPoint_GetPropertyFlags_Call) RunAndReturn(run func() (uint32
 	return _c
 }
 
-// GetPropertyFrequency provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyFrequency() (uint32, error) {
-	ret := _m.Called()
+// GetPropertyFrequency provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyFrequency() (uint32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyFrequency")
@@ -132,21 +144,19 @@ func (_m *MockAccessPoint) GetPropertyFrequency() (uint32, error) {
 
 	var r0 uint32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -167,8 +177,8 @@ func (_c *MockAccessPoint_GetPropertyFrequency_Call) Run(run func()) *MockAccess
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyFrequency_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyFrequency_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyFrequency_Call) Return(v uint32, err error) *MockAccessPoint_GetPropertyFrequency_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -177,9 +187,9 @@ func (_c *MockAccessPoint_GetPropertyFrequency_Call) RunAndReturn(run func() (ui
 	return _c
 }
 
-// GetPropertyHWAddress provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyHWAddress() (string, error) {
-	ret := _m.Called()
+// GetPropertyHWAddress provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyHWAddress() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyHWAddress")
@@ -187,21 +197,19 @@ func (_m *MockAccessPoint) GetPropertyHWAddress() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -222,8 +230,8 @@ func (_c *MockAccessPoint_GetPropertyHWAddress_Call) Run(run func()) *MockAccess
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyHWAddress_Call) Return(_a0 string, _a1 error) *MockAccessPoint_GetPropertyHWAddress_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyHWAddress_Call) Return(s string, err error) *MockAccessPoint_GetPropertyHWAddress_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -232,9 +240,9 @@ func (_c *MockAccessPoint_GetPropertyHWAddress_Call) RunAndReturn(run func() (st
 	return _c
 }
 
-// GetPropertyLastSeen provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyLastSeen() (int32, error) {
-	ret := _m.Called()
+// GetPropertyLastSeen provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyLastSeen() (int32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyLastSeen")
@@ -242,21 +250,19 @@ func (_m *MockAccessPoint) GetPropertyLastSeen() (int32, error) {
 
 	var r0 int32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (int32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (int32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() int32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() int32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(int32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -277,8 +283,8 @@ func (_c *MockAccessPoint_GetPropertyLastSeen_Call) Run(run func()) *MockAccessP
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyLastSeen_Call) Return(_a0 int32, _a1 error) *MockAccessPoint_GetPropertyLastSeen_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyLastSeen_Call) Return(n int32, err error) *MockAccessPoint_GetPropertyLastSeen_Call {
+	_c.Call.Return(n, err)
 	return _c
 }
 
@@ -287,9 +293,9 @@ func (_c *MockAccessPoint_GetPropertyLastSeen_Call) RunAndReturn(run func() (int
 	return _c
 }
 
-// GetPropertyMaxBitrate provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyMaxBitrate() (uint32, error) {
-	ret := _m.Called()
+// GetPropertyMaxBitrate provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyMaxBitrate() (uint32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyMaxBitrate")
@@ -297,21 +303,19 @@ func (_m *MockAccessPoint) GetPropertyMaxBitrate() (uint32, error) {
 
 	var r0 uint32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -332,8 +336,8 @@ func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) Run(run func()) *MockAcces
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyMaxBitrate_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) Return(v uint32, err error) *MockAccessPoint_GetPropertyMaxBitrate_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -342,9 +346,9 @@ func (_c *MockAccessPoint_GetPropertyMaxBitrate_Call) RunAndReturn(run func() (u
 	return _c
 }
 
-// GetPropertyMode provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyMode() (gonetworkmanager.Nm80211Mode, error) {
-	ret := _m.Called()
+// GetPropertyMode provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyMode() (gonetworkmanager.Nm80211Mode, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyMode")
@@ -352,21 +356,19 @@ func (_m *MockAccessPoint) GetPropertyMode() (gonetworkmanager.Nm80211Mode, erro
 
 	var r0 gonetworkmanager.Nm80211Mode
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.Nm80211Mode, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.Nm80211Mode, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.Nm80211Mode); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.Nm80211Mode); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(gonetworkmanager.Nm80211Mode)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -387,8 +389,8 @@ func (_c *MockAccessPoint_GetPropertyMode_Call) Run(run func()) *MockAccessPoint
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyMode_Call) Return(_a0 gonetworkmanager.Nm80211Mode, _a1 error) *MockAccessPoint_GetPropertyMode_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyMode_Call) Return(nm80211Mode gonetworkmanager.Nm80211Mode, err error) *MockAccessPoint_GetPropertyMode_Call {
+	_c.Call.Return(nm80211Mode, err)
 	return _c
 }
 
@@ -397,9 +399,9 @@ func (_c *MockAccessPoint_GetPropertyMode_Call) RunAndReturn(run func() (gonetwo
 	return _c
 }
 
-// GetPropertyRSNFlags provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyRSNFlags() (uint32, error) {
-	ret := _m.Called()
+// GetPropertyRSNFlags provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyRSNFlags() (uint32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyRSNFlags")
@@ -407,21 +409,19 @@ func (_m *MockAccessPoint) GetPropertyRSNFlags() (uint32, error) {
 
 	var r0 uint32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -442,8 +442,8 @@ func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) Run(run func()) *MockAccessP
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyRSNFlags_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) Return(v uint32, err error) *MockAccessPoint_GetPropertyRSNFlags_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -452,9 +452,9 @@ func (_c *MockAccessPoint_GetPropertyRSNFlags_Call) RunAndReturn(run func() (uin
 	return _c
 }
 
-// GetPropertySSID provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertySSID() (string, error) {
-	ret := _m.Called()
+// GetPropertySSID provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertySSID() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertySSID")
@@ -462,21 +462,19 @@ func (_m *MockAccessPoint) GetPropertySSID() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -497,8 +495,8 @@ func (_c *MockAccessPoint_GetPropertySSID_Call) Run(run func()) *MockAccessPoint
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertySSID_Call) Return(_a0 string, _a1 error) *MockAccessPoint_GetPropertySSID_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertySSID_Call) Return(s string, err error) *MockAccessPoint_GetPropertySSID_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -507,9 +505,9 @@ func (_c *MockAccessPoint_GetPropertySSID_Call) RunAndReturn(run func() (string,
 	return _c
 }
 
-// GetPropertyStrength provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyStrength() (uint8, error) {
-	ret := _m.Called()
+// GetPropertyStrength provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyStrength() (uint8, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyStrength")
@@ -517,21 +515,19 @@ func (_m *MockAccessPoint) GetPropertyStrength() (uint8, error) {
 
 	var r0 uint8
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint8, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint8, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint8); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint8); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint8)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -552,8 +548,8 @@ func (_c *MockAccessPoint_GetPropertyStrength_Call) Run(run func()) *MockAccessP
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyStrength_Call) Return(_a0 uint8, _a1 error) *MockAccessPoint_GetPropertyStrength_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyStrength_Call) Return(v uint8, err error) *MockAccessPoint_GetPropertyStrength_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -562,9 +558,9 @@ func (_c *MockAccessPoint_GetPropertyStrength_Call) RunAndReturn(run func() (uin
 	return _c
 }
 
-// GetPropertyWPAFlags provides a mock function with no fields
-func (_m *MockAccessPoint) GetPropertyWPAFlags() (uint32, error) {
-	ret := _m.Called()
+// GetPropertyWPAFlags provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) GetPropertyWPAFlags() (uint32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyWPAFlags")
@@ -572,21 +568,19 @@ func (_m *MockAccessPoint) GetPropertyWPAFlags() (uint32, error) {
 
 	var r0 uint32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -607,8 +601,8 @@ func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) Run(run func()) *MockAccessP
 	return _c
 }
 
-func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) Return(_a0 uint32, _a1 error) *MockAccessPoint_GetPropertyWPAFlags_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) Return(v uint32, err error) *MockAccessPoint_GetPropertyWPAFlags_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -617,9 +611,9 @@ func (_c *MockAccessPoint_GetPropertyWPAFlags_Call) RunAndReturn(run func() (uin
 	return _c
 }
 
-// MarshalJSON provides a mock function with no fields
-func (_m *MockAccessPoint) MarshalJSON() ([]byte, error) {
-	ret := _m.Called()
+// MarshalJSON provides a mock function for the type MockAccessPoint
+func (_mock *MockAccessPoint) MarshalJSON() ([]byte, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for MarshalJSON")
@@ -627,23 +621,21 @@ func (_m *MockAccessPoint) MarshalJSON() ([]byte, error) {
 
 	var r0 []byte
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []byte); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []byte); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]byte)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -664,8 +656,8 @@ func (_c *MockAccessPoint_MarshalJSON_Call) Run(run func()) *MockAccessPoint_Mar
 	return _c
 }
 
-func (_c *MockAccessPoint_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockAccessPoint_MarshalJSON_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockAccessPoint_MarshalJSON_Call) Return(bytes []byte, err error) *MockAccessPoint_MarshalJSON_Call {
+	_c.Call.Return(bytes, err)
 	return _c
 }
 
@@ -673,17 +665,3 @@ func (_c *MockAccessPoint_MarshalJSON_Call) RunAndReturn(run func() ([]byte, err
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockAccessPoint creates a new instance of MockAccessPoint. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockAccessPoint(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockAccessPoint {
-	mock := &MockAccessPoint{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_ActiveConnection.go

@@ -1,14 +1,29 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package gonetworkmanager
 
 import (
-	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
-	dbus "github.com/godbus/dbus/v5"
-
+	"github.com/Wifx/gonetworkmanager/v2"
+	"github.com/godbus/dbus/v5"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockActiveConnection creates a new instance of MockActiveConnection. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockActiveConnection(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockActiveConnection {
+	mock := &MockActiveConnection{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockActiveConnection is an autogenerated mock type for the ActiveConnection type
 type MockActiveConnection struct {
 	mock.Mock
@@ -22,21 +37,20 @@ func (_m *MockActiveConnection) EXPECT() *MockActiveConnection_Expecter {
 	return &MockActiveConnection_Expecter{mock: &_m.Mock}
 }
 
-// GetPath provides a mock function with no fields
-func (_m *MockActiveConnection) GetPath() dbus.ObjectPath {
-	ret := _m.Called()
+// GetPath provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPath() dbus.ObjectPath {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPath")
 	}
 
 	var r0 dbus.ObjectPath
-	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(dbus.ObjectPath)
 	}
-
 	return r0
 }
 
@@ -57,8 +71,8 @@ func (_c *MockActiveConnection_GetPath_Call) Run(run func()) *MockActiveConnecti
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockActiveConnection_GetPath_Call {
-	_c.Call.Return(_a0)
+func (_c *MockActiveConnection_GetPath_Call) Return(objectPath dbus.ObjectPath) *MockActiveConnection_GetPath_Call {
+	_c.Call.Return(objectPath)
 	return _c
 }
 
@@ -67,9 +81,9 @@ func (_c *MockActiveConnection_GetPath_Call) RunAndReturn(run func() dbus.Object
 	return _c
 }
 
-// GetPropertyConnection provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyConnection() (gonetworkmanager.Connection, error) {
-	ret := _m.Called()
+// GetPropertyConnection provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyConnection() (gonetworkmanager.Connection, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyConnection")
@@ -77,23 +91,21 @@ func (_m *MockActiveConnection) GetPropertyConnection() (gonetworkmanager.Connec
 
 	var r0 gonetworkmanager.Connection
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.Connection, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.Connection, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.Connection); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.Connection); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.Connection)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -114,8 +126,8 @@ func (_c *MockActiveConnection_GetPropertyConnection_Call) Run(run func()) *Mock
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyConnection_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockActiveConnection_GetPropertyConnection_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyConnection_Call) Return(connection gonetworkmanager.Connection, err error) *MockActiveConnection_GetPropertyConnection_Call {
+	_c.Call.Return(connection, err)
 	return _c
 }
 
@@ -124,9 +136,9 @@ func (_c *MockActiveConnection_GetPropertyConnection_Call) RunAndReturn(run func
 	return _c
 }
 
-// GetPropertyDHCP4Config provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4Config, error) {
-	ret := _m.Called()
+// GetPropertyDHCP4Config provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4Config, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyDHCP4Config")
@@ -134,23 +146,21 @@ func (_m *MockActiveConnection) GetPropertyDHCP4Config() (gonetworkmanager.DHCP4
 
 	var r0 gonetworkmanager.DHCP4Config
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP4Config, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.DHCP4Config, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP4Config); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.DHCP4Config); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.DHCP4Config)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -171,8 +181,8 @@ func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) Run(run func()) *Moc
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) Return(_a0 gonetworkmanager.DHCP4Config, _a1 error) *MockActiveConnection_GetPropertyDHCP4Config_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) Return(dHCP4Config gonetworkmanager.DHCP4Config, err error) *MockActiveConnection_GetPropertyDHCP4Config_Call {
+	_c.Call.Return(dHCP4Config, err)
 	return _c
 }
 
@@ -181,9 +191,9 @@ func (_c *MockActiveConnection_GetPropertyDHCP4Config_Call) RunAndReturn(run fun
 	return _c
 }
 
-// GetPropertyDHCP6Config provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6Config, error) {
-	ret := _m.Called()
+// GetPropertyDHCP6Config provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6Config, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyDHCP6Config")
@@ -191,23 +201,21 @@ func (_m *MockActiveConnection) GetPropertyDHCP6Config() (gonetworkmanager.DHCP6
 
 	var r0 gonetworkmanager.DHCP6Config
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.DHCP6Config, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.DHCP6Config, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.DHCP6Config); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.DHCP6Config); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.DHCP6Config)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -228,8 +236,8 @@ func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) Run(run func()) *Moc
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) Return(_a0 gonetworkmanager.DHCP6Config, _a1 error) *MockActiveConnection_GetPropertyDHCP6Config_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) Return(dHCP6Config gonetworkmanager.DHCP6Config, err error) *MockActiveConnection_GetPropertyDHCP6Config_Call {
+	_c.Call.Return(dHCP6Config, err)
 	return _c
 }
 
@@ -238,9 +246,9 @@ func (_c *MockActiveConnection_GetPropertyDHCP6Config_Call) RunAndReturn(run fun
 	return _c
 }
 
-// GetPropertyDefault provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyDefault() (bool, error) {
-	ret := _m.Called()
+// GetPropertyDefault provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyDefault() (bool, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyDefault")
@@ -248,21 +256,19 @@ func (_m *MockActiveConnection) GetPropertyDefault() (bool, error) {
 
 	var r0 bool
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (bool, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -283,8 +289,8 @@ func (_c *MockActiveConnection_GetPropertyDefault_Call) Run(run func()) *MockAct
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyDefault_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyDefault_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyDefault_Call) Return(b bool, err error) *MockActiveConnection_GetPropertyDefault_Call {
+	_c.Call.Return(b, err)
 	return _c
 }
 
@@ -293,9 +299,9 @@ func (_c *MockActiveConnection_GetPropertyDefault_Call) RunAndReturn(run func()
 	return _c
 }
 
-// GetPropertyDefault6 provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyDefault6() (bool, error) {
-	ret := _m.Called()
+// GetPropertyDefault6 provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyDefault6() (bool, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyDefault6")
@@ -303,21 +309,19 @@ func (_m *MockActiveConnection) GetPropertyDefault6() (bool, error) {
 
 	var r0 bool
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (bool, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -338,8 +342,8 @@ func (_c *MockActiveConnection_GetPropertyDefault6_Call) Run(run func()) *MockAc
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyDefault6_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyDefault6_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyDefault6_Call) Return(b bool, err error) *MockActiveConnection_GetPropertyDefault6_Call {
+	_c.Call.Return(b, err)
 	return _c
 }
 
@@ -348,9 +352,9 @@ func (_c *MockActiveConnection_GetPropertyDefault6_Call) RunAndReturn(run func()
 	return _c
 }
 
-// GetPropertyDevices provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyDevices() ([]gonetworkmanager.Device, error) {
-	ret := _m.Called()
+// GetPropertyDevices provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyDevices() ([]gonetworkmanager.Device, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyDevices")
@@ -358,23 +362,21 @@ func (_m *MockActiveConnection) GetPropertyDevices() ([]gonetworkmanager.Device,
 
 	var r0 []gonetworkmanager.Device
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.Device, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.Device); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]gonetworkmanager.Device)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -395,8 +397,8 @@ func (_c *MockActiveConnection_GetPropertyDevices_Call) Run(run func()) *MockAct
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyDevices_Call) Return(_a0 []gonetworkmanager.Device, _a1 error) *MockActiveConnection_GetPropertyDevices_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyDevices_Call) Return(devices []gonetworkmanager.Device, err error) *MockActiveConnection_GetPropertyDevices_Call {
+	_c.Call.Return(devices, err)
 	return _c
 }
 
@@ -405,9 +407,9 @@ func (_c *MockActiveConnection_GetPropertyDevices_Call) RunAndReturn(run func()
 	return _c
 }
 
-// GetPropertyID provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyID() (string, error) {
-	ret := _m.Called()
+// GetPropertyID provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyID() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyID")
@@ -415,21 +417,19 @@ func (_m *MockActiveConnection) GetPropertyID() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -450,8 +450,8 @@ func (_c *MockActiveConnection_GetPropertyID_Call) Run(run func()) *MockActiveCo
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyID_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyID_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyID_Call) Return(s string, err error) *MockActiveConnection_GetPropertyID_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -460,9 +460,9 @@ func (_c *MockActiveConnection_GetPropertyID_Call) RunAndReturn(run func() (stri
 	return _c
 }
 
-// GetPropertyIP4Config provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyIP4Config() (gonetworkmanager.IP4Config, error) {
-	ret := _m.Called()
+// GetPropertyIP4Config provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyIP4Config() (gonetworkmanager.IP4Config, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyIP4Config")
@@ -470,23 +470,21 @@ func (_m *MockActiveConnection) GetPropertyIP4Config() (gonetworkmanager.IP4Conf
 
 	var r0 gonetworkmanager.IP4Config
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP4Config, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.IP4Config, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.IP4Config); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.IP4Config); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.IP4Config)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -507,8 +505,8 @@ func (_c *MockActiveConnection_GetPropertyIP4Config_Call) Run(run func()) *MockA
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyIP4Config_Call) Return(_a0 gonetworkmanager.IP4Config, _a1 error) *MockActiveConnection_GetPropertyIP4Config_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyIP4Config_Call) Return(iP4Config gonetworkmanager.IP4Config, err error) *MockActiveConnection_GetPropertyIP4Config_Call {
+	_c.Call.Return(iP4Config, err)
 	return _c
 }
 
@@ -517,9 +515,9 @@ func (_c *MockActiveConnection_GetPropertyIP4Config_Call) RunAndReturn(run func(
 	return _c
 }
 
-// GetPropertyIP6Config provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyIP6Config() (gonetworkmanager.IP6Config, error) {
-	ret := _m.Called()
+// GetPropertyIP6Config provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyIP6Config() (gonetworkmanager.IP6Config, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyIP6Config")
@@ -527,23 +525,21 @@ func (_m *MockActiveConnection) GetPropertyIP6Config() (gonetworkmanager.IP6Conf
 
 	var r0 gonetworkmanager.IP6Config
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.IP6Config, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.IP6Config, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.IP6Config); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.IP6Config); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.IP6Config)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -564,8 +560,8 @@ func (_c *MockActiveConnection_GetPropertyIP6Config_Call) Run(run func()) *MockA
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyIP6Config_Call) Return(_a0 gonetworkmanager.IP6Config, _a1 error) *MockActiveConnection_GetPropertyIP6Config_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyIP6Config_Call) Return(iP6Config gonetworkmanager.IP6Config, err error) *MockActiveConnection_GetPropertyIP6Config_Call {
+	_c.Call.Return(iP6Config, err)
 	return _c
 }
 
@@ -574,9 +570,9 @@ func (_c *MockActiveConnection_GetPropertyIP6Config_Call) RunAndReturn(run func(
 	return _c
 }
 
-// GetPropertyMaster provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyMaster() (gonetworkmanager.Device, error) {
-	ret := _m.Called()
+// GetPropertyMaster provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyMaster() (gonetworkmanager.Device, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyMaster")
@@ -584,23 +580,21 @@ func (_m *MockActiveConnection) GetPropertyMaster() (gonetworkmanager.Device, er
 
 	var r0 gonetworkmanager.Device
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.Device, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.Device, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.Device); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.Device); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.Device)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -621,8 +615,8 @@ func (_c *MockActiveConnection_GetPropertyMaster_Call) Run(run func()) *MockActi
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyMaster_Call) Return(_a0 gonetworkmanager.Device, _a1 error) *MockActiveConnection_GetPropertyMaster_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyMaster_Call) Return(device gonetworkmanager.Device, err error) *MockActiveConnection_GetPropertyMaster_Call {
+	_c.Call.Return(device, err)
 	return _c
 }
 
@@ -631,9 +625,9 @@ func (_c *MockActiveConnection_GetPropertyMaster_Call) RunAndReturn(run func() (
 	return _c
 }
 
-// GetPropertySpecificObject provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertySpecificObject() (gonetworkmanager.AccessPoint, error) {
-	ret := _m.Called()
+// GetPropertySpecificObject provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertySpecificObject() (gonetworkmanager.AccessPoint, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertySpecificObject")
@@ -641,23 +635,21 @@ func (_m *MockActiveConnection) GetPropertySpecificObject() (gonetworkmanager.Ac
 
 	var r0 gonetworkmanager.AccessPoint
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.AccessPoint, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.AccessPoint, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.AccessPoint); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.AccessPoint); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.AccessPoint)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -678,8 +670,8 @@ func (_c *MockActiveConnection_GetPropertySpecificObject_Call) Run(run func()) *
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertySpecificObject_Call) Return(_a0 gonetworkmanager.AccessPoint, _a1 error) *MockActiveConnection_GetPropertySpecificObject_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertySpecificObject_Call) Return(accessPoint gonetworkmanager.AccessPoint, err error) *MockActiveConnection_GetPropertySpecificObject_Call {
+	_c.Call.Return(accessPoint, err)
 	return _c
 }
 
@@ -688,9 +680,9 @@ func (_c *MockActiveConnection_GetPropertySpecificObject_Call) RunAndReturn(run
 	return _c
 }
 
-// GetPropertyState provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyState() (gonetworkmanager.NmActiveConnectionState, error) {
-	ret := _m.Called()
+// GetPropertyState provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyState() (gonetworkmanager.NmActiveConnectionState, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyState")
@@ -698,21 +690,19 @@ func (_m *MockActiveConnection) GetPropertyState() (gonetworkmanager.NmActiveCon
 
 	var r0 gonetworkmanager.NmActiveConnectionState
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.NmActiveConnectionState, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.NmActiveConnectionState, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.NmActiveConnectionState); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.NmActiveConnectionState); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(gonetworkmanager.NmActiveConnectionState)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -733,8 +723,8 @@ func (_c *MockActiveConnection_GetPropertyState_Call) Run(run func()) *MockActiv
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyState_Call) Return(_a0 gonetworkmanager.NmActiveConnectionState, _a1 error) *MockActiveConnection_GetPropertyState_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyState_Call) Return(nmActiveConnectionState gonetworkmanager.NmActiveConnectionState, err error) *MockActiveConnection_GetPropertyState_Call {
+	_c.Call.Return(nmActiveConnectionState, err)
 	return _c
 }
 
@@ -743,9 +733,9 @@ func (_c *MockActiveConnection_GetPropertyState_Call) RunAndReturn(run func() (g
 	return _c
 }
 
-// GetPropertyStateFlags provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyStateFlags() (uint32, error) {
-	ret := _m.Called()
+// GetPropertyStateFlags provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyStateFlags() (uint32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyStateFlags")
@@ -753,21 +743,19 @@ func (_m *MockActiveConnection) GetPropertyStateFlags() (uint32, error) {
 
 	var r0 uint32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -788,8 +776,8 @@ func (_c *MockActiveConnection_GetPropertyStateFlags_Call) Run(run func()) *Mock
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyStateFlags_Call) Return(_a0 uint32, _a1 error) *MockActiveConnection_GetPropertyStateFlags_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyStateFlags_Call) Return(v uint32, err error) *MockActiveConnection_GetPropertyStateFlags_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -798,9 +786,9 @@ func (_c *MockActiveConnection_GetPropertyStateFlags_Call) RunAndReturn(run func
 	return _c
 }
 
-// GetPropertyType provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyType() (string, error) {
-	ret := _m.Called()
+// GetPropertyType provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyType() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyType")
@@ -808,21 +796,19 @@ func (_m *MockActiveConnection) GetPropertyType() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -843,8 +829,8 @@ func (_c *MockActiveConnection_GetPropertyType_Call) Run(run func()) *MockActive
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyType_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyType_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyType_Call) Return(s string, err error) *MockActiveConnection_GetPropertyType_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -853,9 +839,9 @@ func (_c *MockActiveConnection_GetPropertyType_Call) RunAndReturn(run func() (st
 	return _c
 }
 
-// GetPropertyUUID provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyUUID() (string, error) {
-	ret := _m.Called()
+// GetPropertyUUID provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyUUID() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyUUID")
@@ -863,21 +849,19 @@ func (_m *MockActiveConnection) GetPropertyUUID() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -898,8 +882,8 @@ func (_c *MockActiveConnection_GetPropertyUUID_Call) Run(run func()) *MockActive
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyUUID_Call) Return(_a0 string, _a1 error) *MockActiveConnection_GetPropertyUUID_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyUUID_Call) Return(s string, err error) *MockActiveConnection_GetPropertyUUID_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -908,9 +892,9 @@ func (_c *MockActiveConnection_GetPropertyUUID_Call) RunAndReturn(run func() (st
 	return _c
 }
 
-// GetPropertyVPN provides a mock function with no fields
-func (_m *MockActiveConnection) GetPropertyVPN() (bool, error) {
-	ret := _m.Called()
+// GetPropertyVPN provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) GetPropertyVPN() (bool, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyVPN")
@@ -918,21 +902,19 @@ func (_m *MockActiveConnection) GetPropertyVPN() (bool, error) {
 
 	var r0 bool
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (bool, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -953,8 +935,8 @@ func (_c *MockActiveConnection_GetPropertyVPN_Call) Run(run func()) *MockActiveC
 	return _c
 }
 
-func (_c *MockActiveConnection_GetPropertyVPN_Call) Return(_a0 bool, _a1 error) *MockActiveConnection_GetPropertyVPN_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockActiveConnection_GetPropertyVPN_Call) Return(b bool, err error) *MockActiveConnection_GetPropertyVPN_Call {
+	_c.Call.Return(b, err)
 	return _c
 }
 
@@ -963,21 +945,20 @@ func (_c *MockActiveConnection_GetPropertyVPN_Call) RunAndReturn(run func() (boo
 	return _c
 }
 
-// SubscribeState provides a mock function with given fields: receiver, exit
-func (_m *MockActiveConnection) SubscribeState(receiver chan gonetworkmanager.StateChange, exit chan struct{}) error {
-	ret := _m.Called(receiver, exit)
+// SubscribeState provides a mock function for the type MockActiveConnection
+func (_mock *MockActiveConnection) SubscribeState(receiver chan gonetworkmanager.StateChange, exit chan struct{}) error {
+	ret := _mock.Called(receiver, exit)
 
 	if len(ret) == 0 {
 		panic("no return value specified for SubscribeState")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(chan gonetworkmanager.StateChange, chan struct{}) error); ok {
-		r0 = rf(receiver, exit)
+	if returnFunc, ok := ret.Get(0).(func(chan gonetworkmanager.StateChange, chan struct{}) error); ok {
+		r0 = returnFunc(receiver, exit)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -989,13 +970,24 @@ type MockActiveConnection_SubscribeState_Call struct {
 // SubscribeState is a helper method to define mock.On call
 //   - receiver chan gonetworkmanager.StateChange
 //   - exit chan struct{}
-func (_e *MockActiveConnection_Expecter) SubscribeState(receiver interface{}, exit interface{}) *MockActiveConnection_SubscribeState_Call {
+func (_e *MockActiveConnection_Expecter) SubscribeState(receiver any, exit any) *MockActiveConnection_SubscribeState_Call {
 	return &MockActiveConnection_SubscribeState_Call{Call: _e.mock.On("SubscribeState", receiver, exit)}
 }
 
 func (_c *MockActiveConnection_SubscribeState_Call) Run(run func(receiver chan gonetworkmanager.StateChange, exit chan struct{})) *MockActiveConnection_SubscribeState_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(chan gonetworkmanager.StateChange), args[1].(chan struct{}))
+		var arg0 chan gonetworkmanager.StateChange
+		if args[0] != nil {
+			arg0 = args[0].(chan gonetworkmanager.StateChange)
+		}
+		var arg1 chan struct{}
+		if args[1] != nil {
+			arg1 = args[1].(chan struct{})
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
@@ -1005,21 +997,7 @@ func (_c *MockActiveConnection_SubscribeState_Call) Return(err error) *MockActiv
 	return _c
 }
 
-func (_c *MockActiveConnection_SubscribeState_Call) RunAndReturn(run func(chan gonetworkmanager.StateChange, chan struct{}) error) *MockActiveConnection_SubscribeState_Call {
+func (_c *MockActiveConnection_SubscribeState_Call) RunAndReturn(run func(receiver chan gonetworkmanager.StateChange, exit chan struct{}) error) *MockActiveConnection_SubscribeState_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockActiveConnection creates a new instance of MockActiveConnection. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockActiveConnection(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockActiveConnection {
-	mock := &MockActiveConnection{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Connection.go

@@ -1,14 +1,29 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package gonetworkmanager
 
 import (
-	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
-	dbus "github.com/godbus/dbus/v5"
-
+	"github.com/Wifx/gonetworkmanager/v2"
+	"github.com/godbus/dbus/v5"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockConnection creates a new instance of MockConnection. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockConnection(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockConnection {
+	mock := &MockConnection{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockConnection is an autogenerated mock type for the Connection type
 type MockConnection struct {
 	mock.Mock
@@ -22,21 +37,20 @@ func (_m *MockConnection) EXPECT() *MockConnection_Expecter {
 	return &MockConnection_Expecter{mock: &_m.Mock}
 }
 
-// ClearSecrets provides a mock function with no fields
-func (_m *MockConnection) ClearSecrets() error {
-	ret := _m.Called()
+// ClearSecrets provides a mock function for the type MockConnection
+func (_mock *MockConnection) ClearSecrets() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for ClearSecrets")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -57,8 +71,8 @@ func (_c *MockConnection_ClearSecrets_Call) Run(run func()) *MockConnection_Clea
 	return _c
 }
 
-func (_c *MockConnection_ClearSecrets_Call) Return(_a0 error) *MockConnection_ClearSecrets_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConnection_ClearSecrets_Call) Return(err error) *MockConnection_ClearSecrets_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -67,21 +81,20 @@ func (_c *MockConnection_ClearSecrets_Call) RunAndReturn(run func() error) *Mock
 	return _c
 }
 
-// Delete provides a mock function with no fields
-func (_m *MockConnection) Delete() error {
-	ret := _m.Called()
+// Delete provides a mock function for the type MockConnection
+func (_mock *MockConnection) Delete() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Delete")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -102,8 +115,8 @@ func (_c *MockConnection_Delete_Call) Run(run func()) *MockConnection_Delete_Cal
 	return _c
 }
 
-func (_c *MockConnection_Delete_Call) Return(_a0 error) *MockConnection_Delete_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConnection_Delete_Call) Return(err error) *MockConnection_Delete_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -112,21 +125,20 @@ func (_c *MockConnection_Delete_Call) RunAndReturn(run func() error) *MockConnec
 	return _c
 }
 
-// GetPath provides a mock function with no fields
-func (_m *MockConnection) GetPath() dbus.ObjectPath {
-	ret := _m.Called()
+// GetPath provides a mock function for the type MockConnection
+func (_mock *MockConnection) GetPath() dbus.ObjectPath {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPath")
 	}
 
 	var r0 dbus.ObjectPath
-	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(dbus.ObjectPath)
 	}
-
 	return r0
 }
 
@@ -147,8 +159,8 @@ func (_c *MockConnection_GetPath_Call) Run(run func()) *MockConnection_GetPath_C
 	return _c
 }
 
-func (_c *MockConnection_GetPath_Call) Return(_a0 dbus.ObjectPath) *MockConnection_GetPath_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConnection_GetPath_Call) Return(objectPath dbus.ObjectPath) *MockConnection_GetPath_Call {
+	_c.Call.Return(objectPath)
 	return _c
 }
 
@@ -157,9 +169,9 @@ func (_c *MockConnection_GetPath_Call) RunAndReturn(run func() dbus.ObjectPath)
 	return _c
 }
 
-// GetPropertyFilename provides a mock function with no fields
-func (_m *MockConnection) GetPropertyFilename() (string, error) {
-	ret := _m.Called()
+// GetPropertyFilename provides a mock function for the type MockConnection
+func (_mock *MockConnection) GetPropertyFilename() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyFilename")
@@ -167,21 +179,19 @@ func (_m *MockConnection) GetPropertyFilename() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -202,8 +212,8 @@ func (_c *MockConnection_GetPropertyFilename_Call) Run(run func()) *MockConnecti
 	return _c
 }
 
-func (_c *MockConnection_GetPropertyFilename_Call) Return(_a0 string, _a1 error) *MockConnection_GetPropertyFilename_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockConnection_GetPropertyFilename_Call) Return(s string, err error) *MockConnection_GetPropertyFilename_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -212,9 +222,9 @@ func (_c *MockConnection_GetPropertyFilename_Call) RunAndReturn(run func() (stri
 	return _c
 }
 
-// GetPropertyFlags provides a mock function with no fields
-func (_m *MockConnection) GetPropertyFlags() (uint32, error) {
-	ret := _m.Called()
+// GetPropertyFlags provides a mock function for the type MockConnection
+func (_mock *MockConnection) GetPropertyFlags() (uint32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyFlags")
@@ -222,21 +232,19 @@ func (_m *MockConnection) GetPropertyFlags() (uint32, error) {
 
 	var r0 uint32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -257,8 +265,8 @@ func (_c *MockConnection_GetPropertyFlags_Call) Run(run func()) *MockConnection_
 	return _c
 }
 
-func (_c *MockConnection_GetPropertyFlags_Call) Return(_a0 uint32, _a1 error) *MockConnection_GetPropertyFlags_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockConnection_GetPropertyFlags_Call) Return(v uint32, err error) *MockConnection_GetPropertyFlags_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -267,9 +275,9 @@ func (_c *MockConnection_GetPropertyFlags_Call) RunAndReturn(run func() (uint32,
 	return _c
 }
 
-// GetPropertyUnsaved provides a mock function with no fields
-func (_m *MockConnection) GetPropertyUnsaved() (bool, error) {
-	ret := _m.Called()
+// GetPropertyUnsaved provides a mock function for the type MockConnection
+func (_mock *MockConnection) GetPropertyUnsaved() (bool, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyUnsaved")
@@ -277,21 +285,19 @@ func (_m *MockConnection) GetPropertyUnsaved() (bool, error) {
 
 	var r0 bool
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (bool, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -312,8 +318,8 @@ func (_c *MockConnection_GetPropertyUnsaved_Call) Run(run func()) *MockConnectio
 	return _c
 }
 
-func (_c *MockConnection_GetPropertyUnsaved_Call) Return(_a0 bool, _a1 error) *MockConnection_GetPropertyUnsaved_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockConnection_GetPropertyUnsaved_Call) Return(b bool, err error) *MockConnection_GetPropertyUnsaved_Call {
+	_c.Call.Return(b, err)
 	return _c
 }
 
@@ -322,9 +328,9 @@ func (_c *MockConnection_GetPropertyUnsaved_Call) RunAndReturn(run func() (bool,
 	return _c
 }
 
-// GetSecrets provides a mock function with given fields: settingName
-func (_m *MockConnection) GetSecrets(settingName string) (gonetworkmanager.ConnectionSettings, error) {
-	ret := _m.Called(settingName)
+// GetSecrets provides a mock function for the type MockConnection
+func (_mock *MockConnection) GetSecrets(settingName string) (gonetworkmanager.ConnectionSettings, error) {
+	ret := _mock.Called(settingName)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetSecrets")
@@ -332,23 +338,21 @@ func (_m *MockConnection) GetSecrets(settingName string) (gonetworkmanager.Conne
 
 	var r0 gonetworkmanager.ConnectionSettings
 	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (gonetworkmanager.ConnectionSettings, error)); ok {
-		return rf(settingName)
+	if returnFunc, ok := ret.Get(0).(func(string) (gonetworkmanager.ConnectionSettings, error)); ok {
+		return returnFunc(settingName)
 	}
-	if rf, ok := ret.Get(0).(func(string) gonetworkmanager.ConnectionSettings); ok {
-		r0 = rf(settingName)
+	if returnFunc, ok := ret.Get(0).(func(string) gonetworkmanager.ConnectionSettings); ok {
+		r0 = returnFunc(settingName)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.ConnectionSettings)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(settingName)
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(settingName)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -359,30 +363,36 @@ type MockConnection_GetSecrets_Call struct {
 
 // GetSecrets is a helper method to define mock.On call
 //   - settingName string
-func (_e *MockConnection_Expecter) GetSecrets(settingName interface{}) *MockConnection_GetSecrets_Call {
+func (_e *MockConnection_Expecter) GetSecrets(settingName any) *MockConnection_GetSecrets_Call {
 	return &MockConnection_GetSecrets_Call{Call: _e.mock.On("GetSecrets", settingName)}
 }
 
 func (_c *MockConnection_GetSecrets_Call) Run(run func(settingName string)) *MockConnection_GetSecrets_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockConnection_GetSecrets_Call) Return(_a0 gonetworkmanager.ConnectionSettings, _a1 error) *MockConnection_GetSecrets_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockConnection_GetSecrets_Call) Return(connectionSettings gonetworkmanager.ConnectionSettings, err error) *MockConnection_GetSecrets_Call {
+	_c.Call.Return(connectionSettings, err)
 	return _c
 }
 
-func (_c *MockConnection_GetSecrets_Call) RunAndReturn(run func(string) (gonetworkmanager.ConnectionSettings, error)) *MockConnection_GetSecrets_Call {
+func (_c *MockConnection_GetSecrets_Call) RunAndReturn(run func(settingName string) (gonetworkmanager.ConnectionSettings, error)) *MockConnection_GetSecrets_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GetSettings provides a mock function with no fields
-func (_m *MockConnection) GetSettings() (gonetworkmanager.ConnectionSettings, error) {
-	ret := _m.Called()
+// GetSettings provides a mock function for the type MockConnection
+func (_mock *MockConnection) GetSettings() (gonetworkmanager.ConnectionSettings, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetSettings")
@@ -390,23 +400,21 @@ func (_m *MockConnection) GetSettings() (gonetworkmanager.ConnectionSettings, er
 
 	var r0 gonetworkmanager.ConnectionSettings
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (gonetworkmanager.ConnectionSettings, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (gonetworkmanager.ConnectionSettings, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() gonetworkmanager.ConnectionSettings); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() gonetworkmanager.ConnectionSettings); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.ConnectionSettings)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -427,8 +435,8 @@ func (_c *MockConnection_GetSettings_Call) Run(run func()) *MockConnection_GetSe
 	return _c
 }
 
-func (_c *MockConnection_GetSettings_Call) Return(_a0 gonetworkmanager.ConnectionSettings, _a1 error) *MockConnection_GetSettings_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockConnection_GetSettings_Call) Return(connectionSettings gonetworkmanager.ConnectionSettings, err error) *MockConnection_GetSettings_Call {
+	_c.Call.Return(connectionSettings, err)
 	return _c
 }
 
@@ -437,9 +445,9 @@ func (_c *MockConnection_GetSettings_Call) RunAndReturn(run func() (gonetworkman
 	return _c
 }
 
-// MarshalJSON provides a mock function with no fields
-func (_m *MockConnection) MarshalJSON() ([]byte, error) {
-	ret := _m.Called()
+// MarshalJSON provides a mock function for the type MockConnection
+func (_mock *MockConnection) MarshalJSON() ([]byte, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for MarshalJSON")
@@ -447,23 +455,21 @@ func (_m *MockConnection) MarshalJSON() ([]byte, error) {
 
 	var r0 []byte
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []byte); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []byte); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]byte)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -484,8 +490,8 @@ func (_c *MockConnection_MarshalJSON_Call) Run(run func()) *MockConnection_Marsh
 	return _c
 }
 
-func (_c *MockConnection_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockConnection_MarshalJSON_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockConnection_MarshalJSON_Call) Return(bytes []byte, err error) *MockConnection_MarshalJSON_Call {
+	_c.Call.Return(bytes, err)
 	return _c
 }
 
@@ -494,21 +500,20 @@ func (_c *MockConnection_MarshalJSON_Call) RunAndReturn(run func() ([]byte, erro
 	return _c
 }
 
-// Save provides a mock function with no fields
-func (_m *MockConnection) Save() error {
-	ret := _m.Called()
+// Save provides a mock function for the type MockConnection
+func (_mock *MockConnection) Save() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Save")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -529,8 +534,8 @@ func (_c *MockConnection_Save_Call) Run(run func()) *MockConnection_Save_Call {
 	return _c
 }
 
-func (_c *MockConnection_Save_Call) Return(_a0 error) *MockConnection_Save_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConnection_Save_Call) Return(err error) *MockConnection_Save_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -539,21 +544,20 @@ func (_c *MockConnection_Save_Call) RunAndReturn(run func() error) *MockConnecti
 	return _c
 }
 
-// Update provides a mock function with given fields: settings
-func (_m *MockConnection) Update(settings gonetworkmanager.ConnectionSettings) error {
-	ret := _m.Called(settings)
+// Update provides a mock function for the type MockConnection
+func (_mock *MockConnection) Update(settings gonetworkmanager.ConnectionSettings) error {
+	ret := _mock.Called(settings)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Update")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) error); ok {
-		r0 = rf(settings)
+	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) error); ok {
+		r0 = returnFunc(settings)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -564,42 +568,47 @@ type MockConnection_Update_Call struct {
 
 // Update is a helper method to define mock.On call
 //   - settings gonetworkmanager.ConnectionSettings
-func (_e *MockConnection_Expecter) Update(settings interface{}) *MockConnection_Update_Call {
+func (_e *MockConnection_Expecter) Update(settings any) *MockConnection_Update_Call {
 	return &MockConnection_Update_Call{Call: _e.mock.On("Update", settings)}
 }
 
 func (_c *MockConnection_Update_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockConnection_Update_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(gonetworkmanager.ConnectionSettings))
+		var arg0 gonetworkmanager.ConnectionSettings
+		if args[0] != nil {
+			arg0 = args[0].(gonetworkmanager.ConnectionSettings)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockConnection_Update_Call) Return(_a0 error) *MockConnection_Update_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConnection_Update_Call) Return(err error) *MockConnection_Update_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockConnection_Update_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) error) *MockConnection_Update_Call {
+func (_c *MockConnection_Update_Call) RunAndReturn(run func(settings gonetworkmanager.ConnectionSettings) error) *MockConnection_Update_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// UpdateUnsaved provides a mock function with given fields: settings
-func (_m *MockConnection) UpdateUnsaved(settings gonetworkmanager.ConnectionSettings) error {
-	ret := _m.Called(settings)
+// UpdateUnsaved provides a mock function for the type MockConnection
+func (_mock *MockConnection) UpdateUnsaved(settings gonetworkmanager.ConnectionSettings) error {
+	ret := _mock.Called(settings)
 
 	if len(ret) == 0 {
 		panic("no return value specified for UpdateUnsaved")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) error); ok {
-		r0 = rf(settings)
+	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) error); ok {
+		r0 = returnFunc(settings)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -610,37 +619,29 @@ type MockConnection_UpdateUnsaved_Call struct {
 
 // UpdateUnsaved is a helper method to define mock.On call
 //   - settings gonetworkmanager.ConnectionSettings
-func (_e *MockConnection_Expecter) UpdateUnsaved(settings interface{}) *MockConnection_UpdateUnsaved_Call {
+func (_e *MockConnection_Expecter) UpdateUnsaved(settings any) *MockConnection_UpdateUnsaved_Call {
 	return &MockConnection_UpdateUnsaved_Call{Call: _e.mock.On("UpdateUnsaved", settings)}
 }
 
 func (_c *MockConnection_UpdateUnsaved_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockConnection_UpdateUnsaved_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(gonetworkmanager.ConnectionSettings))
+		var arg0 gonetworkmanager.ConnectionSettings
+		if args[0] != nil {
+			arg0 = args[0].(gonetworkmanager.ConnectionSettings)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockConnection_UpdateUnsaved_Call) Return(_a0 error) *MockConnection_UpdateUnsaved_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConnection_UpdateUnsaved_Call) Return(err error) *MockConnection_UpdateUnsaved_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockConnection_UpdateUnsaved_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) error) *MockConnection_UpdateUnsaved_Call {
+func (_c *MockConnection_UpdateUnsaved_Call) RunAndReturn(run func(settings gonetworkmanager.ConnectionSettings) error) *MockConnection_UpdateUnsaved_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockConnection creates a new instance of MockConnection. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockConnection(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockConnection {
-	mock := &MockConnection{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_IP4Config.go

@@ -1,12 +1,28 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package gonetworkmanager
 
 import (
-	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	"github.com/Wifx/gonetworkmanager/v2"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockIP4Config creates a new instance of MockIP4Config. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockIP4Config(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockIP4Config {
+	mock := &MockIP4Config{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockIP4Config is an autogenerated mock type for the IP4Config type
 type MockIP4Config struct {
 	mock.Mock
@@ -20,9 +36,9 @@ func (_m *MockIP4Config) EXPECT() *MockIP4Config_Expecter {
 	return &MockIP4Config_Expecter{mock: &_m.Mock}
 }
 
-// GetPropertyAddressData provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyAddressData() ([]gonetworkmanager.IP4AddressData, error) {
-	ret := _m.Called()
+// GetPropertyAddressData provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyAddressData() ([]gonetworkmanager.IP4AddressData, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyAddressData")
@@ -30,23 +46,21 @@ func (_m *MockIP4Config) GetPropertyAddressData() ([]gonetworkmanager.IP4Address
 
 	var r0 []gonetworkmanager.IP4AddressData
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4AddressData, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4AddressData, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4AddressData); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.IP4AddressData); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]gonetworkmanager.IP4AddressData)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -67,8 +81,8 @@ func (_c *MockIP4Config_GetPropertyAddressData_Call) Run(run func()) *MockIP4Con
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyAddressData_Call) Return(_a0 []gonetworkmanager.IP4AddressData, _a1 error) *MockIP4Config_GetPropertyAddressData_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyAddressData_Call) Return(iP4AddressDatas []gonetworkmanager.IP4AddressData, err error) *MockIP4Config_GetPropertyAddressData_Call {
+	_c.Call.Return(iP4AddressDatas, err)
 	return _c
 }
 
@@ -77,9 +91,9 @@ func (_c *MockIP4Config_GetPropertyAddressData_Call) RunAndReturn(run func() ([]
 	return _c
 }
 
-// GetPropertyAddresses provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyAddresses() ([]gonetworkmanager.IP4Address, error) {
-	ret := _m.Called()
+// GetPropertyAddresses provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyAddresses() ([]gonetworkmanager.IP4Address, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyAddresses")
@@ -87,23 +101,21 @@ func (_m *MockIP4Config) GetPropertyAddresses() ([]gonetworkmanager.IP4Address,
 
 	var r0 []gonetworkmanager.IP4Address
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4Address, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4Address, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4Address); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.IP4Address); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]gonetworkmanager.IP4Address)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -124,8 +136,8 @@ func (_c *MockIP4Config_GetPropertyAddresses_Call) Run(run func()) *MockIP4Confi
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyAddresses_Call) Return(_a0 []gonetworkmanager.IP4Address, _a1 error) *MockIP4Config_GetPropertyAddresses_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyAddresses_Call) Return(iP4Addresss []gonetworkmanager.IP4Address, err error) *MockIP4Config_GetPropertyAddresses_Call {
+	_c.Call.Return(iP4Addresss, err)
 	return _c
 }
 
@@ -134,9 +146,9 @@ func (_c *MockIP4Config_GetPropertyAddresses_Call) RunAndReturn(run func() ([]go
 	return _c
 }
 
-// GetPropertyDnsOptions provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyDnsOptions() ([]string, error) {
-	ret := _m.Called()
+// GetPropertyDnsOptions provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyDnsOptions() ([]string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyDnsOptions")
@@ -144,23 +156,21 @@ func (_m *MockIP4Config) GetPropertyDnsOptions() ([]string, error) {
 
 	var r0 []string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []string); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]string)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -181,8 +191,8 @@ func (_c *MockIP4Config_GetPropertyDnsOptions_Call) Run(run func()) *MockIP4Conf
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyDnsOptions_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyDnsOptions_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyDnsOptions_Call) Return(strings []string, err error) *MockIP4Config_GetPropertyDnsOptions_Call {
+	_c.Call.Return(strings, err)
 	return _c
 }
 
@@ -191,9 +201,9 @@ func (_c *MockIP4Config_GetPropertyDnsOptions_Call) RunAndReturn(run func() ([]s
 	return _c
 }
 
-// GetPropertyDnsPriority provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyDnsPriority() (uint32, error) {
-	ret := _m.Called()
+// GetPropertyDnsPriority provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyDnsPriority() (uint32, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyDnsPriority")
@@ -201,21 +211,19 @@ func (_m *MockIP4Config) GetPropertyDnsPriority() (uint32, error) {
 
 	var r0 uint32
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (uint32, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (uint32, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() uint32); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() uint32); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(uint32)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -236,8 +244,8 @@ func (_c *MockIP4Config_GetPropertyDnsPriority_Call) Run(run func()) *MockIP4Con
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyDnsPriority_Call) Return(_a0 uint32, _a1 error) *MockIP4Config_GetPropertyDnsPriority_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyDnsPriority_Call) Return(v uint32, err error) *MockIP4Config_GetPropertyDnsPriority_Call {
+	_c.Call.Return(v, err)
 	return _c
 }
 
@@ -246,9 +254,9 @@ func (_c *MockIP4Config_GetPropertyDnsPriority_Call) RunAndReturn(run func() (ui
 	return _c
 }
 
-// GetPropertyDomains provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyDomains() ([]string, error) {
-	ret := _m.Called()
+// GetPropertyDomains provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyDomains() ([]string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyDomains")
@@ -256,23 +264,21 @@ func (_m *MockIP4Config) GetPropertyDomains() ([]string, error) {
 
 	var r0 []string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []string); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]string)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -293,8 +299,8 @@ func (_c *MockIP4Config_GetPropertyDomains_Call) Run(run func()) *MockIP4Config_
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyDomains_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyDomains_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyDomains_Call) Return(strings []string, err error) *MockIP4Config_GetPropertyDomains_Call {
+	_c.Call.Return(strings, err)
 	return _c
 }
 
@@ -303,9 +309,9 @@ func (_c *MockIP4Config_GetPropertyDomains_Call) RunAndReturn(run func() ([]stri
 	return _c
 }
 
-// GetPropertyGateway provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyGateway() (string, error) {
-	ret := _m.Called()
+// GetPropertyGateway provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyGateway() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyGateway")
@@ -313,21 +319,19 @@ func (_m *MockIP4Config) GetPropertyGateway() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -348,8 +352,8 @@ func (_c *MockIP4Config_GetPropertyGateway_Call) Run(run func()) *MockIP4Config_
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyGateway_Call) Return(_a0 string, _a1 error) *MockIP4Config_GetPropertyGateway_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyGateway_Call) Return(s string, err error) *MockIP4Config_GetPropertyGateway_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -358,9 +362,9 @@ func (_c *MockIP4Config_GetPropertyGateway_Call) RunAndReturn(run func() (string
 	return _c
 }
 
-// GetPropertyNameserverData provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyNameserverData() ([]gonetworkmanager.IP4NameserverData, error) {
-	ret := _m.Called()
+// GetPropertyNameserverData provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyNameserverData() ([]gonetworkmanager.IP4NameserverData, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyNameserverData")
@@ -368,23 +372,21 @@ func (_m *MockIP4Config) GetPropertyNameserverData() ([]gonetworkmanager.IP4Name
 
 	var r0 []gonetworkmanager.IP4NameserverData
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4NameserverData, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4NameserverData, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4NameserverData); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.IP4NameserverData); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]gonetworkmanager.IP4NameserverData)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -405,8 +407,8 @@ func (_c *MockIP4Config_GetPropertyNameserverData_Call) Run(run func()) *MockIP4
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyNameserverData_Call) Return(_a0 []gonetworkmanager.IP4NameserverData, _a1 error) *MockIP4Config_GetPropertyNameserverData_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyNameserverData_Call) Return(iP4NameserverDatas []gonetworkmanager.IP4NameserverData, err error) *MockIP4Config_GetPropertyNameserverData_Call {
+	_c.Call.Return(iP4NameserverDatas, err)
 	return _c
 }
 
@@ -415,9 +417,9 @@ func (_c *MockIP4Config_GetPropertyNameserverData_Call) RunAndReturn(run func()
 	return _c
 }
 
-// GetPropertyNameservers provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyNameservers() ([]string, error) {
-	ret := _m.Called()
+// GetPropertyNameservers provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyNameservers() ([]string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyNameservers")
@@ -425,23 +427,21 @@ func (_m *MockIP4Config) GetPropertyNameservers() ([]string, error) {
 
 	var r0 []string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []string); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]string)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -462,8 +462,8 @@ func (_c *MockIP4Config_GetPropertyNameservers_Call) Run(run func()) *MockIP4Con
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyNameservers_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyNameservers_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyNameservers_Call) Return(strings []string, err error) *MockIP4Config_GetPropertyNameservers_Call {
+	_c.Call.Return(strings, err)
 	return _c
 }
 
@@ -472,9 +472,9 @@ func (_c *MockIP4Config_GetPropertyNameservers_Call) RunAndReturn(run func() ([]
 	return _c
 }
 
-// GetPropertyRouteData provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyRouteData() ([]gonetworkmanager.IP4RouteData, error) {
-	ret := _m.Called()
+// GetPropertyRouteData provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyRouteData() ([]gonetworkmanager.IP4RouteData, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyRouteData")
@@ -482,23 +482,21 @@ func (_m *MockIP4Config) GetPropertyRouteData() ([]gonetworkmanager.IP4RouteData
 
 	var r0 []gonetworkmanager.IP4RouteData
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4RouteData, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4RouteData, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4RouteData); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.IP4RouteData); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]gonetworkmanager.IP4RouteData)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -519,8 +517,8 @@ func (_c *MockIP4Config_GetPropertyRouteData_Call) Run(run func()) *MockIP4Confi
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyRouteData_Call) Return(_a0 []gonetworkmanager.IP4RouteData, _a1 error) *MockIP4Config_GetPropertyRouteData_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyRouteData_Call) Return(iP4RouteDatas []gonetworkmanager.IP4RouteData, err error) *MockIP4Config_GetPropertyRouteData_Call {
+	_c.Call.Return(iP4RouteDatas, err)
 	return _c
 }
 
@@ -529,9 +527,9 @@ func (_c *MockIP4Config_GetPropertyRouteData_Call) RunAndReturn(run func() ([]go
 	return _c
 }
 
-// GetPropertyRoutes provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyRoutes() ([]gonetworkmanager.IP4Route, error) {
-	ret := _m.Called()
+// GetPropertyRoutes provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyRoutes() ([]gonetworkmanager.IP4Route, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyRoutes")
@@ -539,23 +537,21 @@ func (_m *MockIP4Config) GetPropertyRoutes() ([]gonetworkmanager.IP4Route, error
 
 	var r0 []gonetworkmanager.IP4Route
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4Route, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.IP4Route, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []gonetworkmanager.IP4Route); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.IP4Route); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]gonetworkmanager.IP4Route)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -576,8 +572,8 @@ func (_c *MockIP4Config_GetPropertyRoutes_Call) Run(run func()) *MockIP4Config_G
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyRoutes_Call) Return(_a0 []gonetworkmanager.IP4Route, _a1 error) *MockIP4Config_GetPropertyRoutes_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyRoutes_Call) Return(iP4Routes []gonetworkmanager.IP4Route, err error) *MockIP4Config_GetPropertyRoutes_Call {
+	_c.Call.Return(iP4Routes, err)
 	return _c
 }
 
@@ -586,9 +582,9 @@ func (_c *MockIP4Config_GetPropertyRoutes_Call) RunAndReturn(run func() ([]gonet
 	return _c
 }
 
-// GetPropertySearches provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertySearches() ([]string, error) {
-	ret := _m.Called()
+// GetPropertySearches provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertySearches() ([]string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertySearches")
@@ -596,23 +592,21 @@ func (_m *MockIP4Config) GetPropertySearches() ([]string, error) {
 
 	var r0 []string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []string); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]string)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -633,8 +627,8 @@ func (_c *MockIP4Config_GetPropertySearches_Call) Run(run func()) *MockIP4Config
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertySearches_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertySearches_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertySearches_Call) Return(strings []string, err error) *MockIP4Config_GetPropertySearches_Call {
+	_c.Call.Return(strings, err)
 	return _c
 }
 
@@ -643,9 +637,9 @@ func (_c *MockIP4Config_GetPropertySearches_Call) RunAndReturn(run func() ([]str
 	return _c
 }
 
-// GetPropertyWinsServerData provides a mock function with no fields
-func (_m *MockIP4Config) GetPropertyWinsServerData() ([]string, error) {
-	ret := _m.Called()
+// GetPropertyWinsServerData provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) GetPropertyWinsServerData() ([]string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyWinsServerData")
@@ -653,23 +647,21 @@ func (_m *MockIP4Config) GetPropertyWinsServerData() ([]string, error) {
 
 	var r0 []string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []string); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]string)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -690,8 +682,8 @@ func (_c *MockIP4Config_GetPropertyWinsServerData_Call) Run(run func()) *MockIP4
 	return _c
 }
 
-func (_c *MockIP4Config_GetPropertyWinsServerData_Call) Return(_a0 []string, _a1 error) *MockIP4Config_GetPropertyWinsServerData_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_GetPropertyWinsServerData_Call) Return(strings []string, err error) *MockIP4Config_GetPropertyWinsServerData_Call {
+	_c.Call.Return(strings, err)
 	return _c
 }
 
@@ -700,9 +692,9 @@ func (_c *MockIP4Config_GetPropertyWinsServerData_Call) RunAndReturn(run func()
 	return _c
 }
 
-// MarshalJSON provides a mock function with no fields
-func (_m *MockIP4Config) MarshalJSON() ([]byte, error) {
-	ret := _m.Called()
+// MarshalJSON provides a mock function for the type MockIP4Config
+func (_mock *MockIP4Config) MarshalJSON() ([]byte, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for MarshalJSON")
@@ -710,23 +702,21 @@ func (_m *MockIP4Config) MarshalJSON() ([]byte, error) {
 
 	var r0 []byte
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]byte, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]byte, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []byte); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []byte); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]byte)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -747,8 +737,8 @@ func (_c *MockIP4Config_MarshalJSON_Call) Run(run func()) *MockIP4Config_Marshal
 	return _c
 }
 
-func (_c *MockIP4Config_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockIP4Config_MarshalJSON_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockIP4Config_MarshalJSON_Call) Return(bytes []byte, err error) *MockIP4Config_MarshalJSON_Call {
+	_c.Call.Return(bytes, err)
 	return _c
 }
 
@@ -756,17 +746,3 @@ func (_c *MockIP4Config_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockIP4Config creates a new instance of MockIP4Config. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockIP4Config(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockIP4Config {
-	mock := &MockIP4Config{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/github.com/Wifx/gonetworkmanager/v2/mock_Settings.go

@@ -1,12 +1,28 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package gonetworkmanager
 
 import (
-	gonetworkmanager "github.com/Wifx/gonetworkmanager/v2"
+	"github.com/Wifx/gonetworkmanager/v2"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockSettings creates a new instance of MockSettings. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSettings(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSettings {
+	mock := &MockSettings{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockSettings is an autogenerated mock type for the Settings type
 type MockSettings struct {
 	mock.Mock
@@ -20,9 +36,9 @@ func (_m *MockSettings) EXPECT() *MockSettings_Expecter {
 	return &MockSettings_Expecter{mock: &_m.Mock}
 }
 
-// AddConnection provides a mock function with given fields: settings
-func (_m *MockSettings) AddConnection(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error) {
-	ret := _m.Called(settings)
+// AddConnection provides a mock function for the type MockSettings
+func (_mock *MockSettings) AddConnection(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error) {
+	ret := _mock.Called(settings)
 
 	if len(ret) == 0 {
 		panic("no return value specified for AddConnection")
@@ -30,23 +46,21 @@ func (_m *MockSettings) AddConnection(settings gonetworkmanager.ConnectionSettin
 
 	var r0 gonetworkmanager.Connection
 	var r1 error
-	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)); ok {
-		return rf(settings)
+	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)); ok {
+		return returnFunc(settings)
 	}
-	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) gonetworkmanager.Connection); ok {
-		r0 = rf(settings)
+	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) gonetworkmanager.Connection); ok {
+		r0 = returnFunc(settings)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.Connection)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(gonetworkmanager.ConnectionSettings) error); ok {
-		r1 = rf(settings)
+	if returnFunc, ok := ret.Get(1).(func(gonetworkmanager.ConnectionSettings) error); ok {
+		r1 = returnFunc(settings)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -57,30 +71,36 @@ type MockSettings_AddConnection_Call struct {
 
 // AddConnection is a helper method to define mock.On call
 //   - settings gonetworkmanager.ConnectionSettings
-func (_e *MockSettings_Expecter) AddConnection(settings interface{}) *MockSettings_AddConnection_Call {
+func (_e *MockSettings_Expecter) AddConnection(settings any) *MockSettings_AddConnection_Call {
 	return &MockSettings_AddConnection_Call{Call: _e.mock.On("AddConnection", settings)}
 }
 
 func (_c *MockSettings_AddConnection_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockSettings_AddConnection_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(gonetworkmanager.ConnectionSettings))
+		var arg0 gonetworkmanager.ConnectionSettings
+		if args[0] != nil {
+			arg0 = args[0].(gonetworkmanager.ConnectionSettings)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockSettings_AddConnection_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_AddConnection_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockSettings_AddConnection_Call) Return(connection gonetworkmanager.Connection, err error) *MockSettings_AddConnection_Call {
+	_c.Call.Return(connection, err)
 	return _c
 }
 
-func (_c *MockSettings_AddConnection_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)) *MockSettings_AddConnection_Call {
+func (_c *MockSettings_AddConnection_Call) RunAndReturn(run func(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)) *MockSettings_AddConnection_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// AddConnectionUnsaved provides a mock function with given fields: settings
-func (_m *MockSettings) AddConnectionUnsaved(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error) {
-	ret := _m.Called(settings)
+// AddConnectionUnsaved provides a mock function for the type MockSettings
+func (_mock *MockSettings) AddConnectionUnsaved(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error) {
+	ret := _mock.Called(settings)
 
 	if len(ret) == 0 {
 		panic("no return value specified for AddConnectionUnsaved")
@@ -88,23 +108,21 @@ func (_m *MockSettings) AddConnectionUnsaved(settings gonetworkmanager.Connectio
 
 	var r0 gonetworkmanager.Connection
 	var r1 error
-	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)); ok {
-		return rf(settings)
+	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)); ok {
+		return returnFunc(settings)
 	}
-	if rf, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) gonetworkmanager.Connection); ok {
-		r0 = rf(settings)
+	if returnFunc, ok := ret.Get(0).(func(gonetworkmanager.ConnectionSettings) gonetworkmanager.Connection); ok {
+		r0 = returnFunc(settings)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.Connection)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(gonetworkmanager.ConnectionSettings) error); ok {
-		r1 = rf(settings)
+	if returnFunc, ok := ret.Get(1).(func(gonetworkmanager.ConnectionSettings) error); ok {
+		r1 = returnFunc(settings)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -115,30 +133,36 @@ type MockSettings_AddConnectionUnsaved_Call struct {
 
 // AddConnectionUnsaved is a helper method to define mock.On call
 //   - settings gonetworkmanager.ConnectionSettings
-func (_e *MockSettings_Expecter) AddConnectionUnsaved(settings interface{}) *MockSettings_AddConnectionUnsaved_Call {
+func (_e *MockSettings_Expecter) AddConnectionUnsaved(settings any) *MockSettings_AddConnectionUnsaved_Call {
 	return &MockSettings_AddConnectionUnsaved_Call{Call: _e.mock.On("AddConnectionUnsaved", settings)}
 }
 
 func (_c *MockSettings_AddConnectionUnsaved_Call) Run(run func(settings gonetworkmanager.ConnectionSettings)) *MockSettings_AddConnectionUnsaved_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(gonetworkmanager.ConnectionSettings))
+		var arg0 gonetworkmanager.ConnectionSettings
+		if args[0] != nil {
+			arg0 = args[0].(gonetworkmanager.ConnectionSettings)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockSettings_AddConnectionUnsaved_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_AddConnectionUnsaved_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockSettings_AddConnectionUnsaved_Call) Return(connection gonetworkmanager.Connection, err error) *MockSettings_AddConnectionUnsaved_Call {
+	_c.Call.Return(connection, err)
 	return _c
 }
 
-func (_c *MockSettings_AddConnectionUnsaved_Call) RunAndReturn(run func(gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)) *MockSettings_AddConnectionUnsaved_Call {
+func (_c *MockSettings_AddConnectionUnsaved_Call) RunAndReturn(run func(settings gonetworkmanager.ConnectionSettings) (gonetworkmanager.Connection, error)) *MockSettings_AddConnectionUnsaved_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GetConnectionByUUID provides a mock function with given fields: uuid
-func (_m *MockSettings) GetConnectionByUUID(uuid string) (gonetworkmanager.Connection, error) {
-	ret := _m.Called(uuid)
+// GetConnectionByUUID provides a mock function for the type MockSettings
+func (_mock *MockSettings) GetConnectionByUUID(uuid string) (gonetworkmanager.Connection, error) {
+	ret := _mock.Called(uuid)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetConnectionByUUID")
@@ -146,23 +170,21 @@ func (_m *MockSettings) GetConnectionByUUID(uuid string) (gonetworkmanager.Conne
 
 	var r0 gonetworkmanager.Connection
 	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (gonetworkmanager.Connection, error)); ok {
-		return rf(uuid)
+	if returnFunc, ok := ret.Get(0).(func(string) (gonetworkmanager.Connection, error)); ok {
+		return returnFunc(uuid)
 	}
-	if rf, ok := ret.Get(0).(func(string) gonetworkmanager.Connection); ok {
-		r0 = rf(uuid)
+	if returnFunc, ok := ret.Get(0).(func(string) gonetworkmanager.Connection); ok {
+		r0 = returnFunc(uuid)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(gonetworkmanager.Connection)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(uuid)
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(uuid)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -173,30 +195,36 @@ type MockSettings_GetConnectionByUUID_Call struct {
 
 // GetConnectionByUUID is a helper method to define mock.On call
 //   - uuid string
-func (_e *MockSettings_Expecter) GetConnectionByUUID(uuid interface{}) *MockSettings_GetConnectionByUUID_Call {
+func (_e *MockSettings_Expecter) GetConnectionByUUID(uuid any) *MockSettings_GetConnectionByUUID_Call {
 	return &MockSettings_GetConnectionByUUID_Call{Call: _e.mock.On("GetConnectionByUUID", uuid)}
 }
 
 func (_c *MockSettings_GetConnectionByUUID_Call) Run(run func(uuid string)) *MockSettings_GetConnectionByUUID_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockSettings_GetConnectionByUUID_Call) Return(_a0 gonetworkmanager.Connection, _a1 error) *MockSettings_GetConnectionByUUID_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockSettings_GetConnectionByUUID_Call) Return(connection gonetworkmanager.Connection, err error) *MockSettings_GetConnectionByUUID_Call {
+	_c.Call.Return(connection, err)
 	return _c
 }
 
-func (_c *MockSettings_GetConnectionByUUID_Call) RunAndReturn(run func(string) (gonetworkmanager.Connection, error)) *MockSettings_GetConnectionByUUID_Call {
+func (_c *MockSettings_GetConnectionByUUID_Call) RunAndReturn(run func(uuid string) (gonetworkmanager.Connection, error)) *MockSettings_GetConnectionByUUID_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GetPropertyCanModify provides a mock function with no fields
-func (_m *MockSettings) GetPropertyCanModify() (bool, error) {
-	ret := _m.Called()
+// GetPropertyCanModify provides a mock function for the type MockSettings
+func (_mock *MockSettings) GetPropertyCanModify() (bool, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyCanModify")
@@ -204,21 +232,19 @@ func (_m *MockSettings) GetPropertyCanModify() (bool, error) {
 
 	var r0 bool
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (bool, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -239,8 +265,8 @@ func (_c *MockSettings_GetPropertyCanModify_Call) Run(run func()) *MockSettings_
 	return _c
 }
 
-func (_c *MockSettings_GetPropertyCanModify_Call) Return(_a0 bool, _a1 error) *MockSettings_GetPropertyCanModify_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockSettings_GetPropertyCanModify_Call) Return(b bool, err error) *MockSettings_GetPropertyCanModify_Call {
+	_c.Call.Return(b, err)
 	return _c
 }
 
@@ -249,9 +275,9 @@ func (_c *MockSettings_GetPropertyCanModify_Call) RunAndReturn(run func() (bool,
 	return _c
 }
 
-// GetPropertyHostname provides a mock function with no fields
-func (_m *MockSettings) GetPropertyHostname() (string, error) {
-	ret := _m.Called()
+// GetPropertyHostname provides a mock function for the type MockSettings
+func (_mock *MockSettings) GetPropertyHostname() (string, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetPropertyHostname")
@@ -259,21 +285,19 @@ func (_m *MockSettings) GetPropertyHostname() (string, error) {
 
 	var r0 string
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (string, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -294,8 +318,8 @@ func (_c *MockSettings_GetPropertyHostname_Call) Run(run func()) *MockSettings_G
 	return _c
 }
 
-func (_c *MockSettings_GetPropertyHostname_Call) Return(_a0 string, _a1 error) *MockSettings_GetPropertyHostname_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockSettings_GetPropertyHostname_Call) Return(s string, err error) *MockSettings_GetPropertyHostname_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
@@ -304,9 +328,9 @@ func (_c *MockSettings_GetPropertyHostname_Call) RunAndReturn(run func() (string
 	return _c
 }
 
-// ListConnections provides a mock function with no fields
-func (_m *MockSettings) ListConnections() ([]gonetworkmanager.Connection, error) {
-	ret := _m.Called()
+// ListConnections provides a mock function for the type MockSettings
+func (_mock *MockSettings) ListConnections() ([]gonetworkmanager.Connection, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for ListConnections")
@@ -314,23 +338,21 @@ func (_m *MockSettings) ListConnections() ([]gonetworkmanager.Connection, error)
 
 	var r0 []gonetworkmanager.Connection
 	var r1 error
-	if rf, ok := ret.Get(0).(func() ([]gonetworkmanager.Connection, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() ([]gonetworkmanager.Connection, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() []gonetworkmanager.Connection); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() []gonetworkmanager.Connection); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]gonetworkmanager.Connection)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -351,8 +373,8 @@ func (_c *MockSettings_ListConnections_Call) Run(run func()) *MockSettings_ListC
 	return _c
 }
 
-func (_c *MockSettings_ListConnections_Call) Return(_a0 []gonetworkmanager.Connection, _a1 error) *MockSettings_ListConnections_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockSettings_ListConnections_Call) Return(connections []gonetworkmanager.Connection, err error) *MockSettings_ListConnections_Call {
+	_c.Call.Return(connections, err)
 	return _c
 }
 
@@ -361,21 +383,20 @@ func (_c *MockSettings_ListConnections_Call) RunAndReturn(run func() ([]gonetwor
 	return _c
 }
 
-// ReloadConnections provides a mock function with no fields
-func (_m *MockSettings) ReloadConnections() error {
-	ret := _m.Called()
+// ReloadConnections provides a mock function for the type MockSettings
+func (_mock *MockSettings) ReloadConnections() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for ReloadConnections")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -396,8 +417,8 @@ func (_c *MockSettings_ReloadConnections_Call) Run(run func()) *MockSettings_Rel
 	return _c
 }
 
-func (_c *MockSettings_ReloadConnections_Call) Return(_a0 error) *MockSettings_ReloadConnections_Call {
-	_c.Call.Return(_a0)
+func (_c *MockSettings_ReloadConnections_Call) Return(err error) *MockSettings_ReloadConnections_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -406,21 +427,20 @@ func (_c *MockSettings_ReloadConnections_Call) RunAndReturn(run func() error) *M
 	return _c
 }
 
-// SaveHostname provides a mock function with given fields: hostname
-func (_m *MockSettings) SaveHostname(hostname string) error {
-	ret := _m.Called(hostname)
+// SaveHostname provides a mock function for the type MockSettings
+func (_mock *MockSettings) SaveHostname(hostname string) error {
+	ret := _mock.Called(hostname)
 
 	if len(ret) == 0 {
 		panic("no return value specified for SaveHostname")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string) error); ok {
-		r0 = rf(hostname)
+	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
+		r0 = returnFunc(hostname)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -431,37 +451,29 @@ type MockSettings_SaveHostname_Call struct {
 
 // SaveHostname is a helper method to define mock.On call
 //   - hostname string
-func (_e *MockSettings_Expecter) SaveHostname(hostname interface{}) *MockSettings_SaveHostname_Call {
+func (_e *MockSettings_Expecter) SaveHostname(hostname any) *MockSettings_SaveHostname_Call {
 	return &MockSettings_SaveHostname_Call{Call: _e.mock.On("SaveHostname", hostname)}
 }
 
 func (_c *MockSettings_SaveHostname_Call) Run(run func(hostname string)) *MockSettings_SaveHostname_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockSettings_SaveHostname_Call) Return(_a0 error) *MockSettings_SaveHostname_Call {
-	_c.Call.Return(_a0)
+func (_c *MockSettings_SaveHostname_Call) Return(err error) *MockSettings_SaveHostname_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockSettings_SaveHostname_Call) RunAndReturn(run func(string) error) *MockSettings_SaveHostname_Call {
+func (_c *MockSettings_SaveHostname_Call) RunAndReturn(run func(hostname string) error) *MockSettings_SaveHostname_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockSettings creates a new instance of MockSettings. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockSettings(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockSettings {
-	mock := &MockSettings{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/github.com/godbus/dbus/v5/mock_BusObject.go

@@ -1,14 +1,30 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package dbus
 
 import (
-	context "context"
+	"context"
 
-	dbus "github.com/godbus/dbus/v5"
+	"github.com/godbus/dbus/v5"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockBusObject creates a new instance of MockBusObject. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockBusObject(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockBusObject {
+	mock := &MockBusObject{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockBusObject is an autogenerated mock type for the BusObject type
 type MockBusObject struct {
 	mock.Mock
@@ -22,30 +38,30 @@ func (_m *MockBusObject) EXPECT() *MockBusObject_Expecter {
 	return &MockBusObject_Expecter{mock: &_m.Mock}
 }
 
-// AddMatchSignal provides a mock function with given fields: iface, member, options
-func (_m *MockBusObject) AddMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call {
-	_va := make([]interface{}, len(options))
+// AddMatchSignal provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) AddMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call {
+	// dbus.MatchOption
+	_va := make([]any, len(options))
 	for _i := range options {
 		_va[_i] = options[_i]
 	}
-	var _ca []interface{}
+	var _ca []any
 	_ca = append(_ca, iface, member)
 	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
+	ret := _mock.Called(_ca...)
 
 	if len(ret) == 0 {
 		panic("no return value specified for AddMatchSignal")
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok {
-		r0 = rf(iface, member, options...)
+	if returnFunc, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok {
+		r0 = returnFunc(iface, member, options...)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*dbus.Call)
 		}
 	}
-
 	return r0
 }
 
@@ -58,54 +74,67 @@ type MockBusObject_AddMatchSignal_Call struct {
 //   - iface string
 //   - member string
 //   - options ...dbus.MatchOption
-func (_e *MockBusObject_Expecter) AddMatchSignal(iface interface{}, member interface{}, options ...interface{}) *MockBusObject_AddMatchSignal_Call {
+func (_e *MockBusObject_Expecter) AddMatchSignal(iface any, member any, options ...any) *MockBusObject_AddMatchSignal_Call {
 	return &MockBusObject_AddMatchSignal_Call{Call: _e.mock.On("AddMatchSignal",
-		append([]interface{}{iface, member}, options...)...)}
+		append([]any{iface, member}, options...)...)}
 }
 
 func (_c *MockBusObject_AddMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_AddMatchSignal_Call {
 	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 []dbus.MatchOption
 		variadicArgs := make([]dbus.MatchOption, len(args)-2)
 		for i, a := range args[2:] {
 			if a != nil {
 				variadicArgs[i] = a.(dbus.MatchOption)
 			}
 		}
-		run(args[0].(string), args[1].(string), variadicArgs...)
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_AddMatchSignal_Call) Return(_a0 *dbus.Call) *MockBusObject_AddMatchSignal_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_AddMatchSignal_Call) Return(call *dbus.Call) *MockBusObject_AddMatchSignal_Call {
+	_c.Call.Return(call)
 	return _c
 }
 
-func (_c *MockBusObject_AddMatchSignal_Call) RunAndReturn(run func(string, string, ...dbus.MatchOption) *dbus.Call) *MockBusObject_AddMatchSignal_Call {
+func (_c *MockBusObject_AddMatchSignal_Call) RunAndReturn(run func(iface string, member string, options ...dbus.MatchOption) *dbus.Call) *MockBusObject_AddMatchSignal_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Call provides a mock function with given fields: method, flags, args
-func (_m *MockBusObject) Call(method string, flags dbus.Flags, args ...interface{}) *dbus.Call {
-	var _ca []interface{}
+// Call provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) Call(method string, flags dbus.Flags, args ...any) *dbus.Call {
+	var _ca []any
 	_ca = append(_ca, method, flags)
 	_ca = append(_ca, args...)
-	ret := _m.Called(_ca...)
+	ret := _mock.Called(_ca...)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Call")
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(string, dbus.Flags, ...interface{}) *dbus.Call); ok {
-		r0 = rf(method, flags, args...)
+	if returnFunc, ok := ret.Get(0).(func(string, dbus.Flags, ...any) *dbus.Call); ok {
+		r0 = returnFunc(method, flags, args...)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*dbus.Call)
 		}
 	}
-
 	return r0
 }
 
@@ -117,55 +146,68 @@ type MockBusObject_Call_Call struct {
 // Call is a helper method to define mock.On call
 //   - method string
 //   - flags dbus.Flags
-//   - args ...interface{}
-func (_e *MockBusObject_Expecter) Call(method interface{}, flags interface{}, args ...interface{}) *MockBusObject_Call_Call {
+//   - args ...any
+func (_e *MockBusObject_Expecter) Call(method any, flags any, args ...any) *MockBusObject_Call_Call {
 	return &MockBusObject_Call_Call{Call: _e.mock.On("Call",
-		append([]interface{}{method, flags}, args...)...)}
+		append([]any{method, flags}, args...)...)}
 }
 
-func (_c *MockBusObject_Call_Call) Run(run func(method string, flags dbus.Flags, args ...interface{})) *MockBusObject_Call_Call {
+func (_c *MockBusObject_Call_Call) Run(run func(method string, flags dbus.Flags, args ...any)) *MockBusObject_Call_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]interface{}, len(args)-2)
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 dbus.Flags
+		if args[1] != nil {
+			arg1 = args[1].(dbus.Flags)
+		}
+		var arg2 []any
+		variadicArgs := make([]any, len(args)-2)
 		for i, a := range args[2:] {
 			if a != nil {
-				variadicArgs[i] = a.(interface{})
+				variadicArgs[i] = a.(any)
 			}
 		}
-		run(args[0].(string), args[1].(dbus.Flags), variadicArgs...)
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_Call_Call) Return(_a0 *dbus.Call) *MockBusObject_Call_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_Call_Call) Return(call *dbus.Call) *MockBusObject_Call_Call {
+	_c.Call.Return(call)
 	return _c
 }
 
-func (_c *MockBusObject_Call_Call) RunAndReturn(run func(string, dbus.Flags, ...interface{}) *dbus.Call) *MockBusObject_Call_Call {
+func (_c *MockBusObject_Call_Call) RunAndReturn(run func(method string, flags dbus.Flags, args ...any) *dbus.Call) *MockBusObject_Call_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// CallWithContext provides a mock function with given fields: ctx, method, flags, args
-func (_m *MockBusObject) CallWithContext(ctx context.Context, method string, flags dbus.Flags, args ...interface{}) *dbus.Call {
-	var _ca []interface{}
+// CallWithContext provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) CallWithContext(ctx context.Context, method string, flags dbus.Flags, args ...any) *dbus.Call {
+	var _ca []any
 	_ca = append(_ca, ctx, method, flags)
 	_ca = append(_ca, args...)
-	ret := _m.Called(_ca...)
+	ret := _mock.Called(_ca...)
 
 	if len(ret) == 0 {
 		panic("no return value specified for CallWithContext")
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, ...interface{}) *dbus.Call); ok {
-		r0 = rf(ctx, method, flags, args...)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, ...any) *dbus.Call); ok {
+		r0 = returnFunc(ctx, method, flags, args...)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*dbus.Call)
 		}
 	}
-
 	return r0
 }
 
@@ -178,50 +220,68 @@ type MockBusObject_CallWithContext_Call struct {
 //   - ctx context.Context
 //   - method string
 //   - flags dbus.Flags
-//   - args ...interface{}
-func (_e *MockBusObject_Expecter) CallWithContext(ctx interface{}, method interface{}, flags interface{}, args ...interface{}) *MockBusObject_CallWithContext_Call {
+//   - args ...any
+func (_e *MockBusObject_Expecter) CallWithContext(ctx any, method any, flags any, args ...any) *MockBusObject_CallWithContext_Call {
 	return &MockBusObject_CallWithContext_Call{Call: _e.mock.On("CallWithContext",
-		append([]interface{}{ctx, method, flags}, args...)...)}
+		append([]any{ctx, method, flags}, args...)...)}
 }
 
-func (_c *MockBusObject_CallWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, args ...interface{})) *MockBusObject_CallWithContext_Call {
+func (_c *MockBusObject_CallWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, args ...any)) *MockBusObject_CallWithContext_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]interface{}, len(args)-3)
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 dbus.Flags
+		if args[2] != nil {
+			arg2 = args[2].(dbus.Flags)
+		}
+		var arg3 []any
+		variadicArgs := make([]any, len(args)-3)
 		for i, a := range args[3:] {
 			if a != nil {
-				variadicArgs[i] = a.(interface{})
+				variadicArgs[i] = a.(any)
 			}
 		}
-		run(args[0].(context.Context), args[1].(string), args[2].(dbus.Flags), variadicArgs...)
+		arg3 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2,
+			arg3...,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_CallWithContext_Call) Return(_a0 *dbus.Call) *MockBusObject_CallWithContext_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_CallWithContext_Call) Return(call *dbus.Call) *MockBusObject_CallWithContext_Call {
+	_c.Call.Return(call)
 	return _c
 }
 
-func (_c *MockBusObject_CallWithContext_Call) RunAndReturn(run func(context.Context, string, dbus.Flags, ...interface{}) *dbus.Call) *MockBusObject_CallWithContext_Call {
+func (_c *MockBusObject_CallWithContext_Call) RunAndReturn(run func(ctx context.Context, method string, flags dbus.Flags, args ...any) *dbus.Call) *MockBusObject_CallWithContext_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Destination provides a mock function with no fields
-func (_m *MockBusObject) Destination() string {
-	ret := _m.Called()
+// Destination provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) Destination() string {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Destination")
 	}
 
 	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(string)
 	}
-
 	return r0
 }
 
@@ -242,8 +302,8 @@ func (_c *MockBusObject_Destination_Call) Run(run func()) *MockBusObject_Destina
 	return _c
 }
 
-func (_c *MockBusObject_Destination_Call) Return(_a0 string) *MockBusObject_Destination_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_Destination_Call) Return(s string) *MockBusObject_Destination_Call {
+	_c.Call.Return(s)
 	return _c
 }
 
@@ -252,9 +312,9 @@ func (_c *MockBusObject_Destination_Call) RunAndReturn(run func() string) *MockB
 	return _c
 }
 
-// GetProperty provides a mock function with given fields: p
-func (_m *MockBusObject) GetProperty(p string) (dbus.Variant, error) {
-	ret := _m.Called(p)
+// GetProperty provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) GetProperty(p string) (dbus.Variant, error) {
+	ret := _mock.Called(p)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetProperty")
@@ -262,21 +322,19 @@ func (_m *MockBusObject) GetProperty(p string) (dbus.Variant, error) {
 
 	var r0 dbus.Variant
 	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (dbus.Variant, error)); ok {
-		return rf(p)
+	if returnFunc, ok := ret.Get(0).(func(string) (dbus.Variant, error)); ok {
+		return returnFunc(p)
 	}
-	if rf, ok := ret.Get(0).(func(string) dbus.Variant); ok {
-		r0 = rf(p)
+	if returnFunc, ok := ret.Get(0).(func(string) dbus.Variant); ok {
+		r0 = returnFunc(p)
 	} else {
 		r0 = ret.Get(0).(dbus.Variant)
 	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(p)
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(p)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -287,47 +345,52 @@ type MockBusObject_GetProperty_Call struct {
 
 // GetProperty is a helper method to define mock.On call
 //   - p string
-func (_e *MockBusObject_Expecter) GetProperty(p interface{}) *MockBusObject_GetProperty_Call {
+func (_e *MockBusObject_Expecter) GetProperty(p any) *MockBusObject_GetProperty_Call {
 	return &MockBusObject_GetProperty_Call{Call: _e.mock.On("GetProperty", p)}
 }
 
 func (_c *MockBusObject_GetProperty_Call) Run(run func(p string)) *MockBusObject_GetProperty_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_GetProperty_Call) Return(_a0 dbus.Variant, _a1 error) *MockBusObject_GetProperty_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockBusObject_GetProperty_Call) Return(variant dbus.Variant, err error) *MockBusObject_GetProperty_Call {
+	_c.Call.Return(variant, err)
 	return _c
 }
 
-func (_c *MockBusObject_GetProperty_Call) RunAndReturn(run func(string) (dbus.Variant, error)) *MockBusObject_GetProperty_Call {
+func (_c *MockBusObject_GetProperty_Call) RunAndReturn(run func(p string) (dbus.Variant, error)) *MockBusObject_GetProperty_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Go provides a mock function with given fields: method, flags, ch, args
-func (_m *MockBusObject) Go(method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call {
-	var _ca []interface{}
+// Go provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) Go(method string, flags dbus.Flags, ch chan *dbus.Call, args ...any) *dbus.Call {
+	var _ca []any
 	_ca = append(_ca, method, flags, ch)
 	_ca = append(_ca, args...)
-	ret := _m.Called(_ca...)
+	ret := _mock.Called(_ca...)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Go")
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call); ok {
-		r0 = rf(method, flags, ch, args...)
+	if returnFunc, ok := ret.Get(0).(func(string, dbus.Flags, chan *dbus.Call, ...any) *dbus.Call); ok {
+		r0 = returnFunc(method, flags, ch, args...)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*dbus.Call)
 		}
 	}
-
 	return r0
 }
 
@@ -340,55 +403,73 @@ type MockBusObject_Go_Call struct {
 //   - method string
 //   - flags dbus.Flags
 //   - ch chan *dbus.Call
-//   - args ...interface{}
-func (_e *MockBusObject_Expecter) Go(method interface{}, flags interface{}, ch interface{}, args ...interface{}) *MockBusObject_Go_Call {
+//   - args ...any
+func (_e *MockBusObject_Expecter) Go(method any, flags any, ch any, args ...any) *MockBusObject_Go_Call {
 	return &MockBusObject_Go_Call{Call: _e.mock.On("Go",
-		append([]interface{}{method, flags, ch}, args...)...)}
+		append([]any{method, flags, ch}, args...)...)}
 }
 
-func (_c *MockBusObject_Go_Call) Run(run func(method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{})) *MockBusObject_Go_Call {
+func (_c *MockBusObject_Go_Call) Run(run func(method string, flags dbus.Flags, ch chan *dbus.Call, args ...any)) *MockBusObject_Go_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]interface{}, len(args)-3)
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 dbus.Flags
+		if args[1] != nil {
+			arg1 = args[1].(dbus.Flags)
+		}
+		var arg2 chan *dbus.Call
+		if args[2] != nil {
+			arg2 = args[2].(chan *dbus.Call)
+		}
+		var arg3 []any
+		variadicArgs := make([]any, len(args)-3)
 		for i, a := range args[3:] {
 			if a != nil {
-				variadicArgs[i] = a.(interface{})
+				variadicArgs[i] = a.(any)
 			}
 		}
-		run(args[0].(string), args[1].(dbus.Flags), args[2].(chan *dbus.Call), variadicArgs...)
+		arg3 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2,
+			arg3...,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_Go_Call) Return(_a0 *dbus.Call) *MockBusObject_Go_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_Go_Call) Return(call *dbus.Call) *MockBusObject_Go_Call {
+	_c.Call.Return(call)
 	return _c
 }
 
-func (_c *MockBusObject_Go_Call) RunAndReturn(run func(string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call) *MockBusObject_Go_Call {
+func (_c *MockBusObject_Go_Call) RunAndReturn(run func(method string, flags dbus.Flags, ch chan *dbus.Call, args ...any) *dbus.Call) *MockBusObject_Go_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GoWithContext provides a mock function with given fields: ctx, method, flags, ch, args
-func (_m *MockBusObject) GoWithContext(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call {
-	var _ca []interface{}
+// GoWithContext provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) GoWithContext(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...any) *dbus.Call {
+	var _ca []any
 	_ca = append(_ca, ctx, method, flags, ch)
 	_ca = append(_ca, args...)
-	ret := _m.Called(_ca...)
+	ret := _mock.Called(_ca...)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GoWithContext")
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call); ok {
-		r0 = rf(ctx, method, flags, ch, args...)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, dbus.Flags, chan *dbus.Call, ...any) *dbus.Call); ok {
+		r0 = returnFunc(ctx, method, flags, ch, args...)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*dbus.Call)
 		}
 	}
-
 	return r0
 }
 
@@ -402,50 +483,73 @@ type MockBusObject_GoWithContext_Call struct {
 //   - method string
 //   - flags dbus.Flags
 //   - ch chan *dbus.Call
-//   - args ...interface{}
-func (_e *MockBusObject_Expecter) GoWithContext(ctx interface{}, method interface{}, flags interface{}, ch interface{}, args ...interface{}) *MockBusObject_GoWithContext_Call {
+//   - args ...any
+func (_e *MockBusObject_Expecter) GoWithContext(ctx any, method any, flags any, ch any, args ...any) *MockBusObject_GoWithContext_Call {
 	return &MockBusObject_GoWithContext_Call{Call: _e.mock.On("GoWithContext",
-		append([]interface{}{ctx, method, flags, ch}, args...)...)}
+		append([]any{ctx, method, flags, ch}, args...)...)}
 }
 
-func (_c *MockBusObject_GoWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{})) *MockBusObject_GoWithContext_Call {
+func (_c *MockBusObject_GoWithContext_Call) Run(run func(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...any)) *MockBusObject_GoWithContext_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]interface{}, len(args)-4)
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 dbus.Flags
+		if args[2] != nil {
+			arg2 = args[2].(dbus.Flags)
+		}
+		var arg3 chan *dbus.Call
+		if args[3] != nil {
+			arg3 = args[3].(chan *dbus.Call)
+		}
+		var arg4 []any
+		variadicArgs := make([]any, len(args)-4)
 		for i, a := range args[4:] {
 			if a != nil {
-				variadicArgs[i] = a.(interface{})
+				variadicArgs[i] = a.(any)
 			}
 		}
-		run(args[0].(context.Context), args[1].(string), args[2].(dbus.Flags), args[3].(chan *dbus.Call), variadicArgs...)
+		arg4 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+			arg4...,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_GoWithContext_Call) Return(_a0 *dbus.Call) *MockBusObject_GoWithContext_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_GoWithContext_Call) Return(call *dbus.Call) *MockBusObject_GoWithContext_Call {
+	_c.Call.Return(call)
 	return _c
 }
 
-func (_c *MockBusObject_GoWithContext_Call) RunAndReturn(run func(context.Context, string, dbus.Flags, chan *dbus.Call, ...interface{}) *dbus.Call) *MockBusObject_GoWithContext_Call {
+func (_c *MockBusObject_GoWithContext_Call) RunAndReturn(run func(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...any) *dbus.Call) *MockBusObject_GoWithContext_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Path provides a mock function with no fields
-func (_m *MockBusObject) Path() dbus.ObjectPath {
-	ret := _m.Called()
+// Path provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) Path() dbus.ObjectPath {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Path")
 	}
 
 	var r0 dbus.ObjectPath
-	if rf, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() dbus.ObjectPath); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Get(0).(dbus.ObjectPath)
 	}
-
 	return r0
 }
 
@@ -466,8 +570,8 @@ func (_c *MockBusObject_Path_Call) Run(run func()) *MockBusObject_Path_Call {
 	return _c
 }
 
-func (_c *MockBusObject_Path_Call) Return(_a0 dbus.ObjectPath) *MockBusObject_Path_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_Path_Call) Return(objectPath dbus.ObjectPath) *MockBusObject_Path_Call {
+	_c.Call.Return(objectPath)
 	return _c
 }
 
@@ -476,30 +580,30 @@ func (_c *MockBusObject_Path_Call) RunAndReturn(run func() dbus.ObjectPath) *Moc
 	return _c
 }
 
-// RemoveMatchSignal provides a mock function with given fields: iface, member, options
-func (_m *MockBusObject) RemoveMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call {
-	_va := make([]interface{}, len(options))
+// RemoveMatchSignal provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) RemoveMatchSignal(iface string, member string, options ...dbus.MatchOption) *dbus.Call {
+	// dbus.MatchOption
+	_va := make([]any, len(options))
 	for _i := range options {
 		_va[_i] = options[_i]
 	}
-	var _ca []interface{}
+	var _ca []any
 	_ca = append(_ca, iface, member)
 	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
+	ret := _mock.Called(_ca...)
 
 	if len(ret) == 0 {
 		panic("no return value specified for RemoveMatchSignal")
 	}
 
 	var r0 *dbus.Call
-	if rf, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok {
-		r0 = rf(iface, member, options...)
+	if returnFunc, ok := ret.Get(0).(func(string, string, ...dbus.MatchOption) *dbus.Call); ok {
+		r0 = returnFunc(iface, member, options...)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*dbus.Call)
 		}
 	}
-
 	return r0
 }
 
@@ -512,49 +616,62 @@ type MockBusObject_RemoveMatchSignal_Call struct {
 //   - iface string
 //   - member string
 //   - options ...dbus.MatchOption
-func (_e *MockBusObject_Expecter) RemoveMatchSignal(iface interface{}, member interface{}, options ...interface{}) *MockBusObject_RemoveMatchSignal_Call {
+func (_e *MockBusObject_Expecter) RemoveMatchSignal(iface any, member any, options ...any) *MockBusObject_RemoveMatchSignal_Call {
 	return &MockBusObject_RemoveMatchSignal_Call{Call: _e.mock.On("RemoveMatchSignal",
-		append([]interface{}{iface, member}, options...)...)}
+		append([]any{iface, member}, options...)...)}
 }
 
 func (_c *MockBusObject_RemoveMatchSignal_Call) Run(run func(iface string, member string, options ...dbus.MatchOption)) *MockBusObject_RemoveMatchSignal_Call {
 	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		var arg2 []dbus.MatchOption
 		variadicArgs := make([]dbus.MatchOption, len(args)-2)
 		for i, a := range args[2:] {
 			if a != nil {
 				variadicArgs[i] = a.(dbus.MatchOption)
 			}
 		}
-		run(args[0].(string), args[1].(string), variadicArgs...)
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_RemoveMatchSignal_Call) Return(_a0 *dbus.Call) *MockBusObject_RemoveMatchSignal_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_RemoveMatchSignal_Call) Return(call *dbus.Call) *MockBusObject_RemoveMatchSignal_Call {
+	_c.Call.Return(call)
 	return _c
 }
 
-func (_c *MockBusObject_RemoveMatchSignal_Call) RunAndReturn(run func(string, string, ...dbus.MatchOption) *dbus.Call) *MockBusObject_RemoveMatchSignal_Call {
+func (_c *MockBusObject_RemoveMatchSignal_Call) RunAndReturn(run func(iface string, member string, options ...dbus.MatchOption) *dbus.Call) *MockBusObject_RemoveMatchSignal_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// SetProperty provides a mock function with given fields: p, v
-func (_m *MockBusObject) SetProperty(p string, v interface{}) error {
-	ret := _m.Called(p, v)
+// SetProperty provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) SetProperty(p string, v any) error {
+	ret := _mock.Called(p, v)
 
 	if len(ret) == 0 {
 		panic("no return value specified for SetProperty")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string, interface{}) error); ok {
-		r0 = rf(p, v)
+	if returnFunc, ok := ret.Get(0).(func(string, any) error); ok {
+		r0 = returnFunc(p, v)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -565,43 +682,53 @@ type MockBusObject_SetProperty_Call struct {
 
 // SetProperty is a helper method to define mock.On call
 //   - p string
-//   - v interface{}
-func (_e *MockBusObject_Expecter) SetProperty(p interface{}, v interface{}) *MockBusObject_SetProperty_Call {
+//   - v any
+func (_e *MockBusObject_Expecter) SetProperty(p any, v any) *MockBusObject_SetProperty_Call {
 	return &MockBusObject_SetProperty_Call{Call: _e.mock.On("SetProperty", p, v)}
 }
 
-func (_c *MockBusObject_SetProperty_Call) Run(run func(p string, v interface{})) *MockBusObject_SetProperty_Call {
+func (_c *MockBusObject_SetProperty_Call) Run(run func(p string, v any)) *MockBusObject_SetProperty_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(interface{}))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 any
+		if args[1] != nil {
+			arg1 = args[1].(any)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_SetProperty_Call) Return(_a0 error) *MockBusObject_SetProperty_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_SetProperty_Call) Return(err error) *MockBusObject_SetProperty_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockBusObject_SetProperty_Call) RunAndReturn(run func(string, interface{}) error) *MockBusObject_SetProperty_Call {
+func (_c *MockBusObject_SetProperty_Call) RunAndReturn(run func(p string, v any) error) *MockBusObject_SetProperty_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// StoreProperty provides a mock function with given fields: p, value
-func (_m *MockBusObject) StoreProperty(p string, value interface{}) error {
-	ret := _m.Called(p, value)
+// StoreProperty provides a mock function for the type MockBusObject
+func (_mock *MockBusObject) StoreProperty(p string, value any) error {
+	ret := _mock.Called(p, value)
 
 	if len(ret) == 0 {
 		panic("no return value specified for StoreProperty")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string, interface{}) error); ok {
-		r0 = rf(p, value)
+	if returnFunc, ok := ret.Get(0).(func(string, any) error); ok {
+		r0 = returnFunc(p, value)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -612,38 +739,35 @@ type MockBusObject_StoreProperty_Call struct {
 
 // StoreProperty is a helper method to define mock.On call
 //   - p string
-//   - value interface{}
-func (_e *MockBusObject_Expecter) StoreProperty(p interface{}, value interface{}) *MockBusObject_StoreProperty_Call {
+//   - value any
+func (_e *MockBusObject_Expecter) StoreProperty(p any, value any) *MockBusObject_StoreProperty_Call {
 	return &MockBusObject_StoreProperty_Call{Call: _e.mock.On("StoreProperty", p, value)}
 }
 
-func (_c *MockBusObject_StoreProperty_Call) Run(run func(p string, value interface{})) *MockBusObject_StoreProperty_Call {
+func (_c *MockBusObject_StoreProperty_Call) Run(run func(p string, value any)) *MockBusObject_StoreProperty_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(interface{}))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 any
+		if args[1] != nil {
+			arg1 = args[1].(any)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *MockBusObject_StoreProperty_Call) Return(_a0 error) *MockBusObject_StoreProperty_Call {
-	_c.Call.Return(_a0)
+func (_c *MockBusObject_StoreProperty_Call) Return(err error) *MockBusObject_StoreProperty_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockBusObject_StoreProperty_Call) RunAndReturn(run func(string, interface{}) error) *MockBusObject_StoreProperty_Call {
+func (_c *MockBusObject_StoreProperty_Call) RunAndReturn(run func(p string, value any) error) *MockBusObject_StoreProperty_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockBusObject creates a new instance of MockBusObject. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockBusObject(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockBusObject {
-	mock := &MockBusObject{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/internal/plugins/mock_GitClient.go

@@ -1,8 +1,26 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package plugins
 
-import mock "github.com/stretchr/testify/mock"
+import (
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockGitClient creates a new instance of MockGitClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockGitClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockGitClient {
+	mock := &MockGitClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
 
 // MockGitClient is an autogenerated mock type for the GitClient type
 type MockGitClient struct {
@@ -17,9 +35,9 @@ func (_m *MockGitClient) EXPECT() *MockGitClient_Expecter {
 	return &MockGitClient_Expecter{mock: &_m.Mock}
 }
 
-// HasUpdates provides a mock function with given fields: path
-func (_m *MockGitClient) HasUpdates(path string) (bool, error) {
-	ret := _m.Called(path)
+// HasUpdates provides a mock function for the type MockGitClient
+func (_mock *MockGitClient) HasUpdates(path string) (bool, error) {
+	ret := _mock.Called(path)
 
 	if len(ret) == 0 {
 		panic("no return value specified for HasUpdates")
@@ -27,21 +45,19 @@ func (_m *MockGitClient) HasUpdates(path string) (bool, error) {
 
 	var r0 bool
 	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (bool, error)); ok {
-		return rf(path)
+	if returnFunc, ok := ret.Get(0).(func(string) (bool, error)); ok {
+		return returnFunc(path)
 	}
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(path)
+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = returnFunc(path)
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(path)
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(path)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -58,36 +74,41 @@ func (_e *MockGitClient_Expecter) HasUpdates(path any) *MockGitClient_HasUpdates
 
 func (_c *MockGitClient_HasUpdates_Call) Run(run func(path string)) *MockGitClient_HasUpdates_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockGitClient_HasUpdates_Call) Return(_a0 bool, _a1 error) *MockGitClient_HasUpdates_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockGitClient_HasUpdates_Call) Return(b bool, err error) *MockGitClient_HasUpdates_Call {
+	_c.Call.Return(b, err)
 	return _c
 }
 
-func (_c *MockGitClient_HasUpdates_Call) RunAndReturn(run func(string) (bool, error)) *MockGitClient_HasUpdates_Call {
+func (_c *MockGitClient_HasUpdates_Call) RunAndReturn(run func(path string) (bool, error)) *MockGitClient_HasUpdates_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// PlainClone provides a mock function with given fields: path, url
-func (_m *MockGitClient) PlainClone(path string, url string) error {
-	ret := _m.Called(path, url)
+// PlainClone provides a mock function for the type MockGitClient
+func (_mock *MockGitClient) PlainClone(path string, url string) error {
+	ret := _mock.Called(path, url)
 
 	if len(ret) == 0 {
 		panic("no return value specified for PlainClone")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string, string) error); ok {
-		r0 = rf(path, url)
+	if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = returnFunc(path, url)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -105,36 +126,46 @@ func (_e *MockGitClient_Expecter) PlainClone(path any, url any) *MockGitClient_P
 
 func (_c *MockGitClient_PlainClone_Call) Run(run func(path string, url string)) *MockGitClient_PlainClone_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		var arg1 string
+		if args[1] != nil {
+			arg1 = args[1].(string)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *MockGitClient_PlainClone_Call) Return(_a0 error) *MockGitClient_PlainClone_Call {
-	_c.Call.Return(_a0)
+func (_c *MockGitClient_PlainClone_Call) Return(err error) *MockGitClient_PlainClone_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockGitClient_PlainClone_Call) RunAndReturn(run func(string, string) error) *MockGitClient_PlainClone_Call {
+func (_c *MockGitClient_PlainClone_Call) RunAndReturn(run func(path string, url string) error) *MockGitClient_PlainClone_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Pull provides a mock function with given fields: path
-func (_m *MockGitClient) Pull(path string) error {
-	ret := _m.Called(path)
+// Pull provides a mock function for the type MockGitClient
+func (_mock *MockGitClient) Pull(path string) error {
+	ret := _mock.Called(path)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Pull")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(string) error); ok {
-		r0 = rf(path)
+	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
+		r0 = returnFunc(path)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -151,31 +182,23 @@ func (_e *MockGitClient_Expecter) Pull(path any) *MockGitClient_Pull_Call {
 
 func (_c *MockGitClient_Pull_Call) Run(run func(path string)) *MockGitClient_Pull_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockGitClient_Pull_Call) Return(_a0 error) *MockGitClient_Pull_Call {
-	_c.Call.Return(_a0)
+func (_c *MockGitClient_Pull_Call) Return(err error) *MockGitClient_Pull_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockGitClient_Pull_Call) RunAndReturn(run func(string) error) *MockGitClient_Pull_Call {
+func (_c *MockGitClient_Pull_Call) RunAndReturn(run func(path string) error) *MockGitClient_Pull_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockGitClient creates a new instance of MockGitClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockGitClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockGitClient {
-	mock := &MockGitClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/net/mock_Conn.go

@@ -1,15 +1,30 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package net
 
 import (
-	net "net"
+	"net"
+	"time"
 
 	mock "github.com/stretchr/testify/mock"
-
-	time "time"
 )
 
+// NewMockConn creates a new instance of MockConn. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockConn(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockConn {
+	mock := &MockConn{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockConn is an autogenerated mock type for the Conn type
 type MockConn struct {
 	mock.Mock
@@ -23,21 +38,20 @@ func (_m *MockConn) EXPECT() *MockConn_Expecter {
 	return &MockConn_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with no fields
-func (_m *MockConn) Close() error {
-	ret := _m.Called()
+// Close provides a mock function for the type MockConn
+func (_mock *MockConn) Close() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Close")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -58,8 +72,8 @@ func (_c *MockConn_Close_Call) Run(run func()) *MockConn_Close_Call {
 	return _c
 }
 
-func (_c *MockConn_Close_Call) Return(_a0 error) *MockConn_Close_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConn_Close_Call) Return(err error) *MockConn_Close_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -68,23 +82,22 @@ func (_c *MockConn_Close_Call) RunAndReturn(run func() error) *MockConn_Close_Ca
 	return _c
 }
 
-// LocalAddr provides a mock function with no fields
-func (_m *MockConn) LocalAddr() net.Addr {
-	ret := _m.Called()
+// LocalAddr provides a mock function for the type MockConn
+func (_mock *MockConn) LocalAddr() net.Addr {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for LocalAddr")
 	}
 
 	var r0 net.Addr
-	if rf, ok := ret.Get(0).(func() net.Addr); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() net.Addr); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(net.Addr)
 		}
 	}
-
 	return r0
 }
 
@@ -105,8 +118,8 @@ func (_c *MockConn_LocalAddr_Call) Run(run func()) *MockConn_LocalAddr_Call {
 	return _c
 }
 
-func (_c *MockConn_LocalAddr_Call) Return(_a0 net.Addr) *MockConn_LocalAddr_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConn_LocalAddr_Call) Return(addr net.Addr) *MockConn_LocalAddr_Call {
+	_c.Call.Return(addr)
 	return _c
 }
 
@@ -115,9 +128,9 @@ func (_c *MockConn_LocalAddr_Call) RunAndReturn(run func() net.Addr) *MockConn_L
 	return _c
 }
 
-// Read provides a mock function with given fields: b
-func (_m *MockConn) Read(b []byte) (int, error) {
-	ret := _m.Called(b)
+// Read provides a mock function for the type MockConn
+func (_mock *MockConn) Read(b []byte) (int, error) {
+	ret := _mock.Called(b)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Read")
@@ -125,21 +138,19 @@ func (_m *MockConn) Read(b []byte) (int, error) {
 
 	var r0 int
 	var r1 error
-	if rf, ok := ret.Get(0).(func([]byte) (int, error)); ok {
-		return rf(b)
+	if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
+		return returnFunc(b)
 	}
-	if rf, ok := ret.Get(0).(func([]byte) int); ok {
-		r0 = rf(b)
+	if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
+		r0 = returnFunc(b)
 	} else {
 		r0 = ret.Get(0).(int)
 	}
-
-	if rf, ok := ret.Get(1).(func([]byte) error); ok {
-		r1 = rf(b)
+	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
+		r1 = returnFunc(b)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -150,13 +161,19 @@ type MockConn_Read_Call struct {
 
 // Read is a helper method to define mock.On call
 //   - b []byte
-func (_e *MockConn_Expecter) Read(b interface{}) *MockConn_Read_Call {
+func (_e *MockConn_Expecter) Read(b any) *MockConn_Read_Call {
 	return &MockConn_Read_Call{Call: _e.mock.On("Read", b)}
 }
 
 func (_c *MockConn_Read_Call) Run(run func(b []byte)) *MockConn_Read_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].([]byte))
+		var arg0 []byte
+		if args[0] != nil {
+			arg0 = args[0].([]byte)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -166,28 +183,27 @@ func (_c *MockConn_Read_Call) Return(n int, err error) *MockConn_Read_Call {
 	return _c
 }
 
-func (_c *MockConn_Read_Call) RunAndReturn(run func([]byte) (int, error)) *MockConn_Read_Call {
+func (_c *MockConn_Read_Call) RunAndReturn(run func(b []byte) (int, error)) *MockConn_Read_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// RemoteAddr provides a mock function with no fields
-func (_m *MockConn) RemoteAddr() net.Addr {
-	ret := _m.Called()
+// RemoteAddr provides a mock function for the type MockConn
+func (_mock *MockConn) RemoteAddr() net.Addr {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for RemoteAddr")
 	}
 
 	var r0 net.Addr
-	if rf, ok := ret.Get(0).(func() net.Addr); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() net.Addr); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(net.Addr)
 		}
 	}
-
 	return r0
 }
 
@@ -208,8 +224,8 @@ func (_c *MockConn_RemoteAddr_Call) Run(run func()) *MockConn_RemoteAddr_Call {
 	return _c
 }
 
-func (_c *MockConn_RemoteAddr_Call) Return(_a0 net.Addr) *MockConn_RemoteAddr_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConn_RemoteAddr_Call) Return(addr net.Addr) *MockConn_RemoteAddr_Call {
+	_c.Call.Return(addr)
 	return _c
 }
 
@@ -218,21 +234,20 @@ func (_c *MockConn_RemoteAddr_Call) RunAndReturn(run func() net.Addr) *MockConn_
 	return _c
 }
 
-// SetDeadline provides a mock function with given fields: t
-func (_m *MockConn) SetDeadline(t time.Time) error {
-	ret := _m.Called(t)
+// SetDeadline provides a mock function for the type MockConn
+func (_mock *MockConn) SetDeadline(t time.Time) error {
+	ret := _mock.Called(t)
 
 	if len(ret) == 0 {
 		panic("no return value specified for SetDeadline")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(time.Time) error); ok {
-		r0 = rf(t)
+	if returnFunc, ok := ret.Get(0).(func(time.Time) error); ok {
+		r0 = returnFunc(t)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -243,42 +258,47 @@ type MockConn_SetDeadline_Call struct {
 
 // SetDeadline is a helper method to define mock.On call
 //   - t time.Time
-func (_e *MockConn_Expecter) SetDeadline(t interface{}) *MockConn_SetDeadline_Call {
+func (_e *MockConn_Expecter) SetDeadline(t any) *MockConn_SetDeadline_Call {
 	return &MockConn_SetDeadline_Call{Call: _e.mock.On("SetDeadline", t)}
 }
 
 func (_c *MockConn_SetDeadline_Call) Run(run func(t time.Time)) *MockConn_SetDeadline_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(time.Time))
+		var arg0 time.Time
+		if args[0] != nil {
+			arg0 = args[0].(time.Time)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockConn_SetDeadline_Call) Return(_a0 error) *MockConn_SetDeadline_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConn_SetDeadline_Call) Return(err error) *MockConn_SetDeadline_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockConn_SetDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetDeadline_Call {
+func (_c *MockConn_SetDeadline_Call) RunAndReturn(run func(t time.Time) error) *MockConn_SetDeadline_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// SetReadDeadline provides a mock function with given fields: t
-func (_m *MockConn) SetReadDeadline(t time.Time) error {
-	ret := _m.Called(t)
+// SetReadDeadline provides a mock function for the type MockConn
+func (_mock *MockConn) SetReadDeadline(t time.Time) error {
+	ret := _mock.Called(t)
 
 	if len(ret) == 0 {
 		panic("no return value specified for SetReadDeadline")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(time.Time) error); ok {
-		r0 = rf(t)
+	if returnFunc, ok := ret.Get(0).(func(time.Time) error); ok {
+		r0 = returnFunc(t)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -289,42 +309,47 @@ type MockConn_SetReadDeadline_Call struct {
 
 // SetReadDeadline is a helper method to define mock.On call
 //   - t time.Time
-func (_e *MockConn_Expecter) SetReadDeadline(t interface{}) *MockConn_SetReadDeadline_Call {
+func (_e *MockConn_Expecter) SetReadDeadline(t any) *MockConn_SetReadDeadline_Call {
 	return &MockConn_SetReadDeadline_Call{Call: _e.mock.On("SetReadDeadline", t)}
 }
 
 func (_c *MockConn_SetReadDeadline_Call) Run(run func(t time.Time)) *MockConn_SetReadDeadline_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(time.Time))
+		var arg0 time.Time
+		if args[0] != nil {
+			arg0 = args[0].(time.Time)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockConn_SetReadDeadline_Call) Return(_a0 error) *MockConn_SetReadDeadline_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConn_SetReadDeadline_Call) Return(err error) *MockConn_SetReadDeadline_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockConn_SetReadDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetReadDeadline_Call {
+func (_c *MockConn_SetReadDeadline_Call) RunAndReturn(run func(t time.Time) error) *MockConn_SetReadDeadline_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// SetWriteDeadline provides a mock function with given fields: t
-func (_m *MockConn) SetWriteDeadline(t time.Time) error {
-	ret := _m.Called(t)
+// SetWriteDeadline provides a mock function for the type MockConn
+func (_mock *MockConn) SetWriteDeadline(t time.Time) error {
+	ret := _mock.Called(t)
 
 	if len(ret) == 0 {
 		panic("no return value specified for SetWriteDeadline")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(time.Time) error); ok {
-		r0 = rf(t)
+	if returnFunc, ok := ret.Get(0).(func(time.Time) error); ok {
+		r0 = returnFunc(t)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -335,30 +360,36 @@ type MockConn_SetWriteDeadline_Call struct {
 
 // SetWriteDeadline is a helper method to define mock.On call
 //   - t time.Time
-func (_e *MockConn_Expecter) SetWriteDeadline(t interface{}) *MockConn_SetWriteDeadline_Call {
+func (_e *MockConn_Expecter) SetWriteDeadline(t any) *MockConn_SetWriteDeadline_Call {
 	return &MockConn_SetWriteDeadline_Call{Call: _e.mock.On("SetWriteDeadline", t)}
 }
 
 func (_c *MockConn_SetWriteDeadline_Call) Run(run func(t time.Time)) *MockConn_SetWriteDeadline_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(time.Time))
+		var arg0 time.Time
+		if args[0] != nil {
+			arg0 = args[0].(time.Time)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
 
-func (_c *MockConn_SetWriteDeadline_Call) Return(_a0 error) *MockConn_SetWriteDeadline_Call {
-	_c.Call.Return(_a0)
+func (_c *MockConn_SetWriteDeadline_Call) Return(err error) *MockConn_SetWriteDeadline_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockConn_SetWriteDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetWriteDeadline_Call {
+func (_c *MockConn_SetWriteDeadline_Call) RunAndReturn(run func(t time.Time) error) *MockConn_SetWriteDeadline_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Write provides a mock function with given fields: b
-func (_m *MockConn) Write(b []byte) (int, error) {
-	ret := _m.Called(b)
+// Write provides a mock function for the type MockConn
+func (_mock *MockConn) Write(b []byte) (int, error) {
+	ret := _mock.Called(b)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Write")
@@ -366,21 +397,19 @@ func (_m *MockConn) Write(b []byte) (int, error) {
 
 	var r0 int
 	var r1 error
-	if rf, ok := ret.Get(0).(func([]byte) (int, error)); ok {
-		return rf(b)
+	if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
+		return returnFunc(b)
 	}
-	if rf, ok := ret.Get(0).(func([]byte) int); ok {
-		r0 = rf(b)
+	if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
+		r0 = returnFunc(b)
 	} else {
 		r0 = ret.Get(0).(int)
 	}
-
-	if rf, ok := ret.Get(1).(func([]byte) error); ok {
-		r1 = rf(b)
+	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
+		r1 = returnFunc(b)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -391,13 +420,19 @@ type MockConn_Write_Call struct {
 
 // Write is a helper method to define mock.On call
 //   - b []byte
-func (_e *MockConn_Expecter) Write(b interface{}) *MockConn_Write_Call {
+func (_e *MockConn_Expecter) Write(b any) *MockConn_Write_Call {
 	return &MockConn_Write_Call{Call: _e.mock.On("Write", b)}
 }
 
 func (_c *MockConn_Write_Call) Run(run func(b []byte)) *MockConn_Write_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].([]byte))
+		var arg0 []byte
+		if args[0] != nil {
+			arg0 = args[0].([]byte)
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -407,21 +442,7 @@ func (_c *MockConn_Write_Call) Return(n int, err error) *MockConn_Write_Call {
 	return _c
 }
 
-func (_c *MockConn_Write_Call) RunAndReturn(run func([]byte) (int, error)) *MockConn_Write_Call {
+func (_c *MockConn_Write_Call) RunAndReturn(run func(b []byte) (int, error)) *MockConn_Write_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockConn creates a new instance of MockConn. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockConn(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockConn {
-	mock := &MockConn{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/utils/mock_AppChecker.go

@@ -1,231 +1,12 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks_utils
 
-import mock "github.com/stretchr/testify/mock"
-
-// MockAppChecker is an autogenerated mock type for the AppChecker type
-type MockAppChecker struct {
-	mock.Mock
-}
-
-type MockAppChecker_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *MockAppChecker) EXPECT() *MockAppChecker_Expecter {
-	return &MockAppChecker_Expecter{mock: &_m.Mock}
-}
-
-// AnyCommandExists provides a mock function with given fields: cmds
-func (_m *MockAppChecker) AnyCommandExists(cmds ...string) bool {
-	_va := make([]interface{}, len(cmds))
-	for _i := range cmds {
-		_va[_i] = cmds[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AnyCommandExists")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(...string) bool); ok {
-		r0 = rf(cmds...)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// MockAppChecker_AnyCommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyCommandExists'
-type MockAppChecker_AnyCommandExists_Call struct {
-	*mock.Call
-}
-
-// AnyCommandExists is a helper method to define mock.On call
-//   - cmds ...string
-func (_e *MockAppChecker_Expecter) AnyCommandExists(cmds ...interface{}) *MockAppChecker_AnyCommandExists_Call {
-	return &MockAppChecker_AnyCommandExists_Call{Call: _e.mock.On("AnyCommandExists",
-		append([]interface{}{}, cmds...)...)}
-}
-
-func (_c *MockAppChecker_AnyCommandExists_Call) Run(run func(cmds ...string)) *MockAppChecker_AnyCommandExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]string, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(string)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *MockAppChecker_AnyCommandExists_Call) Return(_a0 bool) *MockAppChecker_AnyCommandExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MockAppChecker_AnyCommandExists_Call) RunAndReturn(run func(...string) bool) *MockAppChecker_AnyCommandExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// AnyFlatpakExists provides a mock function with given fields: flatpaks
-func (_m *MockAppChecker) AnyFlatpakExists(flatpaks ...string) bool {
-	_va := make([]interface{}, len(flatpaks))
-	for _i := range flatpaks {
-		_va[_i] = flatpaks[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AnyFlatpakExists")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(...string) bool); ok {
-		r0 = rf(flatpaks...)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// MockAppChecker_AnyFlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyFlatpakExists'
-type MockAppChecker_AnyFlatpakExists_Call struct {
-	*mock.Call
-}
-
-// AnyFlatpakExists is a helper method to define mock.On call
-//   - flatpaks ...string
-func (_e *MockAppChecker_Expecter) AnyFlatpakExists(flatpaks ...interface{}) *MockAppChecker_AnyFlatpakExists_Call {
-	return &MockAppChecker_AnyFlatpakExists_Call{Call: _e.mock.On("AnyFlatpakExists",
-		append([]interface{}{}, flatpaks...)...)}
-}
-
-func (_c *MockAppChecker_AnyFlatpakExists_Call) Run(run func(flatpaks ...string)) *MockAppChecker_AnyFlatpakExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		variadicArgs := make([]string, len(args)-0)
-		for i, a := range args[0:] {
-			if a != nil {
-				variadicArgs[i] = a.(string)
-			}
-		}
-		run(variadicArgs...)
-	})
-	return _c
-}
-
-func (_c *MockAppChecker_AnyFlatpakExists_Call) Return(_a0 bool) *MockAppChecker_AnyFlatpakExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MockAppChecker_AnyFlatpakExists_Call) RunAndReturn(run func(...string) bool) *MockAppChecker_AnyFlatpakExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// CommandExists provides a mock function with given fields: cmd
-func (_m *MockAppChecker) CommandExists(cmd string) bool {
-	ret := _m.Called(cmd)
-
-	if len(ret) == 0 {
-		panic("no return value specified for CommandExists")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(cmd)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// MockAppChecker_CommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandExists'
-type MockAppChecker_CommandExists_Call struct {
-	*mock.Call
-}
-
-// CommandExists is a helper method to define mock.On call
-//   - cmd string
-func (_e *MockAppChecker_Expecter) CommandExists(cmd interface{}) *MockAppChecker_CommandExists_Call {
-	return &MockAppChecker_CommandExists_Call{Call: _e.mock.On("CommandExists", cmd)}
-}
-
-func (_c *MockAppChecker_CommandExists_Call) Run(run func(cmd string)) *MockAppChecker_CommandExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *MockAppChecker_CommandExists_Call) Return(_a0 bool) *MockAppChecker_CommandExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MockAppChecker_CommandExists_Call) RunAndReturn(run func(string) bool) *MockAppChecker_CommandExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// FlatpakExists provides a mock function with given fields: name
-func (_m *MockAppChecker) FlatpakExists(name string) bool {
-	ret := _m.Called(name)
-
-	if len(ret) == 0 {
-		panic("no return value specified for FlatpakExists")
-	}
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(string) bool); ok {
-		r0 = rf(name)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// MockAppChecker_FlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlatpakExists'
-type MockAppChecker_FlatpakExists_Call struct {
-	*mock.Call
-}
-
-// FlatpakExists is a helper method to define mock.On call
-//   - name string
-func (_e *MockAppChecker_Expecter) FlatpakExists(name interface{}) *MockAppChecker_FlatpakExists_Call {
-	return &MockAppChecker_FlatpakExists_Call{Call: _e.mock.On("FlatpakExists", name)}
-}
-
-func (_c *MockAppChecker_FlatpakExists_Call) Run(run func(name string)) *MockAppChecker_FlatpakExists_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *MockAppChecker_FlatpakExists_Call) Return(_a0 bool) *MockAppChecker_FlatpakExists_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *MockAppChecker_FlatpakExists_Call) RunAndReturn(run func(string) bool) *MockAppChecker_FlatpakExists_Call {
-	_c.Call.Return(run)
-	return _c
-}
+import (
+	mock "github.com/stretchr/testify/mock"
+)
 
 // NewMockAppChecker creates a new instance of MockAppChecker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
@@ -240,3 +21,244 @@ func NewMockAppChecker(t interface {
 
 	return mock
 }
+
+// MockAppChecker is an autogenerated mock type for the AppChecker type
+type MockAppChecker struct {
+	mock.Mock
+}
+
+type MockAppChecker_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockAppChecker) EXPECT() *MockAppChecker_Expecter {
+	return &MockAppChecker_Expecter{mock: &_m.Mock}
+}
+
+// AnyCommandExists provides a mock function for the type MockAppChecker
+func (_mock *MockAppChecker) AnyCommandExists(cmds ...string) bool {
+	// string
+	_va := make([]any, len(cmds))
+	for _i := range cmds {
+		_va[_i] = cmds[_i]
+	}
+	var _ca []any
+	_ca = append(_ca, _va...)
+	ret := _mock.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AnyCommandExists")
+	}
+
+	var r0 bool
+	if returnFunc, ok := ret.Get(0).(func(...string) bool); ok {
+		r0 = returnFunc(cmds...)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	return r0
+}
+
+// MockAppChecker_AnyCommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyCommandExists'
+type MockAppChecker_AnyCommandExists_Call struct {
+	*mock.Call
+}
+
+// AnyCommandExists is a helper method to define mock.On call
+//   - cmds ...string
+func (_e *MockAppChecker_Expecter) AnyCommandExists(cmds ...any) *MockAppChecker_AnyCommandExists_Call {
+	return &MockAppChecker_AnyCommandExists_Call{Call: _e.mock.On("AnyCommandExists",
+		append([]any{}, cmds...)...)}
+}
+
+func (_c *MockAppChecker_AnyCommandExists_Call) Run(run func(cmds ...string)) *MockAppChecker_AnyCommandExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 []string
+		variadicArgs := make([]string, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		arg0 = variadicArgs
+		run(
+			arg0...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockAppChecker_AnyCommandExists_Call) Return(b bool) *MockAppChecker_AnyCommandExists_Call {
+	_c.Call.Return(b)
+	return _c
+}
+
+func (_c *MockAppChecker_AnyCommandExists_Call) RunAndReturn(run func(cmds ...string) bool) *MockAppChecker_AnyCommandExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// AnyFlatpakExists provides a mock function for the type MockAppChecker
+func (_mock *MockAppChecker) AnyFlatpakExists(flatpaks ...string) bool {
+	// string
+	_va := make([]any, len(flatpaks))
+	for _i := range flatpaks {
+		_va[_i] = flatpaks[_i]
+	}
+	var _ca []any
+	_ca = append(_ca, _va...)
+	ret := _mock.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for AnyFlatpakExists")
+	}
+
+	var r0 bool
+	if returnFunc, ok := ret.Get(0).(func(...string) bool); ok {
+		r0 = returnFunc(flatpaks...)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	return r0
+}
+
+// MockAppChecker_AnyFlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnyFlatpakExists'
+type MockAppChecker_AnyFlatpakExists_Call struct {
+	*mock.Call
+}
+
+// AnyFlatpakExists is a helper method to define mock.On call
+//   - flatpaks ...string
+func (_e *MockAppChecker_Expecter) AnyFlatpakExists(flatpaks ...any) *MockAppChecker_AnyFlatpakExists_Call {
+	return &MockAppChecker_AnyFlatpakExists_Call{Call: _e.mock.On("AnyFlatpakExists",
+		append([]any{}, flatpaks...)...)}
+}
+
+func (_c *MockAppChecker_AnyFlatpakExists_Call) Run(run func(flatpaks ...string)) *MockAppChecker_AnyFlatpakExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 []string
+		variadicArgs := make([]string, len(args)-0)
+		for i, a := range args[0:] {
+			if a != nil {
+				variadicArgs[i] = a.(string)
+			}
+		}
+		arg0 = variadicArgs
+		run(
+			arg0...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockAppChecker_AnyFlatpakExists_Call) Return(b bool) *MockAppChecker_AnyFlatpakExists_Call {
+	_c.Call.Return(b)
+	return _c
+}
+
+func (_c *MockAppChecker_AnyFlatpakExists_Call) RunAndReturn(run func(flatpaks ...string) bool) *MockAppChecker_AnyFlatpakExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// CommandExists provides a mock function for the type MockAppChecker
+func (_mock *MockAppChecker) CommandExists(cmd string) bool {
+	ret := _mock.Called(cmd)
+
+	if len(ret) == 0 {
+		panic("no return value specified for CommandExists")
+	}
+
+	var r0 bool
+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = returnFunc(cmd)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	return r0
+}
+
+// MockAppChecker_CommandExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandExists'
+type MockAppChecker_CommandExists_Call struct {
+	*mock.Call
+}
+
+// CommandExists is a helper method to define mock.On call
+//   - cmd string
+func (_e *MockAppChecker_Expecter) CommandExists(cmd any) *MockAppChecker_CommandExists_Call {
+	return &MockAppChecker_CommandExists_Call{Call: _e.mock.On("CommandExists", cmd)}
+}
+
+func (_c *MockAppChecker_CommandExists_Call) Run(run func(cmd string)) *MockAppChecker_CommandExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockAppChecker_CommandExists_Call) Return(b bool) *MockAppChecker_CommandExists_Call {
+	_c.Call.Return(b)
+	return _c
+}
+
+func (_c *MockAppChecker_CommandExists_Call) RunAndReturn(run func(cmd string) bool) *MockAppChecker_CommandExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// FlatpakExists provides a mock function for the type MockAppChecker
+func (_mock *MockAppChecker) FlatpakExists(name string) bool {
+	ret := _mock.Called(name)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FlatpakExists")
+	}
+
+	var r0 bool
+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = returnFunc(name)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	return r0
+}
+
+// MockAppChecker_FlatpakExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlatpakExists'
+type MockAppChecker_FlatpakExists_Call struct {
+	*mock.Call
+}
+
+// FlatpakExists is a helper method to define mock.On call
+//   - name string
+func (_e *MockAppChecker_Expecter) FlatpakExists(name any) *MockAppChecker_FlatpakExists_Call {
+	return &MockAppChecker_FlatpakExists_Call{Call: _e.mock.On("FlatpakExists", name)}
+}
+
+func (_c *MockAppChecker_FlatpakExists_Call) Run(run func(name string)) *MockAppChecker_FlatpakExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockAppChecker_FlatpakExists_Call) Return(b bool) *MockAppChecker_FlatpakExists_Call {
+	_c.Call.Return(b)
+	return _c
+}
+
+func (_c *MockAppChecker_FlatpakExists_Call) RunAndReturn(run func(name string) bool) *MockAppChecker_FlatpakExists_Call {
+	_c.Call.Return(run)
+	return _c
+}

core/internal/mocks/version/mock_VersionFetcher.go

@@ -1,133 +1,12 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks_version
 
-import mock "github.com/stretchr/testify/mock"
-
-// MockVersionFetcher is an autogenerated mock type for the VersionFetcher type
-type MockVersionFetcher struct {
-	mock.Mock
-}
-
-type MockVersionFetcher_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *MockVersionFetcher) EXPECT() *MockVersionFetcher_Expecter {
-	return &MockVersionFetcher_Expecter{mock: &_m.Mock}
-}
-
-// GetCurrentVersion provides a mock function with given fields: dmsPath
-func (_m *MockVersionFetcher) GetCurrentVersion(dmsPath string) (string, error) {
-	ret := _m.Called(dmsPath)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetCurrentVersion")
-	}
-
-	var r0 string
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (string, error)); ok {
-		return rf(dmsPath)
-	}
-	if rf, ok := ret.Get(0).(func(string) string); ok {
-		r0 = rf(dmsPath)
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(dmsPath)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// MockVersionFetcher_GetCurrentVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentVersion'
-type MockVersionFetcher_GetCurrentVersion_Call struct {
-	*mock.Call
-}
-
-// GetCurrentVersion is a helper method to define mock.On call
-//   - dmsPath string
-func (_e *MockVersionFetcher_Expecter) GetCurrentVersion(dmsPath interface{}) *MockVersionFetcher_GetCurrentVersion_Call {
-	return &MockVersionFetcher_GetCurrentVersion_Call{Call: _e.mock.On("GetCurrentVersion", dmsPath)}
-}
-
-func (_c *MockVersionFetcher_GetCurrentVersion_Call) Run(run func(dmsPath string)) *MockVersionFetcher_GetCurrentVersion_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *MockVersionFetcher_GetCurrentVersion_Call) Return(_a0 string, _a1 error) *MockVersionFetcher_GetCurrentVersion_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *MockVersionFetcher_GetCurrentVersion_Call) RunAndReturn(run func(string) (string, error)) *MockVersionFetcher_GetCurrentVersion_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetLatestVersion provides a mock function with given fields: dmsPath
-func (_m *MockVersionFetcher) GetLatestVersion(dmsPath string) (string, error) {
-	ret := _m.Called(dmsPath)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetLatestVersion")
-	}
-
-	var r0 string
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) (string, error)); ok {
-		return rf(dmsPath)
-	}
-	if rf, ok := ret.Get(0).(func(string) string); ok {
-		r0 = rf(dmsPath)
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(dmsPath)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// MockVersionFetcher_GetLatestVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestVersion'
-type MockVersionFetcher_GetLatestVersion_Call struct {
-	*mock.Call
-}
-
-// GetLatestVersion is a helper method to define mock.On call
-//   - dmsPath string
-func (_e *MockVersionFetcher_Expecter) GetLatestVersion(dmsPath interface{}) *MockVersionFetcher_GetLatestVersion_Call {
-	return &MockVersionFetcher_GetLatestVersion_Call{Call: _e.mock.On("GetLatestVersion", dmsPath)}
-}
-
-func (_c *MockVersionFetcher_GetLatestVersion_Call) Run(run func(dmsPath string)) *MockVersionFetcher_GetLatestVersion_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string))
-	})
-	return _c
-}
-
-func (_c *MockVersionFetcher_GetLatestVersion_Call) Return(_a0 string, _a1 error) *MockVersionFetcher_GetLatestVersion_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *MockVersionFetcher_GetLatestVersion_Call) RunAndReturn(run func(string) (string, error)) *MockVersionFetcher_GetLatestVersion_Call {
-	_c.Call.Return(run)
-	return _c
-}
+import (
+	mock "github.com/stretchr/testify/mock"
+)
 
 // NewMockVersionFetcher creates a new instance of MockVersionFetcher. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
@@ -142,3 +21,136 @@ func NewMockVersionFetcher(t interface {
 
 	return mock
 }
+
+// MockVersionFetcher is an autogenerated mock type for the VersionFetcher type
+type MockVersionFetcher struct {
+	mock.Mock
+}
+
+type MockVersionFetcher_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockVersionFetcher) EXPECT() *MockVersionFetcher_Expecter {
+	return &MockVersionFetcher_Expecter{mock: &_m.Mock}
+}
+
+// GetCurrentVersion provides a mock function for the type MockVersionFetcher
+func (_mock *MockVersionFetcher) GetCurrentVersion(dmsPath string) (string, error) {
+	ret := _mock.Called(dmsPath)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetCurrentVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok {
+		return returnFunc(dmsPath)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) string); ok {
+		r0 = returnFunc(dmsPath)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(dmsPath)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockVersionFetcher_GetCurrentVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentVersion'
+type MockVersionFetcher_GetCurrentVersion_Call struct {
+	*mock.Call
+}
+
+// GetCurrentVersion is a helper method to define mock.On call
+//   - dmsPath string
+func (_e *MockVersionFetcher_Expecter) GetCurrentVersion(dmsPath any) *MockVersionFetcher_GetCurrentVersion_Call {
+	return &MockVersionFetcher_GetCurrentVersion_Call{Call: _e.mock.On("GetCurrentVersion", dmsPath)}
+}
+
+func (_c *MockVersionFetcher_GetCurrentVersion_Call) Run(run func(dmsPath string)) *MockVersionFetcher_GetCurrentVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockVersionFetcher_GetCurrentVersion_Call) Return(s string, err error) *MockVersionFetcher_GetCurrentVersion_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *MockVersionFetcher_GetCurrentVersion_Call) RunAndReturn(run func(dmsPath string) (string, error)) *MockVersionFetcher_GetCurrentVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetLatestVersion provides a mock function for the type MockVersionFetcher
+func (_mock *MockVersionFetcher) GetLatestVersion(dmsPath string) (string, error) {
+	ret := _mock.Called(dmsPath)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetLatestVersion")
+	}
+
+	var r0 string
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok {
+		return returnFunc(dmsPath)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) string); ok {
+		r0 = returnFunc(dmsPath)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(dmsPath)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockVersionFetcher_GetLatestVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestVersion'
+type MockVersionFetcher_GetLatestVersion_Call struct {
+	*mock.Call
+}
+
+// GetLatestVersion is a helper method to define mock.On call
+//   - dmsPath string
+func (_e *MockVersionFetcher_Expecter) GetLatestVersion(dmsPath any) *MockVersionFetcher_GetLatestVersion_Call {
+	return &MockVersionFetcher_GetLatestVersion_Call{Call: _e.mock.On("GetLatestVersion", dmsPath)}
+}
+
+func (_c *MockVersionFetcher_GetLatestVersion_Call) Run(run func(dmsPath string)) *MockVersionFetcher_GetLatestVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 string
+		if args[0] != nil {
+			arg0 = args[0].(string)
+		}
+		run(
+			arg0,
+		)
+	})
+	return _c
+}
+
+func (_c *MockVersionFetcher_GetLatestVersion_Call) Return(s string, err error) *MockVersionFetcher_GetLatestVersion_Call {
+	_c.Call.Return(s, err)
+	return _c
+}
+
+func (_c *MockVersionFetcher_GetLatestVersion_Call) RunAndReturn(run func(dmsPath string) (string, error)) *MockVersionFetcher_GetLatestVersion_Call {
+	_c.Call.Return(run)
+	return _c
+}

core/internal/mocks/wlclient/mock_WaylandDisplay.go

@@ -1,12 +1,28 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks_wlclient
 
 import (
-	client "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockWaylandDisplay creates a new instance of MockWaylandDisplay. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockWaylandDisplay(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockWaylandDisplay {
+	mock := &MockWaylandDisplay{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockWaylandDisplay is an autogenerated mock type for the WaylandDisplay type
 type MockWaylandDisplay struct {
 	mock.Mock
@@ -20,23 +36,22 @@ func (_m *MockWaylandDisplay) EXPECT() *MockWaylandDisplay_Expecter {
 	return &MockWaylandDisplay_Expecter{mock: &_m.Mock}
 }
 
-// Context provides a mock function with no fields
-func (_m *MockWaylandDisplay) Context() *client.Context {
-	ret := _m.Called()
+// Context provides a mock function for the type MockWaylandDisplay
+func (_mock *MockWaylandDisplay) Context() *client.Context {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Context")
 	}
 
 	var r0 *client.Context
-	if rf, ok := ret.Get(0).(func() *client.Context); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() *client.Context); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*client.Context)
 		}
 	}
-
 	return r0
 }
 
@@ -57,8 +72,8 @@ func (_c *MockWaylandDisplay_Context_Call) Run(run func()) *MockWaylandDisplay_C
 	return _c
 }
 
-func (_c *MockWaylandDisplay_Context_Call) Return(_a0 *client.Context) *MockWaylandDisplay_Context_Call {
-	_c.Call.Return(_a0)
+func (_c *MockWaylandDisplay_Context_Call) Return(context *client.Context) *MockWaylandDisplay_Context_Call {
+	_c.Call.Return(context)
 	return _c
 }
 
@@ -67,21 +82,20 @@ func (_c *MockWaylandDisplay_Context_Call) RunAndReturn(run func() *client.Conte
 	return _c
 }
 
-// Destroy provides a mock function with no fields
-func (_m *MockWaylandDisplay) Destroy() error {
-	ret := _m.Called()
+// Destroy provides a mock function for the type MockWaylandDisplay
+func (_mock *MockWaylandDisplay) Destroy() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Destroy")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -102,8 +116,8 @@ func (_c *MockWaylandDisplay_Destroy_Call) Run(run func()) *MockWaylandDisplay_D
 	return _c
 }
 
-func (_c *MockWaylandDisplay_Destroy_Call) Return(_a0 error) *MockWaylandDisplay_Destroy_Call {
-	_c.Call.Return(_a0)
+func (_c *MockWaylandDisplay_Destroy_Call) Return(err error) *MockWaylandDisplay_Destroy_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -112,9 +126,9 @@ func (_c *MockWaylandDisplay_Destroy_Call) RunAndReturn(run func() error) *MockW
 	return _c
 }
 
-// GetRegistry provides a mock function with no fields
-func (_m *MockWaylandDisplay) GetRegistry() (*client.Registry, error) {
-	ret := _m.Called()
+// GetRegistry provides a mock function for the type MockWaylandDisplay
+func (_mock *MockWaylandDisplay) GetRegistry() (*client.Registry, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetRegistry")
@@ -122,23 +136,21 @@ func (_m *MockWaylandDisplay) GetRegistry() (*client.Registry, error) {
 
 	var r0 *client.Registry
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (*client.Registry, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (*client.Registry, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() *client.Registry); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() *client.Registry); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*client.Registry)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -159,8 +171,8 @@ func (_c *MockWaylandDisplay_GetRegistry_Call) Run(run func()) *MockWaylandDispl
 	return _c
 }
 
-func (_c *MockWaylandDisplay_GetRegistry_Call) Return(_a0 *client.Registry, _a1 error) *MockWaylandDisplay_GetRegistry_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *MockWaylandDisplay_GetRegistry_Call) Return(registry *client.Registry, err error) *MockWaylandDisplay_GetRegistry_Call {
+	_c.Call.Return(registry, err)
 	return _c
 }
 
@@ -169,21 +181,20 @@ func (_c *MockWaylandDisplay_GetRegistry_Call) RunAndReturn(run func() (*client.
 	return _c
 }
 
-// Roundtrip provides a mock function with no fields
-func (_m *MockWaylandDisplay) Roundtrip() error {
-	ret := _m.Called()
+// Roundtrip provides a mock function for the type MockWaylandDisplay
+func (_mock *MockWaylandDisplay) Roundtrip() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Roundtrip")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -204,8 +215,8 @@ func (_c *MockWaylandDisplay_Roundtrip_Call) Run(run func()) *MockWaylandDisplay
 	return _c
 }
 
-func (_c *MockWaylandDisplay_Roundtrip_Call) Return(_a0 error) *MockWaylandDisplay_Roundtrip_Call {
-	_c.Call.Return(_a0)
+func (_c *MockWaylandDisplay_Roundtrip_Call) Return(err error) *MockWaylandDisplay_Roundtrip_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -213,17 +224,3 @@ func (_c *MockWaylandDisplay_Roundtrip_Call) RunAndReturn(run func() error) *Moc
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewMockWaylandDisplay creates a new instance of MockWaylandDisplay. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockWaylandDisplay(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockWaylandDisplay {
-	mock := &MockWaylandDisplay{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/mocks/wlcontext/mock_WaylandContext.go

@@ -1,12 +1,28 @@
-// Code generated by mockery v2.53.5. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks_wlcontext
 
 import (
-	client "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
+	"github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewMockWaylandContext creates a new instance of MockWaylandContext. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockWaylandContext(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockWaylandContext {
+	mock := &MockWaylandContext{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // MockWaylandContext is an autogenerated mock type for the WaylandContext type
 type MockWaylandContext struct {
 	mock.Mock
@@ -20,9 +36,10 @@ func (_m *MockWaylandContext) EXPECT() *MockWaylandContext_Expecter {
 	return &MockWaylandContext_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with no fields
-func (_m *MockWaylandContext) Close() {
-	_m.Called()
+// Close provides a mock function for the type MockWaylandContext
+func (_mock *MockWaylandContext) Close() {
+	_mock.Called()
+	return
 }
 
 // MockWaylandContext_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
@@ -52,23 +69,22 @@ func (_c *MockWaylandContext_Close_Call) RunAndReturn(run func()) *MockWaylandCo
 	return _c
 }
 
-// Display provides a mock function with no fields
-func (_m *MockWaylandContext) Display() *client.Display {
-	ret := _m.Called()
+// Display provides a mock function for the type MockWaylandContext
+func (_mock *MockWaylandContext) Display() *client.Display {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Display")
 	}
 
 	var r0 *client.Display
-	if rf, ok := ret.Get(0).(func() *client.Display); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() *client.Display); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*client.Display)
 		}
 	}
-
 	return r0
 }
 
@@ -89,8 +105,8 @@ func (_c *MockWaylandContext_Display_Call) Run(run func()) *MockWaylandContext_D
 	return _c
 }
 
-func (_c *MockWaylandContext_Display_Call) Return(_a0 *client.Display) *MockWaylandContext_Display_Call {
-	_c.Call.Return(_a0)
+func (_c *MockWaylandContext_Display_Call) Return(display *client.Display) *MockWaylandContext_Display_Call {
+	_c.Call.Return(display)
 	return _c
 }
 
@@ -99,23 +115,22 @@ func (_c *MockWaylandContext_Display_Call) RunAndReturn(run func() *client.Displ
 	return _c
 }
 
-// FatalError provides a mock function with no fields
-func (_m *MockWaylandContext) FatalError() <-chan error {
-	ret := _m.Called()
+// FatalError provides a mock function for the type MockWaylandContext
+func (_mock *MockWaylandContext) FatalError() <-chan error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for FatalError")
 	}
 
 	var r0 <-chan error
-	if rf, ok := ret.Get(0).(func() <-chan error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() <-chan error); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(<-chan error)
 		}
 	}
-
 	return r0
 }
 
@@ -136,8 +151,8 @@ func (_c *MockWaylandContext_FatalError_Call) Run(run func()) *MockWaylandContex
 	return _c
 }
 
-func (_c *MockWaylandContext_FatalError_Call) Return(_a0 <-chan error) *MockWaylandContext_FatalError_Call {
-	_c.Call.Return(_a0)
+func (_c *MockWaylandContext_FatalError_Call) Return(errCh <-chan error) *MockWaylandContext_FatalError_Call {
+	_c.Call.Return(errCh)
 	return _c
 }
 
@@ -146,9 +161,10 @@ func (_c *MockWaylandContext_FatalError_Call) RunAndReturn(run func() <-chan err
 	return _c
 }
 
-// Post provides a mock function with given fields: fn
-func (_m *MockWaylandContext) Post(fn func()) {
-	_m.Called(fn)
+// Post provides a mock function for the type MockWaylandContext
+func (_mock *MockWaylandContext) Post(fn func()) {
+	_mock.Called(fn)
+	return
 }
 
 // MockWaylandContext_Post_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Post'
@@ -158,13 +174,19 @@ type MockWaylandContext_Post_Call struct {
 
 // Post is a helper method to define mock.On call
 //   - fn func()
-func (_e *MockWaylandContext_Expecter) Post(fn interface{}) *MockWaylandContext_Post_Call {
+func (_e *MockWaylandContext_Expecter) Post(fn any) *MockWaylandContext_Post_Call {
 	return &MockWaylandContext_Post_Call{Call: _e.mock.On("Post", fn)}
 }
 
 func (_c *MockWaylandContext_Post_Call) Run(run func(fn func())) *MockWaylandContext_Post_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(func()))
+		var arg0 func()
+		if args[0] != nil {
+			arg0 = args[0].(func())
+		}
+		run(
+			arg0,
+		)
 	})
 	return _c
 }
@@ -174,14 +196,15 @@ func (_c *MockWaylandContext_Post_Call) Return() *MockWaylandContext_Post_Call {
 	return _c
 }
 
-func (_c *MockWaylandContext_Post_Call) RunAndReturn(run func(func())) *MockWaylandContext_Post_Call {
+func (_c *MockWaylandContext_Post_Call) RunAndReturn(run func(fn func())) *MockWaylandContext_Post_Call {
 	_c.Run(run)
 	return _c
 }
 
-// Start provides a mock function with no fields
-func (_m *MockWaylandContext) Start() {
-	_m.Called()
+// Start provides a mock function for the type MockWaylandContext
+func (_mock *MockWaylandContext) Start() {
+	_mock.Called()
+	return
 }
 
 // MockWaylandContext_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
@@ -210,17 +233,3 @@ func (_c *MockWaylandContext_Start_Call) RunAndReturn(run func()) *MockWaylandCo
 	_c.Run(run)
 	return _c
 }
-
-// NewMockWaylandContext creates a new instance of MockWaylandContext. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewMockWaylandContext(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *MockWaylandContext {
-	mock := &MockWaylandContext{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

core/internal/pam/pam.go

@@ -499,6 +499,9 @@ func buildManagedLockscreenU2FPamContent() string {
 	b.WriteString("#%PAM-1.0\n")
 	b.WriteString(LockscreenU2FPamManagedBlockStart + "\n")
 	b.WriteString("auth    required    pam_u2f.so  cue nouserok timeout=10\n")
+	b.WriteString("account required    pam_permit.so\n")
+	b.WriteString("password required   pam_deny.so\n")
+	b.WriteString("session required    pam_permit.so\n")
 	b.WriteString(LockscreenU2FPamManagedBlockEnd + "\n")
 	return b.String()
 }

core/internal/plugins/feedback.go

@@ -0,0 +1,49 @@
+package plugins
+
+import (
+	"encoding/json"
+	"net/http"
+	"time"
+)
+
+const feedbackURL = "https://api.danklinux.com/plugins"
+
+type Feedback struct {
+	Upvotes  int
+	Status   []string
+	IssueURL string
+}
+
+// FetchFeedback retrieves community upvotes and moderator status from the directory API.
+// Best-effort: any failure returns a nil map.
+func FetchFeedback() map[string]Feedback {
+	client := &http.Client{Timeout: 5 * time.Second}
+
+	resp, err := client.Get(feedbackURL)
+	if err != nil {
+		return nil
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil
+	}
+
+	var payload struct {
+		Plugins []struct {
+			ID       string   `json:"id"`
+			Upvotes  int      `json:"upvotes"`
+			Status   []string `json:"status"`
+			IssueURL string   `json:"issueUrl"`
+		} `json:"plugins"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return nil
+	}
+
+	feedback := make(map[string]Feedback, len(payload.Plugins))
+	for _, p := range payload.Plugins {
+		feedback[p.ID] = Feedback{Upvotes: p.Upvotes, Status: p.Status, IssueURL: p.IssueURL}
+	}
+	return feedback
+}

core/internal/proto/dwl_ipc/dwl_ipc.go

@@ -1,791 +0,0 @@
-// Generated by go-wayland-scanner
-// https://github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/cmd/go-wayland-scanner
-// XML file : internal/proto/xml/dwl-ipc-unstable-v2.xml
-//
-// dwl_ipc_unstable_v2 Protocol Copyright:
-
-package dwl_ipc
-
-import "github.com/AvengeMedia/DankMaterialShell/core/pkg/go-wayland/wayland/client"
-
-// ZdwlIpcManagerV2InterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const ZdwlIpcManagerV2InterfaceName = "zdwl_ipc_manager_v2"
-
-// ZdwlIpcManagerV2 : manage dwl state
-//
-// This interface is exposed as a global in wl_registry.
-//
-// Clients can use this interface to get a dwl_ipc_output.
-// After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events.
-// The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client.
-type ZdwlIpcManagerV2 struct {
-	client.BaseProxy
-	tagsHandler   ZdwlIpcManagerV2TagsHandlerFunc
-	layoutHandler ZdwlIpcManagerV2LayoutHandlerFunc
-}
-
-// NewZdwlIpcManagerV2 : manage dwl state
-//
-// This interface is exposed as a global in wl_registry.
-//
-// Clients can use this interface to get a dwl_ipc_output.
-// After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events.
-// The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client.
-func NewZdwlIpcManagerV2(ctx *client.Context) *ZdwlIpcManagerV2 {
-	zdwlIpcManagerV2 := &ZdwlIpcManagerV2{}
-	ctx.Register(zdwlIpcManagerV2)
-	return zdwlIpcManagerV2
-}
-
-// Release : release dwl_ipc_manager
-//
-// Indicates that the client will not the dwl_ipc_manager object anymore.
-// Objects created through this instance are not affected.
-func (i *ZdwlIpcManagerV2) Release() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	client.PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// GetOutput : get a dwl_ipc_outout for a wl_output
-//
-// Get a dwl_ipc_outout for the specified wl_output.
-func (i *ZdwlIpcManagerV2) GetOutput(output *client.Output) (*ZdwlIpcOutputV2, error) {
-	id := NewZdwlIpcOutputV2(i.Context())
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	client.PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], id.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], output.ID())
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return id, err
-}
-
-// ZdwlIpcManagerV2TagsEvent : Announces tag amount
-//
-// This event is sent after binding.
-// A roundtrip after binding guarantees the client recieved all tags.
-type ZdwlIpcManagerV2TagsEvent struct {
-	Amount uint32
-}
-type ZdwlIpcManagerV2TagsHandlerFunc func(ZdwlIpcManagerV2TagsEvent)
-
-// SetTagsHandler : sets handler for ZdwlIpcManagerV2TagsEvent
-func (i *ZdwlIpcManagerV2) SetTagsHandler(f ZdwlIpcManagerV2TagsHandlerFunc) {
-	i.tagsHandler = f
-}
-
-// ZdwlIpcManagerV2LayoutEvent : Announces a layout
-//
-// This event is sent after binding.
-// A roundtrip after binding guarantees the client recieved all layouts.
-type ZdwlIpcManagerV2LayoutEvent struct {
-	Name string
-}
-type ZdwlIpcManagerV2LayoutHandlerFunc func(ZdwlIpcManagerV2LayoutEvent)
-
-// SetLayoutHandler : sets handler for ZdwlIpcManagerV2LayoutEvent
-func (i *ZdwlIpcManagerV2) SetLayoutHandler(f ZdwlIpcManagerV2LayoutHandlerFunc) {
-	i.layoutHandler = f
-}
-
-func (i *ZdwlIpcManagerV2) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.tagsHandler == nil {
-			return
-		}
-		var e ZdwlIpcManagerV2TagsEvent
-		l := 0
-		e.Amount = client.Uint32(data[l : l+4])
-		l += 4
-
-		i.tagsHandler(e)
-	case 1:
-		if i.layoutHandler == nil {
-			return
-		}
-		var e ZdwlIpcManagerV2LayoutEvent
-		l := 0
-		nameLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
-		l += 4
-		e.Name = client.String(data[l : l+nameLen])
-		l += nameLen
-
-		i.layoutHandler(e)
-	}
-}
-
-// ZdwlIpcOutputV2InterfaceName is the name of the interface as it appears in the [client.Registry].
-// It can be used to match the [client.RegistryGlobalEvent.Interface] in the
-// [Registry.SetGlobalHandler] and can be used in [Registry.Bind] if this applies.
-const ZdwlIpcOutputV2InterfaceName = "zdwl_ipc_output_v2"
-
-// ZdwlIpcOutputV2 : control dwl output
-//
-// Observe and control a dwl output.
-//
-// Events are double-buffered:
-// Clients should cache events and redraw when a dwl_ipc_output.frame event is sent.
-//
-// Request are not double-buffered:
-// The compositor will update immediately upon request.
-type ZdwlIpcOutputV2 struct {
-	client.BaseProxy
-	toggleVisibilityHandler ZdwlIpcOutputV2ToggleVisibilityHandlerFunc
-	activeHandler           ZdwlIpcOutputV2ActiveHandlerFunc
-	tagHandler              ZdwlIpcOutputV2TagHandlerFunc
-	layoutHandler           ZdwlIpcOutputV2LayoutHandlerFunc
-	titleHandler            ZdwlIpcOutputV2TitleHandlerFunc
-	appidHandler            ZdwlIpcOutputV2AppidHandlerFunc
-	layoutSymbolHandler     ZdwlIpcOutputV2LayoutSymbolHandlerFunc
-	frameHandler            ZdwlIpcOutputV2FrameHandlerFunc
-	fullscreenHandler       ZdwlIpcOutputV2FullscreenHandlerFunc
-	floatingHandler         ZdwlIpcOutputV2FloatingHandlerFunc
-	xHandler                ZdwlIpcOutputV2XHandlerFunc
-	yHandler                ZdwlIpcOutputV2YHandlerFunc
-	widthHandler            ZdwlIpcOutputV2WidthHandlerFunc
-	heightHandler           ZdwlIpcOutputV2HeightHandlerFunc
-	lastLayerHandler        ZdwlIpcOutputV2LastLayerHandlerFunc
-	kbLayoutHandler         ZdwlIpcOutputV2KbLayoutHandlerFunc
-	keymodeHandler          ZdwlIpcOutputV2KeymodeHandlerFunc
-	scalefactorHandler      ZdwlIpcOutputV2ScalefactorHandlerFunc
-}
-
-// NewZdwlIpcOutputV2 : control dwl output
-//
-// Observe and control a dwl output.
-//
-// Events are double-buffered:
-// Clients should cache events and redraw when a dwl_ipc_output.frame event is sent.
-//
-// Request are not double-buffered:
-// The compositor will update immediately upon request.
-func NewZdwlIpcOutputV2(ctx *client.Context) *ZdwlIpcOutputV2 {
-	zdwlIpcOutputV2 := &ZdwlIpcOutputV2{}
-	ctx.Register(zdwlIpcOutputV2)
-	return zdwlIpcOutputV2
-}
-
-// Release : release dwl_ipc_outout
-//
-// Indicates to that the client no longer needs this dwl_ipc_output.
-func (i *ZdwlIpcOutputV2) Release() error {
-	defer i.MarkZombie()
-	const opcode = 0
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	client.PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetTags : Set the active tags of this output
-//
-//	tagmask: bitmask of the tags that should be set.
-//	toggleTagset: toggle the selected tagset, zero for invalid, nonzero for valid.
-func (i *ZdwlIpcOutputV2) SetTags(tagmask, toggleTagset uint32) error {
-	const opcode = 1
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	client.PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(tagmask))
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(toggleTagset))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetClientTags : Set the tags of the focused client.
-//
-// The tags are updated as follows:
-// new_tags = (current_tags AND and_tags) XOR xor_tags
-func (i *ZdwlIpcOutputV2) SetClientTags(andTags, xorTags uint32) error {
-	const opcode = 2
-	const _reqBufLen = 8 + 4 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	client.PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(andTags))
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(xorTags))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SetLayout : Set the layout of this output
-//
-//	index: index of a layout recieved by dwl_ipc_manager.layout
-func (i *ZdwlIpcOutputV2) SetLayout(index uint32) error {
-	const opcode = 3
-	const _reqBufLen = 8 + 4
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	client.PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(index))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// Quit : Quit mango
-// This request allows clients to instruct the compositor to quit mango.
-func (i *ZdwlIpcOutputV2) Quit() error {
-	const opcode = 4
-	const _reqBufLen = 8
-	var _reqBuf [_reqBufLen]byte
-	l := 0
-	client.PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	err := i.Context().WriteMsg(_reqBuf[:], nil)
-	return err
-}
-
-// SendDispatch : Set the active tags of this output
-//
-//	dispatch: dispatch name.
-//	arg1: arg1.
-//	arg2: arg2.
-//	arg3: arg3.
-//	arg4: arg4.
-//	arg5: arg5.
-func (i *ZdwlIpcOutputV2) SendDispatch(dispatch, arg1, arg2, arg3, arg4, arg5 string) error {
-	const opcode = 5
-	dispatchLen := client.PaddedLen(len(dispatch) + 1)
-	arg1Len := client.PaddedLen(len(arg1) + 1)
-	arg2Len := client.PaddedLen(len(arg2) + 1)
-	arg3Len := client.PaddedLen(len(arg3) + 1)
-	arg4Len := client.PaddedLen(len(arg4) + 1)
-	arg5Len := client.PaddedLen(len(arg5) + 1)
-	_reqBufLen := 8 + (4 + dispatchLen) + (4 + arg1Len) + (4 + arg2Len) + (4 + arg3Len) + (4 + arg4Len) + (4 + arg5Len)
-	_reqBuf := make([]byte, _reqBufLen)
-	l := 0
-	client.PutUint32(_reqBuf[l:4], i.ID())
-	l += 4
-	client.PutUint32(_reqBuf[l:l+4], uint32(_reqBufLen<<16|opcode&0x0000ffff))
-	l += 4
-	client.PutString(_reqBuf[l:l+(4+dispatchLen)], dispatch)
-	l += (4 + dispatchLen)
-	client.PutString(_reqBuf[l:l+(4+arg1Len)], arg1)
-	l += (4 + arg1Len)
-	client.PutString(_reqBuf[l:l+(4+arg2Len)], arg2)
-	l += (4 + arg2Len)
-	client.PutString(_reqBuf[l:l+(4+arg3Len)], arg3)
-	l += (4 + arg3Len)
-	client.PutString(_reqBuf[l:l+(4+arg4Len)], arg4)
-	l += (4 + arg4Len)
-	client.PutString(_reqBuf[l:l+(4+arg5Len)], arg5)
-	l += (4 + arg5Len)
-	err := i.Context().WriteMsg(_reqBuf, nil)
-	return err
-}
-
-type ZdwlIpcOutputV2TagState uint32
-
-// ZdwlIpcOutputV2TagState :
-const (
-	// ZdwlIpcOutputV2TagStateNone : no state
-	ZdwlIpcOutputV2TagStateNone ZdwlIpcOutputV2TagState = 0
-	// ZdwlIpcOutputV2TagStateActive : tag is active
-	ZdwlIpcOutputV2TagStateActive ZdwlIpcOutputV2TagState = 1
-	// ZdwlIpcOutputV2TagStateUrgent : tag has at least one urgent client
-	ZdwlIpcOutputV2TagStateUrgent ZdwlIpcOutputV2TagState = 2
-)
-
-func (e ZdwlIpcOutputV2TagState) Name() string {
-	switch e {
-	case ZdwlIpcOutputV2TagStateNone:
-		return "none"
-	case ZdwlIpcOutputV2TagStateActive:
-		return "active"
-	case ZdwlIpcOutputV2TagStateUrgent:
-		return "urgent"
-	default:
-		return ""
-	}
-}
-
-func (e ZdwlIpcOutputV2TagState) Value() string {
-	switch e {
-	case ZdwlIpcOutputV2TagStateNone:
-		return "0"
-	case ZdwlIpcOutputV2TagStateActive:
-		return "1"
-	case ZdwlIpcOutputV2TagStateUrgent:
-		return "2"
-	default:
-		return ""
-	}
-}
-
-func (e ZdwlIpcOutputV2TagState) String() string {
-	return e.Name() + "=" + e.Value()
-}
-
-// ZdwlIpcOutputV2ToggleVisibilityEvent : Toggle client visibilty
-//
-// Indicates the client should hide or show themselves.
-// If the client is visible then hide, if hidden then show.
-type ZdwlIpcOutputV2ToggleVisibilityEvent struct{}
-type ZdwlIpcOutputV2ToggleVisibilityHandlerFunc func(ZdwlIpcOutputV2ToggleVisibilityEvent)
-
-// SetToggleVisibilityHandler : sets handler for ZdwlIpcOutputV2ToggleVisibilityEvent
-func (i *ZdwlIpcOutputV2) SetToggleVisibilityHandler(f ZdwlIpcOutputV2ToggleVisibilityHandlerFunc) {
-	i.toggleVisibilityHandler = f
-}
-
-// ZdwlIpcOutputV2ActiveEvent : Update the selected output.
-//
-// Indicates if the output is active. Zero is invalid, nonzero is valid.
-type ZdwlIpcOutputV2ActiveEvent struct {
-	Active uint32
-}
-type ZdwlIpcOutputV2ActiveHandlerFunc func(ZdwlIpcOutputV2ActiveEvent)
-
-// SetActiveHandler : sets handler for ZdwlIpcOutputV2ActiveEvent
-func (i *ZdwlIpcOutputV2) SetActiveHandler(f ZdwlIpcOutputV2ActiveHandlerFunc) {
-	i.activeHandler = f
-}
-
-// ZdwlIpcOutputV2TagEvent : Update the state of a tag.
-//
-// Indicates that a tag has been updated.
-type ZdwlIpcOutputV2TagEvent struct {
-	Tag     uint32
-	State   uint32
-	Clients uint32
-	Focused uint32
-}
-type ZdwlIpcOutputV2TagHandlerFunc func(ZdwlIpcOutputV2TagEvent)
-
-// SetTagHandler : sets handler for ZdwlIpcOutputV2TagEvent
-func (i *ZdwlIpcOutputV2) SetTagHandler(f ZdwlIpcOutputV2TagHandlerFunc) {
-	i.tagHandler = f
-}
-
-// ZdwlIpcOutputV2LayoutEvent : Update the layout.
-//
-// Indicates a new layout is selected.
-type ZdwlIpcOutputV2LayoutEvent struct {
-	Layout uint32
-}
-type ZdwlIpcOutputV2LayoutHandlerFunc func(ZdwlIpcOutputV2LayoutEvent)
-
-// SetLayoutHandler : sets handler for ZdwlIpcOutputV2LayoutEvent
-func (i *ZdwlIpcOutputV2) SetLayoutHandler(f ZdwlIpcOutputV2LayoutHandlerFunc) {
-	i.layoutHandler = f
-}
-
-// ZdwlIpcOutputV2TitleEvent : Update the title.
-//
-// Indicates the title has changed.
-type ZdwlIpcOutputV2TitleEvent struct {
-	Title string
-}
-type ZdwlIpcOutputV2TitleHandlerFunc func(ZdwlIpcOutputV2TitleEvent)
-
-// SetTitleHandler : sets handler for ZdwlIpcOutputV2TitleEvent
-func (i *ZdwlIpcOutputV2) SetTitleHandler(f ZdwlIpcOutputV2TitleHandlerFunc) {
-	i.titleHandler = f
-}
-
-// ZdwlIpcOutputV2AppidEvent : Update the appid.
-//
-// Indicates the appid has changed.
-type ZdwlIpcOutputV2AppidEvent struct {
-	Appid string
-}
-type ZdwlIpcOutputV2AppidHandlerFunc func(ZdwlIpcOutputV2AppidEvent)
-
-// SetAppidHandler : sets handler for ZdwlIpcOutputV2AppidEvent
-func (i *ZdwlIpcOutputV2) SetAppidHandler(f ZdwlIpcOutputV2AppidHandlerFunc) {
-	i.appidHandler = f
-}
-
-// ZdwlIpcOutputV2LayoutSymbolEvent : Update the current layout symbol
-//
-// Indicates the layout has changed. Since layout symbols are dynamic.
-// As opposed to the zdwl_ipc_manager.layout event, this should take precendence when displaying.
-// You can ignore the zdwl_ipc_output.layout event.
-type ZdwlIpcOutputV2LayoutSymbolEvent struct {
-	Layout string
-}
-type ZdwlIpcOutputV2LayoutSymbolHandlerFunc func(ZdwlIpcOutputV2LayoutSymbolEvent)
-
-// SetLayoutSymbolHandler : sets handler for ZdwlIpcOutputV2LayoutSymbolEvent
-func (i *ZdwlIpcOutputV2) SetLayoutSymbolHandler(f ZdwlIpcOutputV2LayoutSymbolHandlerFunc) {
-	i.layoutSymbolHandler = f
-}
-
-// ZdwlIpcOutputV2FrameEvent : The update sequence is done.
-//
-// Indicates that a sequence of status updates have finished and the client should redraw.
-type ZdwlIpcOutputV2FrameEvent struct{}
-type ZdwlIpcOutputV2FrameHandlerFunc func(ZdwlIpcOutputV2FrameEvent)
-
-// SetFrameHandler : sets handler for ZdwlIpcOutputV2FrameEvent
-func (i *ZdwlIpcOutputV2) SetFrameHandler(f ZdwlIpcOutputV2FrameHandlerFunc) {
-	i.frameHandler = f
-}
-
-// ZdwlIpcOutputV2FullscreenEvent : Update fullscreen status
-//
-// Indicates if the selected client on this output is fullscreen.
-type ZdwlIpcOutputV2FullscreenEvent struct {
-	IsFullscreen uint32
-}
-type ZdwlIpcOutputV2FullscreenHandlerFunc func(ZdwlIpcOutputV2FullscreenEvent)
-
-// SetFullscreenHandler : sets handler for ZdwlIpcOutputV2FullscreenEvent
-func (i *ZdwlIpcOutputV2) SetFullscreenHandler(f ZdwlIpcOutputV2FullscreenHandlerFunc) {
-	i.fullscreenHandler = f
-}
-
-// ZdwlIpcOutputV2FloatingEvent : Update the floating status
-//
-// Indicates if the selected client on this output is floating.
-type ZdwlIpcOutputV2FloatingEvent struct {
-	IsFloating uint32
-}
-type ZdwlIpcOutputV2FloatingHandlerFunc func(ZdwlIpcOutputV2FloatingEvent)
-
-// SetFloatingHandler : sets handler for ZdwlIpcOutputV2FloatingEvent
-func (i *ZdwlIpcOutputV2) SetFloatingHandler(f ZdwlIpcOutputV2FloatingHandlerFunc) {
-	i.floatingHandler = f
-}
-
-// ZdwlIpcOutputV2XEvent : Update the x coordinates
-//
-// Indicates if x coordinates of the selected client.
-type ZdwlIpcOutputV2XEvent struct {
-	X int32
-}
-type ZdwlIpcOutputV2XHandlerFunc func(ZdwlIpcOutputV2XEvent)
-
-// SetXHandler : sets handler for ZdwlIpcOutputV2XEvent
-func (i *ZdwlIpcOutputV2) SetXHandler(f ZdwlIpcOutputV2XHandlerFunc) {
-	i.xHandler = f
-}
-
-// ZdwlIpcOutputV2YEvent : Update the y coordinates
-//
-// Indicates if y coordinates of the selected client.
-type ZdwlIpcOutputV2YEvent struct {
-	Y int32
-}
-type ZdwlIpcOutputV2YHandlerFunc func(ZdwlIpcOutputV2YEvent)
-
-// SetYHandler : sets handler for ZdwlIpcOutputV2YEvent
-func (i *ZdwlIpcOutputV2) SetYHandler(f ZdwlIpcOutputV2YHandlerFunc) {
-	i.yHandler = f
-}
-
-// ZdwlIpcOutputV2WidthEvent : Update the width
-//
-// Indicates if width of the selected client.
-type ZdwlIpcOutputV2WidthEvent struct {
-	Width int32
-}
-type ZdwlIpcOutputV2WidthHandlerFunc func(ZdwlIpcOutputV2WidthEvent)
-
-// SetWidthHandler : sets handler for ZdwlIpcOutputV2WidthEvent
-func (i *ZdwlIpcOutputV2) SetWidthHandler(f ZdwlIpcOutputV2WidthHandlerFunc) {
-	i.widthHandler = f
-}
-
-// ZdwlIpcOutputV2HeightEvent : Update the height
-//
-// Indicates if height of the selected client.
-type ZdwlIpcOutputV2HeightEvent struct {
-	Height int32
-}
-type ZdwlIpcOutputV2HeightHandlerFunc func(ZdwlIpcOutputV2HeightEvent)
-
-// SetHeightHandler : sets handler for ZdwlIpcOutputV2HeightEvent
-func (i *ZdwlIpcOutputV2) SetHeightHandler(f ZdwlIpcOutputV2HeightHandlerFunc) {
-	i.heightHandler = f
-}
-
-// ZdwlIpcOutputV2LastLayerEvent : last map layer.
-//
-// last map layer.
-type ZdwlIpcOutputV2LastLayerEvent struct {
-	LastLayer string
-}
-type ZdwlIpcOutputV2LastLayerHandlerFunc func(ZdwlIpcOutputV2LastLayerEvent)
-
-// SetLastLayerHandler : sets handler for ZdwlIpcOutputV2LastLayerEvent
-func (i *ZdwlIpcOutputV2) SetLastLayerHandler(f ZdwlIpcOutputV2LastLayerHandlerFunc) {
-	i.lastLayerHandler = f
-}
-
-// ZdwlIpcOutputV2KbLayoutEvent : current keyboard layout.
-//
-// current keyboard layout.
-type ZdwlIpcOutputV2KbLayoutEvent struct {
-	KbLayout string
-}
-type ZdwlIpcOutputV2KbLayoutHandlerFunc func(ZdwlIpcOutputV2KbLayoutEvent)
-
-// SetKbLayoutHandler : sets handler for ZdwlIpcOutputV2KbLayoutEvent
-func (i *ZdwlIpcOutputV2) SetKbLayoutHandler(f ZdwlIpcOutputV2KbLayoutHandlerFunc) {
-	i.kbLayoutHandler = f
-}
-
-// ZdwlIpcOutputV2KeymodeEvent : current keybind mode.
-//
-// current keybind mode.
-type ZdwlIpcOutputV2KeymodeEvent struct {
-	Keymode string
-}
-type ZdwlIpcOutputV2KeymodeHandlerFunc func(ZdwlIpcOutputV2KeymodeEvent)
-
-// SetKeymodeHandler : sets handler for ZdwlIpcOutputV2KeymodeEvent
-func (i *ZdwlIpcOutputV2) SetKeymodeHandler(f ZdwlIpcOutputV2KeymodeHandlerFunc) {
-	i.keymodeHandler = f
-}
-
-// ZdwlIpcOutputV2ScalefactorEvent : scale factor of monitor.
-//
-// scale factor of monitor.
-type ZdwlIpcOutputV2ScalefactorEvent struct {
-	Scalefactor uint32
-}
-type ZdwlIpcOutputV2ScalefactorHandlerFunc func(ZdwlIpcOutputV2ScalefactorEvent)
-
-// SetScalefactorHandler : sets handler for ZdwlIpcOutputV2ScalefactorEvent
-func (i *ZdwlIpcOutputV2) SetScalefactorHandler(f ZdwlIpcOutputV2ScalefactorHandlerFunc) {
-	i.scalefactorHandler = f
-}
-
-func (i *ZdwlIpcOutputV2) Dispatch(opcode uint32, fd int, data []byte) {
-	switch opcode {
-	case 0:
-		if i.toggleVisibilityHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2ToggleVisibilityEvent
-
-		i.toggleVisibilityHandler(e)
-	case 1:
-		if i.activeHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2ActiveEvent
-		l := 0
-		e.Active = client.Uint32(data[l : l+4])
-		l += 4
-
-		i.activeHandler(e)
-	case 2:
-		if i.tagHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2TagEvent
-		l := 0
-		e.Tag = client.Uint32(data[l : l+4])
-		l += 4
-		e.State = client.Uint32(data[l : l+4])
-		l += 4
-		e.Clients = client.Uint32(data[l : l+4])
-		l += 4
-		e.Focused = client.Uint32(data[l : l+4])
-		l += 4
-
-		i.tagHandler(e)
-	case 3:
-		if i.layoutHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2LayoutEvent
-		l := 0
-		e.Layout = client.Uint32(data[l : l+4])
-		l += 4
-
-		i.layoutHandler(e)
-	case 4:
-		if i.titleHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2TitleEvent
-		l := 0
-		titleLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
-		l += 4
-		e.Title = client.String(data[l : l+titleLen])
-		l += titleLen
-
-		i.titleHandler(e)
-	case 5:
-		if i.appidHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2AppidEvent
-		l := 0
-		appidLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
-		l += 4
-		e.Appid = client.String(data[l : l+appidLen])
-		l += appidLen
-
-		i.appidHandler(e)
-	case 6:
-		if i.layoutSymbolHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2LayoutSymbolEvent
-		l := 0
-		layoutLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
-		l += 4
-		e.Layout = client.String(data[l : l+layoutLen])
-		l += layoutLen
-
-		i.layoutSymbolHandler(e)
-	case 7:
-		if i.frameHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2FrameEvent
-
-		i.frameHandler(e)
-	case 8:
-		if i.fullscreenHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2FullscreenEvent
-		l := 0
-		e.IsFullscreen = client.Uint32(data[l : l+4])
-		l += 4
-
-		i.fullscreenHandler(e)
-	case 9:
-		if i.floatingHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2FloatingEvent
-		l := 0
-		e.IsFloating = client.Uint32(data[l : l+4])
-		l += 4
-
-		i.floatingHandler(e)
-	case 10:
-		if i.xHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2XEvent
-		l := 0
-		e.X = int32(client.Uint32(data[l : l+4]))
-		l += 4
-
-		i.xHandler(e)
-	case 11:
-		if i.yHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2YEvent
-		l := 0
-		e.Y = int32(client.Uint32(data[l : l+4]))
-		l += 4
-
-		i.yHandler(e)
-	case 12:
-		if i.widthHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2WidthEvent
-		l := 0
-		e.Width = int32(client.Uint32(data[l : l+4]))
-		l += 4
-
-		i.widthHandler(e)
-	case 13:
-		if i.heightHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2HeightEvent
-		l := 0
-		e.Height = int32(client.Uint32(data[l : l+4]))
-		l += 4
-
-		i.heightHandler(e)
-	case 14:
-		if i.lastLayerHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2LastLayerEvent
-		l := 0
-		lastLayerLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
-		l += 4
-		e.LastLayer = client.String(data[l : l+lastLayerLen])
-		l += lastLayerLen
-
-		i.lastLayerHandler(e)
-	case 15:
-		if i.kbLayoutHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2KbLayoutEvent
-		l := 0
-		kbLayoutLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
-		l += 4
-		e.KbLayout = client.String(data[l : l+kbLayoutLen])
-		l += kbLayoutLen
-
-		i.kbLayoutHandler(e)
-	case 16:
-		if i.keymodeHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2KeymodeEvent
-		l := 0
-		keymodeLen := client.PaddedLen(int(client.Uint32(data[l : l+4])))
-		l += 4
-		e.Keymode = client.String(data[l : l+keymodeLen])
-		l += keymodeLen
-
-		i.keymodeHandler(e)
-	case 17:
-		if i.scalefactorHandler == nil {
-			return
-		}
-		var e ZdwlIpcOutputV2ScalefactorEvent
-		l := 0
-		e.Scalefactor = client.Uint32(data[l : l+4])
-		l += 4
-
-		i.scalefactorHandler(e)
-	}
-}

core/internal/qmlchecks/greeter_session_memory_test.go

@@ -0,0 +1,22 @@
+package qmlchecks
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestGreeterRememberLastSessionFallsBackToDesktopID(t *testing.T) {
+	data, err := os.ReadFile("../../../quickshell/Modules/Greetd/GreeterContent.qml")
+	if err != nil {
+		t.Fatalf("read greeter QML: %v", err)
+	}
+
+	content := string(data)
+	if !strings.Contains(content, "GreetdMemory.lastSessionDesktopId || desktopIdFromPath(GreetdMemory.lastSessionId)") {
+		t.Fatalf("remembered greeter sessions should derive a desktop id from legacy absolute session paths")
+	}
+	if !strings.Contains(content, "GreeterState.sessionDesktopIds[i] === savedDesktopId") {
+		t.Fatalf("remembered greeter sessions should match current sessions by desktop id")
+	}
+}

core/internal/qmlchecks/lockscreen_input_test.go

@@ -0,0 +1,25 @@
+package qmlchecks
+
+import (
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestLockScreenPasswordFieldBypassesTextInputIME(t *testing.T) {
+	data, err := os.ReadFile("../../../quickshell/Modules/Lock/LockScreenContent.qml")
+	if err != nil {
+		t.Fatalf("read lock screen QML: %v", err)
+	}
+
+	content := string(data)
+	textInputPasswordField := regexp.MustCompile(`(?s)TextInput\s*\{[^{}]*id:\s*passwordField`)
+	if textInputPasswordField.MatchString(content) {
+		t.Fatalf("passwordField must not be a TextInput because TextInput can route physical keyboard input through IME")
+	}
+
+	if !strings.Contains(content, "Keys.onPressed") || !strings.Contains(content, "event.text") {
+		t.Fatalf("passwordField should handle physical key text manually instead of relying on a text input control")
+	}
+}