feat(online): validate end-to-end handshake

.agents/lessons-learned.md

@@ -25,3 +25,4 @@ fact.
 2026-07-21: A Harmony POSTFIX on the game load method cannot stall the loading screen: it runs only after the load method returns, so a stuck load means the hook never fired (a fired-but-slow postfix would show as a hang after the screen clears, not a frozen loading screen). Still, wrap the event invoke in try/catch so a subscriber exception can never propagate back into the game's load and abort it.
 2026-07-22: Bash fixture runners must remove CR from .env input before sourcing because Windows checkout conversion otherwise leaves carriage returns in exported values under POSIX shells.
 2026-07-22: SaveLoadManager.readyToSave is the common static world-ready marker set by both StartMenu new-game and continue coroutines; LoadGame runs only for continue, so API readiness must poll readyToSave rather than depend on the LoadGame postfix.
+2026-07-24: LiteNetLib 1.3.1 connected packets use a two-bit ConnectionNumber: stale mismatches are rejected before liveness or state handling, while user data, Ping, Pong, and Disconnect carry the active number.

packages/net/Sailwind.Online.Net/ITransport.cs

@@ -20,14 +20,26 @@ public interface ITransport
         /// <summary>True while the current peer is fully connected, i.e. safe to send on.</summary>
         bool IsPeerConnected { get; }
 
+        /// <summary>
+        /// Maximum payload bytes the current peer can send as one unreliable packet, or zero when
+        /// there is no current peer.
+        /// </summary>
+        int MaxUnreliablePayloadSize { get; }
+
         /// <summary>Round-trip estimate in milliseconds for the current peer, or -1 when there is none.</summary>
         int Ping { get; }
 
         /// <summary>Bring the manager up. Returns false when the socket cannot bind.</summary>
         bool Start();
 
-        /// <summary>Open (or re-open) the single peer to <paramref name="host"/>:<paramref name="port"/> with the connect key.</summary>
-        void Connect(string host, int port, string key);
+        /// <summary>
+        /// Open (or keep opening) the single peer to <paramref name="host"/>:<paramref name="port"/>
+        /// with the connect key. Returns true when a current peer exists after the attempt.
+        /// </summary>
+        bool Connect(string host, int port, string key);
+
+        /// <summary>Immediately drop the current peer without reporting a network-originated disconnect.</summary>
+        void DropPeer();
 
         /// <summary>Send one datagram to the current peer with the given delivery method.</summary>
         void Send(byte[] data, DeliveryMethod deliveryMethod);

packages/net/Sailwind.Online.Net/LiteNetLibTransport.cs

@@ -16,7 +16,7 @@ public sealed class LiteNetLibTransport : ITransport
     {
         private readonly EventBasedNetListener _listener = new EventBasedNetListener();
         private readonly NetManager _manager;
-        private NetPeer? _peer;
+        private readonly CurrentPeerSlot<NetPeer> _peer = new CurrentPeerSlot<NetPeer>();
 
         public LiteNetLibTransport()
         {
@@ -40,12 +40,31 @@ public bool IsRunning
 
         public bool IsPeerConnected
         {
-            get { return _peer != null && _peer.ConnectionState == ConnectionState.Connected; }
+            get
+            {
+                NetPeer? peer = _peer.Value;
+                return peer != null && peer.ConnectionState == ConnectionState.Connected;
+            }
+        }
+
+        public int MaxUnreliablePayloadSize
+        {
+            get
+            {
+                NetPeer? peer = _peer.Value;
+                return peer != null
+                    ? peer.GetMaxSinglePacketSize(DeliveryMethod.Unreliable)
+                    : 0;
+            }
         }
 
         public int Ping
         {
-            get { return _peer != null ? _peer.Ping : -1; }
+            get
+            {
+                NetPeer? peer = _peer.Value;
+                return peer != null ? peer.Ping : -1;
+            }
         }
 
         public event Action? PeerConnected;
@@ -58,14 +77,25 @@ public bool Start()
             return _manager.Start();
         }
 
-        public void Connect(string host, int port, string key)
+        public bool Connect(string host, int port, string key)
+        {
+            return _peer.SetIfPresent(_manager.Connect(host, port, key));
+        }
+
+        public void DropPeer()
         {
-            _peer = _manager.Connect(host, port, key);
+            NetPeer? peer = _peer.Clear();
+            if (peer == null)
+            {
+                return;
+            }
+
+            _manager.DisconnectPeerForce(peer);
         }
 
         public void Send(byte[] data, DeliveryMethod deliveryMethod)
         {
-            _peer?.Send(data, deliveryMethod);
+            _peer.Value?.Send(data, deliveryMethod);
         }
 
         public void PollEvents()
@@ -80,23 +110,37 @@ public void Stop()
                 _manager.Stop();
             }
 
-            _peer = null;
+            _peer.Clear();
         }
 
         private void OnPeerConnected(NetPeer peer)
         {
-            _peer = peer;
+            if (!_peer.IsCurrent(peer))
+            {
+                return;
+            }
+
             PeerConnected?.Invoke();
         }
 
         private void OnPeerDisconnected(NetPeer peer, DisconnectInfo info)
         {
-            _peer = null;
+            if (!_peer.TryClear(peer))
+            {
+                return;
+            }
+
             PeerDisconnected?.Invoke(info.Reason.ToString());
         }
 
         private void OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channelNumber, DeliveryMethod deliveryMethod)
         {
+            if (!_peer.IsCurrent(peer))
+            {
+                reader.Recycle();
+                return;
+            }
+
             byte[] data = reader.GetRemainingBytes();
             reader.Recycle();
             NetworkReceive?.Invoke(data);
@@ -107,4 +151,48 @@ private void OnNetworkError(IPEndPoint endPoint, SocketError socketError)
             NetworkError?.Invoke(endPoint, socketError);
         }
     }
+
+    internal sealed class CurrentPeerSlot<TPeer>
+        where TPeer : class
+    {
+        private TPeer? _value;
+
+        public TPeer? Value
+        {
+            get { return _value; }
+        }
+
+        public bool SetIfPresent(TPeer peer)
+        {
+            if (peer != null)
+            {
+                _value = peer;
+            }
+
+            return _value != null;
+        }
+
+        public TPeer? Clear()
+        {
+            TPeer? peer = _value;
+            _value = null;
+            return peer;
+        }
+
+        public bool IsCurrent(TPeer peer)
+        {
+            return ReferenceEquals(_value, peer);
+        }
+
+        public bool TryClear(TPeer peer)
+        {
+            if (!IsCurrent(peer))
+            {
+                return false;
+            }
+
+            _value = null;
+            return true;
+        }
+    }
 }