Restructure step 3: your server, Invite, version gate, AppGraph

- One server per app run (loopback, no password); Invite attaches an
  all-interfaces listener to the same server and Stop sharing detaches
  it (guests told with 4016); members, media and Up next never reset.
  No solo mode: you're home on your own server unless in a friend's.
- Navigation: none / yours / friend; a join passes a version gate on
  /health first (clear "they/you need to update", update offer).
- Invite as a value (host, port, name, password flag, version, fp
  reserved); addresses filtered (loopback, link-local, 198.18/15,
  bridges) and ranked; Sharing chip, Copy invite, Stop sharing.
- Alone looks like a plain player (alone replaces solo).
- AppGraph builds and disposes systems; widgets use AppScope;
  SessionState deleted; a test caps the remaining singletons.

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

apps/desktop/lib/src/app/app_graph.dart

@@ -0,0 +1,156 @@
+import 'package:flutter/widgets.dart';
+
+import '../jellyfin/accounts.dart';
+import '../platform/app_log.dart' show appLogDir;
+import '../platform/desktop/desktop_ports.dart';
+import '../platform/ports/ports.dart';
+import '../screens/home/health_probe.dart';
+import '../session/connection.dart' show Connection;
+import '../session/identity.dart' show ClientIdentity, Profile;
+import '../session/navigation.dart';
+import '../session/notifier.dart';
+import '../session/session_coordinator.dart';
+import '../session/your_server.dart';
+import '../sfx/sfx.dart';
+import '../sfx/sound_bank.dart';
+import '../sfx/synth_sfx.dart';
+import '../state/connect_prefs.dart';
+import '../state/settings.dart';
+
+/// The composition root: builds the app's systems once (in `main`), wires
+/// them through their constructors and disposes them. No logic and no
+/// signals of its own. Widgets reach it through [AppScope].
+class AppGraph {
+  /// The platform (window, links, folders, yt-dlp, notifications).
+  final Ports ports;
+
+  /// Owns the app's audio device ([SynthSfx.dispose] on close).
+  final SynthSfx sfx;
+
+  /// Every toast, sound, system notification and activity-log line.
+  final Notifier notifier;
+
+  /// The link to whichever server this app is in.
+  final Connection connection;
+
+  final SessionCoordinator coordinator;
+
+  /// The connect form and recent servers.
+  final ConnectStore forms;
+
+  /// This app's own server, alive for the whole run.
+  final YourServer yourServer;
+
+  /// Home (your server) or a friend's.
+  final Navigation navigation;
+
+  AppGraph._({
+    required this.ports,
+    required this.sfx,
+    required this.notifier,
+    required this.connection,
+    required this.coordinator,
+    required this.forms,
+    required this.yourServer,
+    required this.navigation,
+  });
+
+  /// The desktop app's graph. Tests pass their own [ports], [identity]
+  /// (default: the install's stored one), [healthGet] and server starter.
+  factory AppGraph.build({
+    Ports? ports,
+    ClientIdentity? identity,
+    HealthGetter healthGet = defaultHealthGet,
+    ServerStarter? serverStarter,
+    JellyfinAccounts? jellyfin,
+  }) {
+    final p = ports ?? desktopPorts();
+    final sfx = SynthSfx(
+      volume: () => AppSettings.instance.soundVolume.peek(),
+      // A nudge is an explicit poke: it ignores its switch (not the volume).
+      enabled: (k) => k == SfxKind.nudge || !AppSettings.instance.soundsOff.peek().contains(k.name),
+      presetFor: soundPresetFor,
+    );
+    final notifier = Notifier(
+      sfx: sfx,
+      attention: p.shell.requestAttention,
+      system: p.notifications,
+      focusWindow: p.shell.focus,
+      prefs: () => AppSettings.instance.notifyPrefs,
+    );
+    final connection = Connection(notify: notifier.notify, identity: identity ?? ClientIdentity.stored());
+    final coordinator =
+        SessionCoordinator(notifier: notifier, connection: connection, ytDlp: p.links, jellyfin: jellyfin);
+    final forms = ConnectStore();
+    final yourServer = YourServer(
+      forms: forms,
+      jellyfin: jellyfin,
+      // The app's yt-dlp folder; '' (the server's own default) when the
+      // app-support folder is not available.
+      ytDlpDir: () async {
+        try {
+          return (await p.links.ytDlp).dir;
+        } catch (_) {
+          return '';
+        }
+      },
+      logDir: () => appLogDir,
+      starter: serverStarter,
+    );
+    final navigation = Navigation(
+      coordinator: coordinator,
+      yourServer: yourServer,
+      forms: forms,
+      healthGet: healthGet,
+    );
+    // The profile keeps its name in the connect form and pushes changes
+    // to whichever server this app is in.
+    Profile.instance
+      ..forms = forms
+      ..push = ({String? name, String? avatar}) {
+        if (navigation.online.peek()) coordinator.updateProfile(name: name, avatar: avatar);
+      };
+    return AppGraph._(
+      ports: p,
+      sfx: sfx,
+      notifier: notifier,
+      connection: connection,
+      coordinator: coordinator,
+      forms: forms,
+      yourServer: yourServer,
+      navigation: navigation,
+    );
+  }
+
+  Future<void> dispose() async {
+    navigation.dispose();
+    await coordinator.dispose();
+    await yourServer.stop();
+    await sfx.dispose();
+  }
+}
+
+/// The sound set [kind] plays from: its own pick in Settings, else the
+/// overall one.
+SoundPreset soundPresetFor(SfxKind kind) {
+  final s = AppSettings.instance;
+  final name = s.soundPresetFor.peek()[kind.name] ?? s.soundPreset.peek();
+  return SoundPreset.values.where((p) => p.name == name).firstOrNull ?? defaultPreset;
+}
+
+/// Hands the [AppGraph] to every widget below: `AppScope.of(context)`.
+/// The graph never changes, so reading it registers no dependency (safe
+/// in `initState`).
+class AppScope extends InheritedWidget {
+  final AppGraph graph;
+  const AppScope({super.key, required this.graph, required super.child});
+
+  static AppGraph of(BuildContext context) {
+    final scope = context.getInheritedWidgetOfExactType<AppScope>();
+    assert(scope != null, 'no AppScope above this widget');
+    return scope!.graph;
+  }
+
+  @override
+  bool updateShouldNotify(AppScope oldWidget) => !identical(graph, oldWidget.graph);
+}