SmC: real per-peer geo, on-globe heart burst, arc reversal

- Geo: peerLookup switched from geo.getiantem.org/<ip> (returns 404 for
  arbitrary IPs — every peer collapsed to the IR-fallback center) to
  ipwho.is (HTTPS, no auth, city-level lat/lon + country name + flag
  emoji). PeerLookup now returns PeerGeo with a real, unique location
  per peer.
- Event model: UnboundedConnectionEvent carries country name, flag
  emoji, coords, and an isReplay flag.
- Notifier: ref-counts streams per TCP peer so the arc persists until
  the peer's last H2 stream closes (samizdat multiplexes many streams
  over one conn); resolves geo async then emits enriched events;
  replayCurrentPeers() seeds the globe with existing peers when the
  user navigates to SmC mid-stream; emits synthetic -1's on toggle-off
  so arcs don't orphan when peer.Client.Stop suppresses the box.Close
  cascade.
- Globe: arcs linger 5s past last -1 so brief URL-test probes still
  register; coords jittered ±2° per workerIdx hash so multiple peers
  in the same city fan out instead of overlapping; arc direction
  reversed (censored user → uncensored peer) so the dash animation
  reads as traffic arriving at us.
- Heart burst: on-globe animation anchored at peer coords via
  Point.labelBuilder (lib projects 3D→2D for us). Uses the actual
  assets from getlantern/unbounded — explosion.json Lottie + the
  inline FF5A79 heart SVG path via CustomPainter. 4.6s burst + 4.2s
  fading country label below.
- StatusCard: small info_outline tooltip explaining that most events
  are short URL-test liveness probes (601 of ~700 CONNECTs in a
  measured session were to api.iantem.io — clients probing peer
  reachability before sending real traffic).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 2 people

assets/unbounded/explosion.json

@@ -1,13 +1,31 @@
+import 'package:flutter_earth_globe/globe_coordinates.dart';
+
 /// Represents a consumer connection change from the broflake widget proxy.
 class UnboundedConnectionEvent {
   final int state; // 1 = connected, -1 = disconnected
   final int workerIdx;
   final String addr; // IP address
+  // Geo fields are populated by ShareNotifier after peer lookup. Empty on
+  // legacy events and on -1 frames (where only workerIdx matters for the
+  // globe to remove the arc).
+  final String countryName;
+  final String countryCode;
+  final String flagEmoji;
+  final GlobeCoordinates? coordinates;
+  // True for synthetic events the notifier emits to seed a newly-mounted
+  // globe with peers that connected before the screen opened. Lets the UI
+  // suppress the "new connection from <country>" burst for replays.
+  final bool isReplay;
 
   UnboundedConnectionEvent({
     required this.state,
     required this.workerIdx,
     required this.addr,
+    this.countryName = '',
+    this.countryCode = '',
+    this.flagEmoji = '',
+    this.coordinates,
+    this.isReplay = false,
   });
 
   factory UnboundedConnectionEvent.fromJson(Map<String, dynamic> json) {

lib/core/models/unbounded_connection_event.dart

@@ -3,11 +3,38 @@ import 'dart:convert';
 import 'package:flutter_earth_globe/globe_coordinates.dart';
 import 'package:http/http.dart' as http;
 
+/// Result of a peer geo lookup. Country/flag default to empty when the
+/// lookup fails; coordinates default to a centre-of-the-globe sentinel.
+class PeerGeo {
+  const PeerGeo({
+    required this.coordinates,
+    required this.countryName,
+    required this.countryCode,
+    required this.flagEmoji,
+  });
+
+  final GlobeCoordinates coordinates;
+  final String countryName;
+  final String countryCode;
+  final String flagEmoji;
+
+  static const unknown = PeerGeo(
+    coordinates: GlobeCoordinates(0, 0),
+    countryName: '',
+    countryCode: '',
+    flagEmoji: '',
+  );
+}
+
 class GeoLookupService {
-  static const _geoUrl = 'https://geo.getiantem.org';
+  static const _selfUrl = 'https://geo.getiantem.org';
+  // ipwho.is: HTTPS, no auth, 10k req/month free. Returns country + lat/lon
+  // + flag emoji in one shot.
+  static const _peerUrl = 'https://ipwho.is';
 
-  // ISO country code → approximate centre coordinates
-  static const _countries = {
+  // ISO country code → approximate centre coordinates. Used as a fallback
+  // when ipwho.is doesn't return city-level coords.
+  static const _countryCenters = {
     'AF': (lat: 33.0, lng: 65.0),
     'AL': (lat: 41.0, lng: 20.0),
     'DZ': (lat: 28.0, lng: 3.0),
@@ -133,15 +160,15 @@ class GeoLookupService {
   };
 
   static GlobeCoordinates _isoToCoords(String iso) {
-    final c = _countries[iso] ?? _countries['US']!;
+    final c = _countryCenters[iso] ?? _countryCenters['US']!;
     return GlobeCoordinates(c.lat, c.lng);
   }
 
   /// Looks up the current device's location (no IP argument).
   static Future<GlobeCoordinates> selfLookup() async {
     try {
       final response = await http
-          .get(Uri.parse('$_geoUrl/'))
+          .get(Uri.parse('$_selfUrl/'))
           .timeout(const Duration(seconds: 5));
       if (response.statusCode == 200) {
         final data = jsonDecode(response.body) as Map<String, dynamic>;
@@ -154,20 +181,31 @@ class GeoLookupService {
     return _isoToCoords('US');
   }
 
-  /// Looks up the country for a peer [ip] address.
-  static Future<GlobeCoordinates> peerLookup(String ip) async {
+  /// Looks up country, flag, and coordinates for a peer [ip] address.
+  /// Returns [PeerGeo.unknown] on any failure so callers can suppress the
+  /// arc / banner rather than displaying a wrong country.
+  static Future<PeerGeo> peerLookup(String ip) async {
     try {
       final response = await http
-          .get(Uri.parse('$_geoUrl/$ip'))
+          .get(Uri.parse('$_peerUrl/$ip'))
           .timeout(const Duration(seconds: 5));
-      if (response.statusCode == 200) {
-        final data = jsonDecode(response.body) as Map<String, dynamic>;
-        final iso =
-            (data['Country'] as Map<String, dynamic>?)?['IsoCode'] as String? ??
-                'IR';
-        return _isoToCoords(iso);
-      }
+      if (response.statusCode != 200) return PeerGeo.unknown;
+      final data = jsonDecode(response.body) as Map<String, dynamic>;
+      if (data['success'] != true) return PeerGeo.unknown;
+      final iso = (data['country_code'] as String?) ?? '';
+      final lat = (data['latitude'] as num?)?.toDouble();
+      final lng = (data['longitude'] as num?)?.toDouble();
+      final coords = (lat != null && lng != null)
+          ? GlobeCoordinates(lat, lng)
+          : _isoToCoords(iso);
+      final flagObj = data['flag'] as Map<String, dynamic>?;
+      return PeerGeo(
+        coordinates: coords,
+        countryName: (data['country'] as String?) ?? '',
+        countryCode: iso,
+        flagEmoji: (flagObj?['emoji'] as String?) ?? '',
+      );
     } catch (_) {}
-    return _isoToCoords('IR');
+    return PeerGeo.unknown;
   }
 }