feat(wails): move the Go side to v3

Phases 2 and 3 of plan 009, plus the parts of phase 1 that could not
land before them. Nothing in the tree imports wails/v2 any more; all
three lint and test configurations are green and `go build .` produces
a running binary.

The point of the migration is one file. backend/events/emit.go probed
ctx.Value("events") — a v2-*private* context key — to decide whether
emitting was safe, because runtime.EventsEmit called log.Fatalf on a
context without the runtime and took the process down with it. v3's
emit takes no context, so that is now application.Get() == nil. D1
held: events.Emit keeps its ctx as the WithSink test seam, and all 45
call sites and 7 test files are untouched.

The bootstrap splits into application.New + Window.NewWithOptions +
Run. Ten bound services implement ServiceStartup instead of being
handed a context by hand from OnStartup, which also stops ten
SetContext methods being exported as bindings. jobs.Registry and
explore.SearchIndex keep theirs — neither is bound, so converting them
would be churn for no binding removed.

Four things differed from the plan and are written up in it: GPU policy
moved to the per-window LinuxWindow options rather than surviving on
LinuxOptions; there is no OnStartup/OnDomReady option, so app-level
wiring hangs off ApplicationStarted; application.NewService is generic,
so FEBindings []any could not survive (the binding generator is a
static analyser and would have seen nothing); and the quit veto had to
be restructured, because v3's dialog answers on a callback rather than
returning the button, so ShouldQuit vetoes, asks, and quits again from
the callback.

Window state saving moves to a WindowClosing hook — the size has to be
read while the window still exists, and v3's OnShutdown has neither
context nor window. backend/logging is deleted rather than ported:
v3 takes a *slog.Logger directly, so the v2 logger.Logger adapter had
no caller left.

Phase 1's tail rides along, now that it can: the Makefile's wails
invocations, all 50 webkit2_41 sites, lefthook, both packaging recipes
and ci.yml's apt lists. v3 builds against GTK4 + WebKitGTK 6.0, which
Arch and ubuntu:24.04 both ship, so the tag is a deletion rather than
a translation.

Phase 4 is next and the branch is not usable until it lands: the app
builds, but frontend/wailsjs/ is v2's tree and nothing regenerates it,
so the frontend cannot reach the backend yet.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UDCbcCZQepnpSQYJ6SxxZm

backend/frontendutil/frontendutil.go

@@ -3,12 +3,18 @@ package frontendutil
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 
-	"github.com/wailsapp/wails/v2/pkg/runtime"
+	"github.com/wailsapp/wails/v3/pkg/application"
 )
 
+// ErrNoRuntime is returned when a dialog is asked for with no running
+// application to parent it to — under test, or after shutdown.
+var ErrNoRuntime = errors.New("no Wails runtime to show a dialog")
+
 // FrontendUtil provides frontend-bound Go functions.
 type FrontendUtil struct {
 	ctx context.Context
@@ -19,18 +25,35 @@ func NewFrontendUtil() (*FrontendUtil, error) {
 	return &FrontendUtil{}, nil
 }
 
-// SetContext sets the Wails runtime context.
-func (fe *FrontendUtil) SetContext(ctx context.Context) {
+// ServiceStartup is v3's service lifecycle hook: it runs once the
+// runtime exists, and ctx is cancelled when the app shuts down.  It
+// replaces v2's SetContext, which had to be called by hand from
+// OnStartup and was exported, so it was also bound to the frontend.
+func (fe *FrontendUtil) ServiceStartup(
+	ctx context.Context,
+	_ application.ServiceOptions,
+) error {
 	fe.ctx = ctx
+
+	return nil
 }
 
 // DirectoryPicker opens a directory selection dialog.
+//
+// v3 has no separate directory dialog: it is the file dialog told to
+// choose directories and not files.
 func (fe *FrontendUtil) DirectoryPicker() (string, error) {
-	runtime.LogInfo(fe.ctx, "selecting a directory")
+	app := application.Get()
+	if app == nil {
+		return "", ErrNoRuntime
+	}
 
-	dir, err := runtime.OpenDirectoryDialog(
-		fe.ctx,
-		runtime.OpenDialogOptions{})
+	slog.Default().Info("selecting a directory")
+
+	dir, err := app.Dialog.OpenFile().
+		CanChooseDirectories(true).
+		CanChooseFiles(false).
+		PromptForSingleSelection()
 	if err != nil {
 		return "", fmt.Errorf(
 			"could not open directory dialog\n%w", err,
@@ -46,20 +69,17 @@ func (fe *FrontendUtil) PlaylistFilePicker() (
 	[]string,
 	error,
 ) {
-	runtime.LogInfo(fe.ctx, "selecting playlist files")
+	app := application.Get()
+	if app == nil {
+		return nil, ErrNoRuntime
+	}
 
-	files, err := runtime.OpenMultipleFilesDialog(
-		fe.ctx,
-		runtime.OpenDialogOptions{
-			Title: "Import Playlist",
-			Filters: []runtime.FileFilter{
-				{
-					DisplayName: "Playlist Files (*.m3u, *.m3u8)",
-					Pattern:     "*.m3u;*.m3u8",
-				},
-			},
-		},
-	)
+	slog.Default().Info("selecting playlist files")
+
+	files, err := app.Dialog.OpenFile().
+		SetTitle("Import Playlist").
+		AddFilter("Playlist Files (*.m3u, *.m3u8)", "*.m3u;*.m3u8").
+		PromptForMultipleSelection()
 	if err != nil {
 		return nil, fmt.Errorf(
 			"could not open file dialog: %w", err,
@@ -73,18 +93,15 @@ func (fe *FrontendUtil) PlaylistFilePicker() (
 // files (JPEG, PNG).  Returns the selected file path, or empty
 // string if the user cancelled.
 func (fe *FrontendUtil) ImageFilePicker() (string, error) {
-	file, err := runtime.OpenFileDialog(
-		fe.ctx,
-		runtime.OpenDialogOptions{
-			Title: "Select Cover Art",
-			Filters: []runtime.FileFilter{
-				{
-					DisplayName: "Image Files (*.jpg, *.jpeg, *.png)",
-					Pattern:     "*.jpg;*.jpeg;*.png",
-				},
-			},
-		},
-	)
+	app := application.Get()
+	if app == nil {
+		return "", ErrNoRuntime
+	}
+
+	file, err := app.Dialog.OpenFile().
+		SetTitle("Select Cover Art").
+		AddFilter("Image Files (*.jpg, *.jpeg, *.png)", "*.jpg;*.jpeg;*.png").
+		PromptForSingleSelection()
 	if err != nil {
 		return "", fmt.Errorf("could not open file dialog: %w", err)
 	}