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/events/emit.go

@@ -5,11 +5,11 @@ import (
 	"errors"
 	"log/slog"
 
-	"github.com/wailsapp/wails/v2/pkg/runtime"
+	"github.com/wailsapp/wails/v3/pkg/application"
 )
 
-// ErrNoRuntime is returned by Deliver when the context carries neither
-// a test Sink nor a live Wails runtime, so the event went nowhere.
+// ErrNoRuntime is returned by Deliver when there is neither a test Sink
+// in the context nor a running application, so the event went nowhere.
 var ErrNoRuntime = errors.New(
 	"no Wails runtime or event sink in context",
 )
@@ -46,14 +46,16 @@ func sinkFrom(ctx context.Context) Sink {
 // Emit publishes a Wails event, tolerating any context.
 //
 // This is the only supported way to emit an event: nothing outside this
-// package may call runtime.EventsEmit, which TestNoDirectEventsEmit
-// enforces.
+// package may call app.Event.Emit, which TestNoDirectRuntimeEmits
+// enforces.  That rule outlived its original reason — v2's
+// runtime.EventsEmit called log.Fatalf on a context that did not carry
+// the runtime, taking the process down from any background worker —
+// and is kept because one emit path is what keeps emitStatus-style
+// deduplication honest.
 //
-// runtime.EventsEmit calls log.Fatalf when the context is nil or lacks
-// the runtime's "events" value, terminating the process rather than
-// returning an error.  Background workers that outlive a context, and
-// any test that constructs a service directly, both hit that path — so
-// an event with nowhere to go is dropped and logged here instead.
+// The context is no longer a delivery mechanism: v3's emit takes none.
+// It stays because WithSink travels in it, which is what makes a
+// service that emits events testable in-process.
 func Emit(ctx context.Context, name string, data ...any) {
 	if err := Deliver(ctx, name, data...); err != nil {
 		slog.Default().Debug(
@@ -70,21 +72,26 @@ func Emit(ctx context.Context, name string, data ...any) {
 //
 // Ordinary emitters want Emit.
 func Deliver(ctx context.Context, name string, data ...any) error {
-	if ctx == nil {
+	// A nil context cannot carry a sink, but it is no longer a reason
+	// not to deliver: v3 emits through the application, not the context.
+	if ctx != nil {
+		if sink := sinkFrom(ctx); sink != nil {
+			sink.Emit(name, data...)
+
+			return nil
+		}
+	}
+
+	// application.Get() returns nil when no app is running — under test,
+	// before Run, and after shutdown.  It does not terminate the
+	// process, which is what the v2 probe of the private "events"
+	// context key existed to avoid.
+	app := application.Get()
+	if app == nil {
 		return ErrNoRuntime
 	}
 
-	if sink := sinkFrom(ctx); sink != nil {
-		sink.Emit(name, data...)
-
-		return nil
-	}
-
-	if ctx.Value("events") == nil {
-		return ErrNoRuntime
-	}
-
-	runtime.EventsEmit(ctx, name, data...)
+	app.Event.Emit(name, data...)
 
 	return nil
 }

backend/events/noemit_test.go

@@ -16,6 +16,13 @@ var allowedEmitters = map[string]bool{
 // TestNoDirectRuntimeEmits fails if anything outside backend/events
 // calls the Wails runtime's event emitter directly.
 //
+// The original reason was survival: v2's runtime.EventsEmit called
+// log.Fatalf on a context that did not carry the runtime, so a direct
+// call from a background worker could take the process down.  v3's
+// emit takes no context and cannot do that, and the rule is kept for
+// the weaker but still real reason — one emit path is what lets
+// emitStatus drop an unchanged payload for every caller at once.
+//
 // This is a text walk rather than a golangci-lint rule because
 // golangci-lint runs once per build configuration, so a call in an
 // indexbuild- or dev-tagged file is only seen by the pass that compiles
@@ -23,10 +30,11 @@ var allowedEmitters = map[string]bool{
 // entirely.
 func TestNoDirectRuntimeEmits(t *testing.T) {
 	// A selector, not a bare name: built at runtime so this file does
-	// not match itself, and qualified so it catches every import alias
-	// the tree uses (plain runtime., and wailsruntime.) without also
-	// matching an identifier that merely ends in the same letters.
-	needle := ".Events" + "Emit("
+	// not match itself, and qualified so it catches the call however
+	// the application value is named (app.Event.Emit, a.Event.Emit,
+	// application.Get().Event.Emit) without matching an identifier
+	// that merely ends in the same letters.
+	needle := ".Event" + ".Emit("
 
 	root := filepath.Join("..", "..")