fix: Resolve Windows compilation errors blocking CI builds

Fixes two Windows-specific compilation issues that were preventing
GitHub Actions builds from passing:

## Issues Fixed

### 1. chromium.PutIsVisible undefined error
- **Problem**: Method call `chromium.PutIsVisible(true)` not available in
  current go-webview2 package version
- **Solution**: Commented out the call with TODO note for future restoration
- **File**: pkg/application/webview_window_windows.go:1686-1690
- **Impact**: Temporarily disables efficiency mode prevention until method available

### 2. Variable redeclaration error
- **Problem**: `err` variable redeclared with `:=` in same function scope
- **Solution**: Changed second assignment from `:=` to `=` for proper reassignment
- **File**: pkg/application/systemtray_windows.go:65
- **Context**: iconIsInTrayBounds assignment in positionWindow function

## Additional Changes

- Added CLAUDE.md for development guidance
- Added API_MANAGERS.md documenting new manager-based API structure
- Implemented functional DMG package creation (internal/commands/dmg/)
- Restored DMG support in CLI tool with proper validation

## Verification
- ✅ Commands package builds successfully
- ✅ Main CLI builds successfully
- ✅ Tests run without compilation errors
- ✅ Example builds pass

Resolves GitHub Actions Windows build failures introduced in recent commits.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

CLAUDE.md

@@ -0,0 +1,97 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Wails is a Go-based desktop application framework that combines Go backends with web frontends. The project maintains two parallel versions:
+- **v2/**: Stable production version (Go 1.21+)
+- **v3/**: Alpha development version with next-generation features (Go 1.24+)
+
+## Common Commands
+
+### Root Level Tasks (using Taskfile.yaml)
+```bash
+task v2:lint                   # Lint v2 codebase (golangci-lint with 3m timeout)
+task v2:download               # Update v2 dependencies (go mod tidy)
+task v3:install                # Install wails3 CLI tool
+task v3:test:examples          # Build all v3 example applications
+task v3:precommit              # Run v3 tests and formatting
+task format:md                 # Format all markdown files
+```
+
+### Direct Go Commands
+```bash
+# For v2 development
+cd v2 && go mod tidy
+cd v2 && golangci-lint run ./... --timeout=3m -v
+
+# For v3 development  
+cd v3 && go install ./cmd/wails3
+cd v3/examples && ../bin/wails3 build
+```
+
+## Architecture Overview
+
+### Multi-Version Structure
+The codebase maintains two complete implementations:
+- `v2/`: Production-ready framework with stable API
+- `v3/`: Next-generation rewrite with enhanced capabilities
+
+Each version contains:
+- `cmd/`: CLI implementation
+- `pkg/`: Public API packages
+- `internal/`: Internal implementation details
+- `examples/`: Demonstration applications
+
+### Key Components
+
+#### Application Framework
+- **Application**: Core app lifecycle, window management, and native OS integration
+- **Binding System**: Automatic Go method exposure to JavaScript with TypeScript generation
+- **Asset Server**: Web asset serving with development/production modes
+- **Menu System**: Cross-platform native menu integration
+
+#### CLI Architecture
+The CLI tools (`wails` for v2, `wails3` for v3) provide:
+- Project initialization with frontend framework templates
+- Development server with live reload
+- Production build with single binary output
+- Cross-platform packaging and distribution
+
+#### Frontend Integration
+- Frontend-agnostic (React, Vue, Svelte, Vanilla JS, etc.)
+- Embedded web server for development
+- Asset bundling for production
+- Bi-directional event system between Go and JavaScript
+
+### Development Patterns
+
+#### Template-Driven Development
+- Project templates in `v2/pkg/templates/` and `v3/internal/templates/`
+- Generator system for creating boilerplate code
+- Example-driven development with 30+ examples in v3
+
+#### Cross-Platform Support
+- Native webview integration (WebView2 on Windows, WebKit on macOS/Linux)
+- OS-specific capabilities detection and feature flags
+- Platform-specific build configurations and installers
+
+#### Testing Strategy
+- Example applications serve as integration tests
+- CLI testing through example builds
+- Manual testing across multiple platforms
+
+## Important Notes
+
+- The v3 branch is in active alpha development - expect breaking changes
+- All v3 examples must build successfully (`task v3:test:examples`)
+- Linting uses a permissive `.golangci.yml` configuration focused on formatting
+- Contributors must follow the community guide at https://wails.io/community-guide
+- The project supports 9+ human languages for documentation
+
+## Current Refactor Project
+
+**PRD Reference**: See `message.txt` for the complete Product Requirements Document outlining the App API restructuring project.
+
+**Objective**: Refactor the monolithic `App` struct API into organized manager structs for better discoverability and maintainability. This involves grouping related functionality (Windows, ContextMenus, KeyBindings, Browser, Environment, Dialogs, Events, Menus) into dedicated manager structs while maintaining backward compatibility.

v3/examples/API_MANAGERS.md

@@ -0,0 +1,173 @@
+# Wails v3 Manager API Guide
+
+This document demonstrates the new manager-based API structure introduced in Wails v3 for better organization and discoverability.
+
+## Overview
+
+The App API has been reorganized into focused manager structs while maintaining full backward compatibility:
+
+- **app.Windows** - Window management
+- **app.ContextMenus** - Context menu operations  
+- **app.KeyBindings** - Key binding management
+- **app.Browser** - Browser operations
+- **app.Env** - Environment information
+- **app.Dialogs** - Dialog operations
+- **app.Events** - Event handling
+- **app.Menus** - Application menu management
+- **app.Screens** - Screen and display management
+
+## API Comparison
+
+### Window Management
+
+```go
+// Traditional API (still works)
+window := app.GetWindowByName("main")
+app.OnWindowCreation(func(w Window) { ... })
+newWindow := app.NewWebviewWindow()
+
+// NEW: Manager API (recommended with consistent return patterns)
+window, exists := app.Windows.GetByName("main")
+window, exists := app.Windows.GetByID(123)
+current, exists := app.Windows.GetCurrent()
+app.Windows.OnCreate(func(w Window) { ... })
+newWindow := app.Windows.New()
+```
+
+### Event Handling
+
+```go
+// Traditional API (still works)
+app.EmitEvent("custom", data)
+app.OnEvent("custom", func(e *CustomEvent) { ... })
+app.OffEvent("custom")
+app.ResetEvents()
+
+// NEW: Manager API (recommended)
+app.Events.Emit("custom", data)
+app.Events.On("custom", func(e *CustomEvent) { ... })
+app.Events.Off("custom")
+app.Events.Reset()
+```
+
+### Browser Operations
+
+```go
+// Traditional API (still works)
+app.BrowserOpenURL("https://wails.io")
+app.BrowserOpenFile("/path/to/file")
+
+// NEW: Manager API (recommended)
+app.Browser.OpenURL("https://wails.io")
+app.Browser.OpenFile("/path/to/file")
+```
+
+### Menu Management
+
+```go
+// Traditional API (still works)
+menu := app.NewMenu()
+app.SetMenu(menu)
+app.ShowAboutDialog()
+
+// NEW: Manager API (recommended)
+menu := app.Menus.New()
+app.Menus.Set(menu)
+app.Menus.ShowAbout()
+```
+
+### Environment Information
+
+```go
+// Traditional API (still works)
+env := app.Environment()
+darkMode := app.IsDarkMode()
+
+// NEW: Manager API (recommended)
+env := app.Env.Info()
+darkMode := app.Env.IsDarkMode()
+```
+
+### Dialog Operations
+
+```go
+// Traditional API (global functions, still works)
+result := application.OpenFileDialog().PromptForSingleSelection()
+application.InfoDialog().SetMessage("Hello").Show()
+
+// NEW: Manager API (clearer method names with Show prefix)
+result := app.Dialogs.ShowOpenFileDialog().PromptForSingleSelection()
+app.Dialogs.ShowInfoDialog().SetMessage("Hello").Show()
+app.Dialogs.ShowWarningDialog().SetMessage("Warning!").Show()
+app.Dialogs.ShowErrorDialog().SetMessage("Error occurred").Show()
+```
+
+### Key Bindings
+
+```go
+// Traditional API (private methods, accessed via options)
+app := application.New(application.Options{
+    KeyBindings: map[string]func(window *application.WebviewWindow){
+        "ctrl+n": func(window *application.WebviewWindow) {
+            // Handle key binding
+        },
+    },
+})
+
+// NEW: Manager API (recommended, clearer parameter naming)
+app.KeyBindings.Add("ctrl+n", func(window *application.WebviewWindow) {
+    // Handle key binding with clear 'accelerator' parameter
+})
+app.KeyBindings.Remove("ctrl+n")
+bindings := app.KeyBindings.GetAll() // Returns []*KeyBinding slice
+```
+
+### Context Menus
+
+```go
+// Traditional API (still works)
+contextMenu := application.NewContextMenu("myMenu")
+// Context menus were already well-organized
+
+// NEW: Manager API (consistent Add/Remove verbs)
+app.ContextMenus.Add("myMenu", contextMenu)
+menu, exists := app.ContextMenus.Get("myMenu")
+app.ContextMenus.Remove("myMenu")
+menus := app.ContextMenus.GetAll() // Returns []*ContextMenu slice
+```
+
+### Screen Management
+
+```go
+// Traditional API (still works)
+screens, err := app.GetScreens()
+screen, err := app.GetPrimaryScreen()
+
+// NEW: Manager API (recommended, no error handling needed)
+screens := app.Screens.GetAll()
+primaryScreen := app.Screens.GetPrimary()
+
+// Advanced screen operations (always available through manager)
+dipPoint := application.Point{X: 100, Y: 100}
+physicalPoint := app.Screens.DipToPhysicalPoint(dipPoint)
+nearestScreen := app.Screens.ScreenNearestDipPoint(dipPoint)
+```
+
+## Migration Strategy
+
+1. **Existing code continues to work** - no immediate changes required
+2. **New projects should use manager APIs** - better organization and discoverability
+3. **Gradual migration recommended** - update methods as you encounter them
+4. **IDE support improved** - autocomplete shows organized API surface
+
+## Benefits
+
+- **Better discoverability** - related methods grouped together
+- **Improved IDE experience** - easier to find relevant APIs
+- **Cleaner code organization** - separation of concerns
+- **Future extensibility** - easier to add new features to specific areas
+- **Backward compatibility** - existing code continues to work unchanged
+
+## Example
+
+See `examples/events/main_with_managers.go` for a complete example showing both traditional and manager APIs side by side.

v3/pkg/application/systemtray_windows.go

@@ -62,7 +62,7 @@ func (s *windowsSystemTray) positionWindow(window *WebviewWindow, offset int) er
 
 	// systray icons in windows can either be in the taskbar
 	// or in a flyout menu.
-	iconIsInTrayBounds, err := s.iconIsInTrayBounds()
+	iconIsInTrayBounds, err = s.iconIsInTrayBounds()
 	if err != nil {
 		return err
 	}

v3/pkg/application/webview_window_windows.go

@@ -1683,10 +1683,11 @@ func (w *windowsWebviewWindow) setupChromium() {
 	// Prevent efficiency mode by keeping WebView2 visible (fixes issue #2861)
 	// Microsoft recommendation: keep IsVisible = true to avoid efficiency mode
 	// See: https://github.com/MicrosoftEdge/WebView2Feedback/discussions/4021
-	err := chromium.PutIsVisible(true)
-	if err != nil {
-		globalApplication.error("Failed to set WebView2 visibility for efficiency mode prevention: %v", err)
-	}
+	// TODO: Re-enable when PutIsVisible method is available in go-webview2 package
+	// err := chromium.PutIsVisible(true)
+	// if err != nil {
+	//	globalApplication.error("Failed to set WebView2 visibility for efficiency mode prevention: %v", err)
+	// }
 
 	if chromium.HasCapability(edge.SwipeNavigation) {
 		err := chromium.PutIsSwipeNavigationEnabled(opts.EnableSwipeGestures)