styly-netsync-server 0.14.0__tar.gz → 0.15.0__tar.gz

{styly_netsync_server-0.14.0 → styly_netsync_server-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.14.0
+Version: 0.15.0
 Summary: STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences
 Author-email: "STYLY, Inc." <info@styly.inc>
 License-Expression: Apache-2.0
@@ -81,13 +81,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 5`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V5 pose body.
-- v5 adds an optional `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
-- Unbound v5 poses keep the v4 `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion.
+- Current wire protocol is `protocolVersion = 7`.
+- Transport uses three sockets: control (`control_port`, default `5555`) for RPC, Network Variables, ownership, ID mapping, and client hello; transform uplink (`transform_port`, default `5557`) for client/object poses; PUB/SUB (`pub_port`, default `5556`) for room pose and room object downlink.
+- Discovery responses use `STYLY-NETSYNC2|controlPort|transformPort|pubPort|serverName`; legacy `STYLY-NETSYNC|...` responses are explicitly incompatible.
+- `dealer_port` / `--dealer-port` remain a one-release compatibility alias for `control_port` / `--control-port`.
+- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact pose body. Clients register control identity with `MSG_CLIENT_HELLO` (19).
+- Moving-floor-local poses set the `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
+- Unbound poses keep the `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes), so receivers can reconstruct the sender's rig-Y motion.
 - Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v5 position quantization ranges:
+- Protocol v7 position quantization ranges:
   - Absolute (`headPosAbs` only): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
   - XROrigin locomotion delta for unbound poses (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
   - Direct physical payload for moving-floor-local poses (`physical`, 4×`int16`: `x, y, z, yaw`): `0.01 m` per unit for translation, `0.1°` for yaw.
@@ -98,7 +101,7 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 The following options summarize trade-offs when expanding absolute-position range.
 
-Assumed unbound baseline (`protocolVersion=5`, `MovingFloorLocal` off):
+Assumed unbound baseline (`protocolVersion=7`, `MovingFloorLocal` off):
 - Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `46 bytes` (matches `test_client_body_size_with_full_pose_no_virtuals`).
 - Room per-client entry (`clientNo + poseTime + clientBody`): `56 bytes`.
 
@@ -267,4 +270,4 @@ The response includes the room ID and whether each key was `"applied"`, `"queued
 
 ### Read consistency
 
-GET endpoints return a snapshot of the REST bridge's in-process cache, which is populated by PUB-SUB broadcasts from the server. The first request to a room lazily creates a bridge and may return an empty snapshot until the initial broadcasts arrive — retry after a short delay if needed.
+GET endpoints return a snapshot of the REST bridge's in-process cache, which is populated by control-lane sync messages from the server. The first request to a room lazily creates a bridge and may return an empty snapshot until the initial sync arrives — retry after a short delay if needed.

{styly_netsync_server-0.14.0 → styly_netsync_server-0.15.0}/README.md

@@ -42,13 +42,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 5`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V5 pose body.
-- v5 adds an optional `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
-- Unbound v5 poses keep the v4 `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion.
+- Current wire protocol is `protocolVersion = 7`.
+- Transport uses three sockets: control (`control_port`, default `5555`) for RPC, Network Variables, ownership, ID mapping, and client hello; transform uplink (`transform_port`, default `5557`) for client/object poses; PUB/SUB (`pub_port`, default `5556`) for room pose and room object downlink.
+- Discovery responses use `STYLY-NETSYNC2|controlPort|transformPort|pubPort|serverName`; legacy `STYLY-NETSYNC|...` responses are explicitly incompatible.
+- `dealer_port` / `--dealer-port` remain a one-release compatibility alias for `control_port` / `--control-port`.
+- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact pose body. Clients register control identity with `MSG_CLIENT_HELLO` (19).
+- Moving-floor-local poses set the `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
+- Unbound poses keep the `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes), so receivers can reconstruct the sender's rig-Y motion.
 - Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v5 position quantization ranges:
+- Protocol v7 position quantization ranges:
   - Absolute (`headPosAbs` only): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
   - XROrigin locomotion delta for unbound poses (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
   - Direct physical payload for moving-floor-local poses (`physical`, 4×`int16`: `x, y, z, yaw`): `0.01 m` per unit for translation, `0.1°` for yaw.
@@ -59,7 +62,7 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 The following options summarize trade-offs when expanding absolute-position range.
 
-Assumed unbound baseline (`protocolVersion=5`, `MovingFloorLocal` off):
+Assumed unbound baseline (`protocolVersion=7`, `MovingFloorLocal` off):
 - Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `46 bytes` (matches `test_client_body_size_with_full_pose_no_virtuals`).
 - Room per-client entry (`clientNo + poseTime + clientBody`): `56 bytes`.
 
@@ -228,4 +231,4 @@ The response includes the room ID and whether each key was `"applied"`, `"queued
 
 ### Read consistency
 
-GET endpoints return a snapshot of the REST bridge's in-process cache, which is populated by PUB-SUB broadcasts from the server. The first request to a room lazily creates a bridge and may return an empty snapshot until the initial broadcasts arrive — retry after a short delay if needed.
+GET endpoints return a snapshot of the REST bridge's in-process cache, which is populated by control-lane sync messages from the server. The first request to a room lazily creates a bridge and may return an empty snapshot until the initial sync arrives — retry after a short delay if needed.

{styly_netsync_server-0.14.0 → styly_netsync_server-0.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "styly-netsync-server"
-version = "0.14.0"
+version = "0.15.0"
 description = "STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences"
 readme = "README.md"
 requires-python = ">=3.11"

{styly_netsync_server-0.14.0 → styly_netsync_server-0.15.0}/src/styly_netsync/__init__.py

@@ -16,7 +16,7 @@ Examples:
 
     # Use server programmatically
     from styly_netsync import NetSyncServer
-    server = NetSyncServer(dealer_port=5555, pub_port=5556)
+    server = NetSyncServer(control_port=5555, transform_port=5557, pub_port=5556)
     server.start()
 
     # Use client programmatically

{styly_netsync_server-0.14.0 → styly_netsync_server-0.15.0}/src/styly_netsync/binary_serializer.py

@@ -6,10 +6,11 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 # Message type identifiers
-# v6: Network Variable wire messages dropped the per-write timestamp field.
+# v7: Control and transform traffic use separate sockets, and clients register
+# their control identity with MSG_CLIENT_HELLO.
 # Bumped so mixed old/new builds fail the handshake instead of silently
 # misparsing NV traffic (the version byte rides on transform/object messages).
-PROTOCOL_VERSION = 6
+PROTOCOL_VERSION = 7
 MSG_CLIENT_TRANSFORM = 1
 MSG_ROOM_TRANSFORM = 2  # Legacy room transform with short IDs only
 MSG_RPC = 3  # Remote procedure call
@@ -28,6 +29,9 @@ MSG_OBJECT_OWNERSHIP_REQUEST = 15  # Client → Server: RequestOwnership/Release
 MSG_OBJECT_OWNERSHIP_CHANGED = 16  # Server → Clients (ROUTER): ownership changed
 MSG_OBJECT_OWNERSHIP_REJECTED = 17  # Server → Client (ROUTER): request rejected
 MSG_CLIENT_VAR_CLEAR = 18  # Clear all client variables for the sender
+MSG_CLIENT_HELLO = 19  # Client → Server: bind control identity to device ID
+
+CLIENT_HELLO_FLAG_STEALTH = 0x01
 
 # Transform data type identifiers (deprecated - kept for reference)
 
@@ -36,7 +40,7 @@ MSG_CLIENT_VAR_CLEAR = 18  # Clear all client variables for the sender
 _max_virtual_transforms = 50
 MAX_VIRTUAL_TRANSFORMS = _max_virtual_transforms  # Legacy alias for backward compat
 
-# Protocol v5 transform encoding constants
+# Protocol v7 pose encoding constants
 ABS_POS_SCALE = 0.01
 LOCO_POS_SCALE = 0.01
 REL_POS_SCALE = 0.005
@@ -632,6 +636,17 @@ def serialize_rpc_message(data: dict[str, Any]) -> bytes:
     return bytes(buffer)
 
 
+def serialize_client_hello(device_id: str, is_stealth: bool = False) -> bytes:
+    """Serialize client hello for control-lane identity registration."""
+    buffer = bytearray()
+    buffer.append(MSG_CLIENT_HELLO)
+    buffer.append(PROTOCOL_VERSION)
+    flags = CLIENT_HELLO_FLAG_STEALTH if is_stealth else 0
+    buffer.append(flags)
+    _pack_string(buffer, device_id)
+    return bytes(buffer)
+
+
 def parse_version(version_str: str) -> tuple[int, int, int]:
     """Parse semantic version string into (major, minor, patch) tuple.
 
@@ -825,7 +840,7 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
     offset += 1
 
     # Validate message type is within valid range
-    if message_type < MSG_CLIENT_TRANSFORM or message_type > MSG_CLIENT_VAR_CLEAR:
+    if message_type < MSG_CLIENT_TRANSFORM or message_type > MSG_CLIENT_HELLO:
         # Return invalid message type with None data instead of raising exception
         return message_type, None, b""
 
@@ -856,6 +871,8 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
             return message_type, _deserialize_client_var_sync(data, offset), b""
         elif message_type == MSG_CLIENT_VAR_CLEAR:
             return message_type, _deserialize_client_var_clear(data, offset), b""
+        elif message_type == MSG_CLIENT_HELLO:
+            return message_type, _deserialize_client_hello(data, offset), b""
         elif message_type == MSG_OBJECT_POSE:
             return message_type, _deserialize_object_pose(data, offset), b""
         elif message_type == MSG_ROOM_OBJECTS:
@@ -890,6 +907,22 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
         return message_type, None, b""
 
 
+def _deserialize_client_hello(data: bytes, offset: int) -> dict[str, Any]:
+    """Deserialize client hello control message."""
+    protocol_version = data[offset]
+    offset += 1
+    if protocol_version != PROTOCOL_VERSION:
+        raise ValueError(f"Unsupported protocol version: {protocol_version}")
+    flags = data[offset]
+    offset += 1
+    device_id, offset = _unpack_string(data, offset)
+    return {
+        "deviceId": device_id,
+        "flags": flags,
+        "isStealthMode": bool(flags & CLIENT_HELLO_FLAG_STEALTH),
+    }
+
+
 def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any], int]:
     """Deserialize protocol v5 compact pose body."""
     result: dict[str, Any] = {}
@@ -1336,6 +1369,10 @@ def serialize_object_pose(data: dict[str, Any]) -> bytes:
     buffer = bytearray()
     buffer.append(MSG_OBJECT_POSE)
     buffer.append(PROTOCOL_VERSION)
+    # Sender device ID: lets the server attribute the pose by identity carried in
+    # the payload rather than the transform-lane socket identity (which a stealth
+    # owner never binds because it sends no MSG_CLIENT_POSE).
+    _pack_string(buffer, str(data.get("deviceId", "")))
     object_id = int(data.get("objectId", 0)) & 0xFFFFFFFF
     buffer.extend(struct.pack("<I", object_id))
     buffer.extend(struct.pack("<H", int(data.get("poseSeq", 0)) & 0xFFFF))
@@ -1433,6 +1470,8 @@ def _deserialize_object_pose(data: bytes, offset: int) -> dict[str, Any]:
     offset += 1
     if protocol_version != PROTOCOL_VERSION:
         raise ValueError(f"Unsupported protocol version: {protocol_version}")
+    device_id, offset = _unpack_string(data, offset)
+    result["deviceId"] = device_id
     result["objectId"] = struct.unpack("<I", data[offset : offset + 4])[0]
     offset += 4
     result["poseSeq"] = struct.unpack("<H", data[offset : offset + 2])[0]

{styly_netsync_server-0.14.0 → styly_netsync_server-0.15.0}/src/styly_netsync/client.py

@@ -9,7 +9,8 @@ Key features (mirroring Unity ConnectionManager PR #311 and #316):
 - Latest-wins transform sending: Only the most recent transform is sent
 - Control message queue with TTL expiration
 - SUB receive draining: Only process the last payload to reduce CPU
-- DEALER receive for control messages from server (ROUTER unicast)
+    - Separate control and transform DEALER sockets
+    - DEALER receive for control messages from server (ROUTER unicast)
 """
 
 import json
@@ -36,7 +37,6 @@ from . import binary_serializer
 from .adapters import (
     client_transform_from_wire,
     client_transform_to_wire,
-    create_stealth_transform,
     is_stealth_transform,
 )
 from .events import EventHandler
@@ -140,6 +140,7 @@ class net_sync_manager:
         self,
         server: str = "tcp://localhost",
         dealer_port: int = 5555,
+        transform_port: int | None = None,
         sub_port: int = 5556,
         room: str = "default_room",
         auto_dispatch: bool = True,
@@ -152,7 +153,8 @@ class net_sync_manager:
 
         Args:
             server: ZeroMQ base address (e.g., "tcp://localhost")
-            dealer_port: Server ROUTER port for uplink
+            dealer_port: Deprecated alias for the server control ROUTER port
+            transform_port: Server ROUTER port for transform uplink
             sub_port: Server PUB port for downlink
             room: Room topic to subscribe to
             auto_dispatch: If True, callbacks fire on receive thread
@@ -162,17 +164,21 @@ class net_sync_manager:
                 (default: 30.0; pass None to disable silence detection)
         """
         self._server = server
-        self._dealer_port = dealer_port
+        self._control_port = dealer_port
+        self._dealer_port = self._control_port  # Deprecated compatibility alias
+        self._transform_port = (
+            transform_port if transform_port is not None else self._control_port + 2
+        )
         self._sub_port = sub_port
         self._room = room
         self._auto_dispatch = auto_dispatch
-        self._queue_max = queue_max
         self._reconnect_delay = reconnect_delay
         self._receive_timeout = receive_timeout
 
         # ZeroMQ context and sockets
         self._context: zmq.Context | None = None
         self._dealer_socket: zmq.Socket | None = None
+        self._transform_socket: zmq.Socket | None = None
         self._sub_socket: zmq.Socket | None = None
 
         # Threading
@@ -225,6 +231,7 @@ class net_sync_manager:
         # Priority-based sending (mirroring Unity ConnectionManager)
         # Control messages (RPC, NV) have priority over transforms
         self._ctrl_outbox: Queue[OutboundPacket] = Queue(maxsize=256)
+        self._pending_control: OutboundPacket | None = None
         self._latest_transform: OutboundPacket | None = None
         self._transform_lock = threading.Lock()
 
@@ -321,9 +328,19 @@ class net_sync_manager:
 
     @property
     def dealer_port(self) -> int:
-        """Dealer port."""
+        """Deprecated alias for the control port."""
         return self._dealer_port
 
+    @property
+    def control_port(self) -> int:
+        """Control socket port."""
+        return self._control_port
+
+    @property
+    def transform_port(self) -> int:
+        """Transform uplink socket port."""
+        return self._transform_port
+
     @property
     def sub_port(self) -> int:
         """Subscriber port."""
@@ -339,18 +356,22 @@ class net_sync_manager:
                 # Initialize ZeroMQ
                 self._context = zmq.Context()
 
-                # DEALER socket for uplink and control message receive
+                # DEALER socket for control uplink and control message receive
                 self._dealer_socket = self._context.socket(zmq.DEALER)
                 self._dealer_socket.setsockopt(zmq.LINGER, 0)
-                self._dealer_socket.setsockopt(
-                    zmq.SNDHWM, 10
-                )  # Low HWM for backpressure
-                self._dealer_socket.setsockopt(
-                    zmq.RCVHWM, 10
-                )  # Bound receive queue for control messages
+                self._dealer_socket.setsockopt(zmq.SNDHWM, 1024)
+                self._dealer_socket.setsockopt(zmq.RCVHWM, 1024)
                 self._dealer_socket.setsockopt(zmq.RCVTIMEO, 0)  # Non-blocking receive
-                dealer_addr = self._build_connect_addr(self._dealer_port)
-                self._dealer_socket.connect(dealer_addr)
+                control_addr = self._build_connect_addr(self._control_port)
+                self._dealer_socket.connect(control_addr)
+
+                # DEALER socket for transform uplink only. Low HWM preserves
+                # latest-wins freshness under slow receivers.
+                self._transform_socket = self._context.socket(zmq.DEALER)
+                self._transform_socket.setsockopt(zmq.LINGER, 0)
+                self._transform_socket.setsockopt(zmq.SNDHWM, 2)
+                transform_addr = self._build_connect_addr(self._transform_port)
+                self._transform_socket.connect(transform_addr)
 
                 # SUB socket for downlink (transform broadcasts)
                 # Low RCVHWM (2) to prefer recent updates and drop stale messages
@@ -361,6 +382,8 @@ class net_sync_manager:
                 self._sub_socket.connect(sub_addr)
                 self._sub_socket.setsockopt(zmq.SUBSCRIBE, self._room.encode("utf-8"))
 
+                self._enqueue_client_hello(is_stealth=False)
+
                 # Start receive thread
                 self._running = True
                 self._reconnect_at = None  # Clear stale reconnect state
@@ -371,7 +394,8 @@ class net_sync_manager:
                 self._receive_thread.start()
 
                 logger.info(
-                    f"NetSync client started: {dealer_addr}, {sub_addr}, room={self._room}"
+                    "NetSync client started: "
+                    f"{control_addr}, {transform_addr}, {sub_addr}, room={self._room}"
                 )
 
             except Exception as e:
@@ -416,6 +440,9 @@ class net_sync_manager:
         if self._dealer_socket:
             self._dealer_socket.close()
             self._dealer_socket = None
+        if self._transform_socket:
+            self._transform_socket.close()
+            self._transform_socket = None
         if self._sub_socket:
             self._sub_socket.close()
             self._sub_socket = None
@@ -470,7 +497,7 @@ class net_sync_manager:
         logger.info("Attempting socket reconnect...")
 
         # Close old sockets
-        for sock_attr in ("_dealer_socket", "_sub_socket"):
+        for sock_attr in ("_dealer_socket", "_transform_socket", "_sub_socket"):
             sock = getattr(self, sock_attr, None)
             if sock is not None:
                 try:
@@ -488,14 +515,21 @@ class net_sync_manager:
                 return False
 
         try:
-            # DEALER socket (same options as start())
+            # Control DEALER socket (same options as start())
             self._dealer_socket = self._context.socket(zmq.DEALER)
             self._dealer_socket.setsockopt(zmq.LINGER, 0)
-            self._dealer_socket.setsockopt(zmq.SNDHWM, 10)
-            self._dealer_socket.setsockopt(zmq.RCVHWM, 10)
+            self._dealer_socket.setsockopt(zmq.SNDHWM, 1024)
+            self._dealer_socket.setsockopt(zmq.RCVHWM, 1024)
             self._dealer_socket.setsockopt(zmq.RCVTIMEO, 0)
-            dealer_addr = self._build_connect_addr(self._dealer_port)
-            self._dealer_socket.connect(dealer_addr)
+            control_addr = self._build_connect_addr(self._control_port)
+            self._dealer_socket.connect(control_addr)
+
+            # Transform DEALER socket (same options as start())
+            self._transform_socket = self._context.socket(zmq.DEALER)
+            self._transform_socket.setsockopt(zmq.LINGER, 0)
+            self._transform_socket.setsockopt(zmq.SNDHWM, 2)
+            transform_addr = self._build_connect_addr(self._transform_port)
+            self._transform_socket.connect(transform_addr)
 
             # SUB socket (same options as start())
             self._sub_socket = self._context.socket(zmq.SUB)
@@ -510,9 +544,11 @@ class net_sync_manager:
 
             logger.info(
                 f"Reconnected (#{self._stats['reconnect_count']}): "
-                f"{dealer_addr}, {sub_addr}, room={self._room}"
+                f"{control_addr}, {transform_addr}, {sub_addr}, room={self._room}"
             )
 
+            self._enqueue_client_hello(is_stealth=self._is_stealth_mode)
+
             # Restart discovery if it was active before the connection error
             if self._discovery_port is not None:
                 self.start_discovery(self._discovery_port)
@@ -522,7 +558,7 @@ class net_sync_manager:
         except Exception as e:
             logger.error(f"Socket reconnect failed: {e}")
             # Cleanup partial setup
-            for sock_attr in ("_dealer_socket", "_sub_socket"):
+            for sock_attr in ("_dealer_socket", "_transform_socket", "_sub_socket"):
                 sock = getattr(self, sock_attr, None)
                 if sock is not None:
                     try:
@@ -540,6 +576,7 @@ class net_sync_manager:
                 self._ctrl_outbox.get_nowait()
             except Empty:
                 break
+        self._pending_control = None
 
         # Clear latest transform
         with self._transform_lock:
@@ -759,7 +796,7 @@ class net_sync_manager:
 
         # Priority-based send drain:
         # 1. Drain control messages first (higher priority)
-        # 2. Then try to send latest transform (lower priority)
+        # 2. Then try to send latest transform through transform socket
         did_work |= self._drain_control_sends()
         did_work |= self._try_send_latest_transform()
 
@@ -778,41 +815,34 @@ class net_sync_manager:
         now = time.monotonic()
 
         while sent < self._ctrl_drain_batch:
-            try:
-                packet = self._ctrl_outbox.get_nowait()
-            except Empty:
-                break
+            if self._pending_control is not None:
+                packet = self._pending_control
+            else:
+                try:
+                    packet = self._ctrl_outbox.get_nowait()
+                except Empty:
+                    break
 
             # TTL check - skip expired packets
             if now - packet.enqueued_at > self._ctrl_ttl_seconds:
                 logger.warning(
                     f"Control packet expired (TTL {self._ctrl_ttl_seconds}s exceeded)"
                 )
+                self._pending_control = None
                 continue
 
             # Try to send
-            outcome = self._try_send_dealer(packet.room_id, packet.payload)
+            outcome = self._try_send_socket(
+                self._dealer_socket, packet.room_id, packet.payload
+            )
             if outcome.is_sent:
+                self._pending_control = None
                 did_work = True
                 sent += 1
             elif outcome.is_backpressure:
-                # Backpressure - increment counter and attempt to re-queue the packet
                 with self._lock:
                     self._stats["would_block_count"] += 1
-                try:
-                    # Re-queue the control packet so it can be retried later
-                    self._ctrl_outbox.put_nowait(packet)
-                except Full:
-                    # Queue is full: this control packet is dropped; log prominently
-                    with self._lock:
-                        self._stats["ctrl_queue_drops"] += 1
-                    logger.warning(
-                        "Control packet dropped due to backpressure and full queue; "
-                        "would_block=%s, queue_drops=%s",
-                        self._stats.get("would_block_count"),
-                        self._stats.get("ctrl_queue_drops"),
-                    )
-                # Stop draining on backpressure to respect socket backpressure signal
+                self._pending_control = packet
                 break
             else:
                 # Fatal error
@@ -826,7 +856,7 @@ class net_sync_manager:
 
         Returns True if a transform was sent.
         """
-        if not self._dealer_socket:
+        if not self._transform_socket:
             return False
 
         with self._transform_lock:
@@ -835,7 +865,9 @@ class net_sync_manager:
                 return False
 
             # Try to send
-            outcome = self._try_send_dealer(packet.room_id, packet.payload)
+            outcome = self._try_send_socket(
+                self._transform_socket, packet.room_id, packet.payload
+            )
             if outcome.is_sent:
                 # Success - clear the packet
                 self._latest_transform = None
@@ -850,17 +882,19 @@ class net_sync_manager:
                 logger.error(f"Fatal send error: {outcome.error}")
                 return False
 
-    def _try_send_dealer(self, room_id: str, payload: bytes) -> SendOutcome:
-        """Try to send a message via DEALER socket.
+    def _try_send_socket(
+        self, socket_obj: zmq.Socket | None, room_id: str, payload: bytes
+    ) -> SendOutcome:
+        """Try to send a message via a DEALER socket.
 
         Returns SendOutcome indicating success, backpressure, or fatal error.
         """
-        if not self._dealer_socket:
+        if not socket_obj:
             return SendOutcome.fatal("Socket not available")
 
         try:
             # Use NOBLOCK to detect backpressure
-            self._dealer_socket.send_multipart(
+            socket_obj.send_multipart(
                 [room_id.encode("utf-8"), payload], flags=zmq.NOBLOCK
             )
             return SendOutcome.sent()
@@ -1109,7 +1143,7 @@ class net_sync_manager:
         Only the most recent transform is retained. Calling this multiple times
         before the network thread sends will only send the last one.
         """
-        if not self._running or not self._dealer_socket:
+        if not self._running or not self._transform_socket:
             return False
 
         try:
@@ -1146,20 +1180,14 @@ class net_sync_manager:
         return result
 
     def _send_stealth_heartbeat(self) -> bool:
-        """Serialize and enqueue one stealth heartbeat packet.
+        """Serialize and enqueue one stealth control hello packet.
 
-        Uses the control queue (matching Unity's TryEnqueueControl for stealth handshakes).
+        Uses the control queue so stealth clients maintain membership without
+        sending pose-shaped transform payloads.
         Updates _last_stealth_heartbeat_time on success to drive the 1 Hz interval.
         """
-        stealth_tx = create_stealth_transform()
-        stealth_tx.device_id = self._device_id
-
         try:
-            wire_data = client_transform_to_wire(stealth_tx)
-            message = binary_serializer.serialize_client_transform(wire_data)
-            result = self._enqueue_control(
-                self._room, message, msg_type="stealth_heartbeat"
-            )
+            result = self._enqueue_client_hello(is_stealth=True)
             if result:
                 self._last_stealth_heartbeat_time = time.monotonic()
             return result
@@ -1304,6 +1332,13 @@ class net_sync_manager:
             )
             return False
 
+    def _enqueue_client_hello(self, is_stealth: bool) -> bool:
+        """Enqueue a client hello control message."""
+        message = binary_serializer.serialize_client_hello(
+            self._device_id, is_stealth=is_stealth
+        )
+        return self._enqueue_control(self._room, message, msg_type="client_hello")
+
     def get_global_variable(self, name: str, default: str | None = None) -> str | None:
         """Get global variable from local cache."""
         return self._global_variables.get(name, default)
@@ -1577,26 +1612,32 @@ class net_sync_manager:
                         data, addr = sock.recvfrom(1024)
                         response = data.decode("utf-8")
 
-                        if response.startswith("STYLY-NETSYNC|"):
+                        if response.startswith("STYLY-NETSYNC2|"):
                             parts = response.split("|")
-                            if len(parts) >= 4:
-                                dealer_port = int(parts[1])
-                                sub_port = int(parts[2])
-                                server_name = parts[3]
+                            if len(parts) >= 5:
+                                control_port = int(parts[1])
+                                transform_port = int(parts[2])
+                                sub_port = int(parts[3])
+                                server_name = parts[4]
 
                                 logger.info(
                                     f"Discovered server: {server_name} at "
-                                    f"{addr[0]}:{dealer_port}/{sub_port}"
+                                    f"{addr[0]}:{control_port}/{transform_port}/{sub_port}"
                                 )
                                 server_address = f"tcp://{addr[0]}"
                                 self.on_server_discovered.invoke(
-                                    server_address, dealer_port, sub_port
+                                    server_address,
+                                    control_port,
+                                    transform_port,
+                                    sub_port,
                                 )
 
                                 # Auto-connect after discovery
                                 if not self._running:
                                     self._server = server_address
-                                    self._dealer_port = dealer_port
+                                    self._control_port = control_port
+                                    self._dealer_port = control_port
+                                    self._transform_port = transform_port
                                     self._sub_port = sub_port
                                     try:
                                         self.start()
@@ -1608,6 +1649,11 @@ class net_sync_manager:
                                         break
                                 self._stop_discovery_internal()
                                 return
+                        elif response.startswith("STYLY-NETSYNC|"):
+                            logger.warning(
+                                "Ignoring incompatible legacy discovery response from %s",
+                                addr[0],
+                            )
                     except TimeoutError:
                         pass
                     except Exception: