smc: MediaQuery copyWith + symmetric wire format + drop stale fromJson

Three Copilot findings:

1. _GlobeView wrapped its body in MediaQuery(data: MediaQueryData(size:
   widgetSize), ...) — constructing MediaQueryData from scratch drops
   inherited fields (devicePixelRatio, textScaleFactor, padding,
   viewInsets, etc.). On high-DPI displays the pixel ratio fell to
   1.0, breaking globe rendering crispness; accessibility scaling
   for any descendants would also break. Switched to
   MediaQuery.of(context).copyWith(size: widgetSize) which keeps
   the inherited fields and only overrides what we need.

2. lantern-core/core.go's doc comment said the peer-connection wire
   payload was always {state, source, timestamp}, but the
   peer.ConnectionEvent marshal block emitted only {state, source}.
   Added timestamp to the peer marshal (both peer.ConnectionEvent
   and unbounded.ConnectionEvent carry Timestamp on the radiance
   side, so the consumer-facing shape is now symmetric) and
   updated the comment to spell out the source format difference
   between protocols and call out Unix-millis for timestamp.

3. UnboundedConnectionEvent.fromJson was stale: it expected
   {workerIdx, addr} keys, but the actual wire format is
   {state, source, timestamp}. The factory is never called from
   anywhere in lib/ — wire-format parsing happens inline in
   share_my_connection.dart, and the class is only constructed
   directly by the notifier as an internal Dart-side event model.
   Dropped the dead factory and clarified the class docstring to
   distinguish 'internal Dart-side model' from 'wire format',
   including a note that workerIdx is a Dart-side identity
   counter (_workerSeq), not the broflake worker index.

dart analyze clean; Go build clean.

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

Author: myleshorton

lantern-core/core.go

@@ -407,10 +407,11 @@ func (lc *LanternCore) listenDataCapEvents() {
 // The wire format unifies both protocols on a single event type
 // (EventTypePeerConnection) with a {state, source, timestamp}
 // payload — peer.ConnectionEvent and unbounded.ConnectionEvent both
-// expose the same shape on the radiance side, so consumers don't
-// need to disambiguate which protocol produced an event. Source is
-// "host:port" (IPv4) or "[host]:port" (IPv6) for peer-share, and
-// the broflake-reported consumer IP for Unbounded (no port).
+// carry the same three fields on the radiance side, so the Dart
+// consumer can deserialize each frame uniformly without caring
+// which protocol produced it. Source is "host:port" /
+// "[host]:port" for peer-share, and the broflake-reported consumer
+// IP (no port) for Unbounded. Timestamp is Unix milliseconds.
 func (lc *LanternCore) listenPeerConnectionEvents() {
 	// unbounded.ConnectionEvent stays on in-process events.Subscribe for
 	// now. Unbounded runs in the same process as the consumer in mobile
@@ -452,8 +453,9 @@ func (lc *LanternCore) listenPeerConnectionEvents() {
 	// immediately.
 	err := lc.client.PeerConnectionEvents(lc.ctx, func(evt peer.ConnectionEvent) {
 		jsonBytes, err := json.Marshal(map[string]any{
-			"state":  evt.State,
-			"source": evt.Source,
+			"state":     evt.State,
+			"source":    evt.Source,
+			"timestamp": evt.Timestamp,
 		})
 		if err != nil {
 			slog.Error("marshal peer connection event", "error", err)

lib/core/models/unbounded_connection_event.dart

@@ -1,6 +1,16 @@
 import 'package:flutter_earth_globe/globe_coordinates.dart';
 
-/// Represents a consumer connection change from the broflake widget proxy.
+/// Internal Dart-side connection-change model the ShareNotifier emits
+/// to the globe via _eventController. NOT the wire format —
+/// FlutterEvent messages from lantern-core (forwarded from radiance)
+/// are parsed inline in share_my_connection.dart's event subscription
+/// as `{state, source, timestamp}` and synthesized into this model
+/// after geo-resolution.
+///
+/// workerIdx here is the Dart-side identity counter (_workerSeq++ in
+/// the notifier), not the broflake worker index — it's a stable
+/// handle for matching accept/close pairs and cancelling pending arc
+/// removals when a peer reconnects from the same IP.
 class UnboundedConnectionEvent {
   final int state; // 1 = connected, -1 = disconnected
   final int workerIdx;
@@ -27,14 +37,6 @@ class UnboundedConnectionEvent {
     this.coordinates,
     this.isReplay = false,
   });
-
-  factory UnboundedConnectionEvent.fromJson(Map<String, dynamic> json) {
-    return UnboundedConnectionEvent(
-      state: json['state'] as int,
-      workerIdx: json['workerIdx'] as int,
-      addr: json['addr'] as String? ?? '',
-    );
-  }
 }
 
 /// Tracks live and cumulative connection counts for Unbounded.

lib/features/share_my_connection/share_my_connection.dart

@@ -974,8 +974,13 @@ class _GlobeViewState extends ConsumerState<_GlobeView> {
         final radius =
             min(constraints.maxWidth, constraints.maxHeight) / 2 * 0.7;
         return ClipRect(
+          // copyWith preserves the inherited devicePixelRatio,
+          // textScaleFactor, padding/insets etc. — constructing
+          // MediaQueryData from scratch with just `size:` would drop
+          // those, breaking high-DPI rendering (pixel ratio falls to
+          // 1.0) and accessibility scaling for the globe subtree.
           child: MediaQuery(
-            data: MediaQueryData(size: widgetSize),
+            data: MediaQuery.of(context).copyWith(size: widgetSize),
             child: Stack(
               children: [
                 Positioned.fill(