From 2d903d45992569d98aefa1b1ea32c5e5c3a9bb20 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Sat, 22 Feb 2025 14:58:56 +0200
Subject: [PATCH 01/14] Store connected clients and their data as entities

---
 CHANGELOG.md                                  |  18 +
 Cargo.toml                                    |   1 -
 .../examples/simple_box.rs                    | 110 +++--
 .../examples/tic_tac_toe.rs                   | 130 ++++--
 bevy_replicon_example_backend/src/client.rs   |  16 +-
 bevy_replicon_example_backend/src/server.rs   |  47 +-
 .../tests/backend.rs                          |   7 +-
 src/client/diagnostics.rs                     |   8 +-
 src/core.rs                                   |  74 ++--
 src/core/connected_clients.rs                 | 131 ------
 src/core/event/client_event.rs                |  19 +-
 src/core/event/client_trigger.rs              |  12 +-
 src/core/event/server_event.rs                | 104 +++--
 src/core/event/server_trigger.rs              |   6 +-
 src/core/replication.rs                       |   2 +-
 src/core/replication/client_ticks.rs          | 161 +++++++
 src/core/replication/replicated_clients.rs    | 400 ------------------
 .../replication_registry/test_fns.rs          |   2 +-
 src/core/replicon_client.rs                   | 106 +----
 src/core/replicon_server.rs                   |  29 +-
 src/lib.rs                                    |  62 ++-
 src/server.rs                                 | 339 +++++++--------
 src/server/client_entity_map.rs               |  42 +-
 .../client_visibility.rs                      |  87 ++--
 src/server/event.rs                           |  12 +-
 src/server/replication_messages.rs            |  43 --
 .../replication_messages/mutate_message.rs    |  17 +-
 .../replication_messages/serialized_data.rs   |  21 +-
 .../replication_messages/update_message.rs    |  19 +-
 src/test_app.rs                               |  70 ++-
 tests/connection.rs                           |  69 +--
 tests/despawn.rs                              |   4 +-
 tests/insertion.rs                            |  43 +-
 tests/mutations.rs                            | 119 ++++--
 tests/removal.rs                              |  26 +-
 tests/server_event.rs                         |  53 ++-
 tests/spawn.rs                                |  28 +-
 tests/stats.rs                                |  22 +-
 tests/visibility.rs                           |  91 ++--
 39 files changed, 1026 insertions(+), 1524 deletions(-)
 delete mode 100644 src/core/connected_clients.rs
 create mode 100644 src/core/replication/client_ticks.rs
 delete mode 100644 src/core/replication/replicated_clients.rs
 rename src/{core/replication/replicated_clients => server}/client_visibility.rs (89%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d7fbf1e8..fc8dcac8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,9 +11,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Derive `Debug` for `FnsId`.
 - Derive `Deref` and `DerefMut` to underlying event in `ToClients` and `FromClient`.
+- Derive `PartialEq` for `RepliconClientStatus`.
 
 ### Changed
 
+- Connected clients are now represented as entities with `ConnectedClient` components. Backends are responsible for spawning and despawning entities with this component.
+- Statistics for connected clients now accessible via `ClientStats` component.
+- Replicated entities now represented by connected clients with `ReplicatedClient` component.
+- To access visibility, use `ClientVisibility` component on replicated entities.
+- `ServerEntityMap` resource now a component on replicated entities. It now accepts entity to entity mappings directly instead of `ClientId` to `ClientMapping`.
+- Replace statistic methods on `RepliconClient` with `RepliconClient::stats()` method that returns `ClientStats` struct.
+- Move `VisibilityPolicy` to `server` module.
+- Use `TestClientEntity` instead of `ClientId` resource on clients in `ServerTestAppExt` to identify client entity.
+- Rename `FromClient::client_id` into `FromClient::client_entity`.
 - Replace `bincode` with `postcard`. It has more suitable variable integer encoding and potentially unlocks `no_std` support. If you use custom ser/de functions, replace `DefaultOptions::new().serialize_into(message, event)` with `postcard_utils::to_extend_mut(event, message)` and `DefaultOptions::new().deserialize_from(cursor)` with `postcard_utils::from_buf(message)`.
 - All serde methods now use `postcard::Result` instead of `bincode::Result`.
 - All deserialization methods now accept `Bytes` instead of `std::io::Cursor` because deserialization from `std::io::Read` requires a temporary buffer. `Bytes` already provide cursor-like functionality. The crate now re-exported under `bevy_replicon::bytes`.
@@ -26,6 +36,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Local re-trigger for listen server mode.
 
+### Removed
+
+- `ClientId`. Replicon doesn't need to know what backends use as client identifiers and now just uses `Entity` to refer to a connected client everywhere. Use `Entity::PLACEHOLDER` to refer to a server.
+- `StartReplication` trigger. Just insert `ReplicatedClient` to enable replication.
+- `ConnectedClients` and `ReplicatedClients` resources. Use components on connected clients instead.
+- `ClientConnected` and `ClientDisconnected` triggers. Just observe for `Trigger<OnAdd, ConnectedClient>` or `Trigger<OnRemove, ConnectedClient>`. To get disconnect reason, obtain it from the ued backend.
+- `ServerSet::TriggerConnectionEvents` variant. We no longer use events for connections.
+
 ## [0.30.1] - 2025-02-07
 
 ### Fixed
diff --git a/Cargo.toml b/Cargo.toml
index b4f23457..706ed738 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,6 @@ members = ["bevy_replicon_example_backend"]
 
 [dependencies]
 bevy = { version = "0.15", default-features = false, features = ["serialize"] }
-thiserror = "2.0"
 typeid = "1.0"
 bytes = "1.10"
 serde = "1.0"
diff --git a/bevy_replicon_example_backend/examples/simple_box.rs b/bevy_replicon_example_backend/examples/simple_box.rs
index 2cfbb162..14129d87 100644
--- a/bevy_replicon_example_backend/examples/simple_box.rs
+++ b/bevy_replicon_example_backend/examples/simple_box.rs
@@ -1,7 +1,10 @@
 //! A simple demo to showcase how player could send inputs to move a box and server replicates position back.
 //! Also demonstrates the single-player and how sever also could be a player.
 
-use std::io;
+use std::{
+    hash::{DefaultHasher, Hash, Hasher},
+    io,
+};
 
 use bevy::{
     color::palettes::css::GREEN,
@@ -35,7 +38,7 @@ struct SimpleBoxPlugin;
 impl Plugin for SimpleBoxPlugin {
     fn build(&self, app: &mut App) {
         app.replicate::<BoxPosition>()
-            .replicate::<BoxColor>()
+            .replicate::<PlayerBox>()
             .add_client_trigger::<MoveBox>(ChannelKind::Ordered)
             .add_observer(spawn_clients)
             .add_observer(despawn_clients)
@@ -49,7 +52,12 @@ fn read_cli(mut commands: Commands, cli: Res<Cli>) -> io::Result<()> {
     match *cli {
         Cli::SinglePlayer => {
             info!("starting single-player game");
-            commands.spawn((BoxPlayer(ClientId::SERVER), BoxColor(GREEN.into())));
+            commands.spawn((
+                PlayerBox {
+                    color: GREEN.into(),
+                },
+                BoxOwner(Entity::PLACEHOLDER),
+            ));
         }
         Cli::Server { port } => {
             info!("starting server at port {port}");
@@ -63,15 +71,20 @@ fn read_cli(mut commands: Commands, cli: Res<Cli>) -> io::Result<()> {
                 },
                 TextColor::WHITE,
             ));
-            commands.spawn((BoxPlayer(ClientId::SERVER), BoxColor(GREEN.into())));
+            commands.spawn((
+                PlayerBox {
+                    color: GREEN.into(),
+                },
+                BoxOwner(Entity::PLACEHOLDER),
+            ));
         }
         Cli::Client { port } => {
             info!("connecting to port {port}");
             let client = ExampleClient::new(port)?;
-            let client_id = client.id()?;
+            let addr = client.local_addr()?;
             commands.insert_resource(client);
             commands.spawn((
-                Text(format!("Client: {client_id:?}")),
+                Text(format!("Client: {addr}")),
                 TextFont {
                     font_size: 30.0,
                     ..default()
@@ -89,24 +102,37 @@ fn spawn_camera(mut commands: Commands) {
 }
 
 /// Spawns a new box whenever a client connects.
-fn spawn_clients(trigger: Trigger<ClientConnected>, mut commands: Commands) {
-    // Generate pseudo random color from client id.
-    let r = ((trigger.client_id.get() % 23) as f32) / 23.0;
-    let g = ((trigger.client_id.get() % 27) as f32) / 27.0;
-    let b = ((trigger.client_id.get() % 39) as f32) / 39.0;
-    info!("spawning box for `{:?}`", trigger.client_id);
-    commands.spawn((BoxPlayer(trigger.client_id), BoxColor(Color::srgb(r, g, b))));
+fn spawn_clients(trigger: Trigger<OnAdd, ConnectedClient>, mut commands: Commands) {
+    // Hash index to generate visually distinctive color.
+    let mut hasher = DefaultHasher::new();
+    trigger.entity().index().hash(&mut hasher);
+    let hash = hasher.finish();
+
+    // Use the lower 24 bits.
+    // Divide by 255 to convert bytes into 0..1 floats.
+    let r = ((hash >> 16) & 0xFF) as f32 / 255.0;
+    let g = ((hash >> 8) & 0xFF) as f32 / 255.0;
+    let b = (hash & 0xFF) as f32 / 255.0;
+
+    // Generate pseudo random color from client entity.
+    info!("spawning box for `{:?}`", trigger.entity());
+    commands.spawn((
+        PlayerBox {
+            color: Color::srgb(r, g, b),
+        },
+        BoxOwner(trigger.entity()),
+    ));
 }
 
 /// Despawns a box whenever a client disconnects.
 fn despawn_clients(
-    trigger: Trigger<ClientDisconnected>,
+    trigger: Trigger<OnRemove, ConnectedClient>,
     mut commands: Commands,
-    boxes: Query<(Entity, &BoxPlayer)>,
+    boxes: Query<(Entity, &BoxOwner)>,
 ) {
     let (entity, _) = boxes
         .iter()
-        .find(|(_, &player)| *player == trigger.client_id)
+        .find(|(_, &owner)| *owner == trigger.entity())
         .expect("all clients should have entities");
     commands.entity(entity).despawn();
 }
@@ -139,26 +165,28 @@ fn read_input(mut commands: Commands, input: Res<ButtonInput<KeyCode>>) {
 fn apply_movement(
     trigger: Trigger<FromClient<MoveBox>>,
     time: Res<Time>,
-    mut boxes: Query<(&BoxPlayer, &mut BoxPosition)>,
+    mut boxes: Query<(&BoxOwner, &mut BoxPosition)>,
 ) {
     const MOVE_SPEED: f32 = 300.0;
-    info!("received movement from `{:?}`", trigger.client_id);
-    for (player, mut position) in &mut boxes {
-        // Find the sender entity. We don't include the entity as a trigger target to save traffic, since the server knows
-        // which entity to apply the input to. We could have a resource that maps connected clients to controlled entities,
-        // but we didn't implement it for the sake of simplicity.
-        if trigger.client_id == **player {
-            **position += *trigger.event * time.delta_secs() * MOVE_SPEED;
-        }
-    }
+    info!("received movement from `{}`", trigger.entity());
+
+    // Find the sender entity. We don't include the entity as a trigger target to save traffic, since the server knows
+    // which entity to apply the input to. We could have a resource that maps connected clients to controlled entities,
+    // but we didn't implement it for the sake of simplicity.
+    let (_, mut position) = boxes
+        .iter_mut()
+        .find(|(&owner, _)| *owner == trigger.client_entity)
+        .unwrap_or_else(|| panic!("`{}` should be connected", trigger.client_entity));
+
+    **position += *trigger.event * time.delta_secs() * MOVE_SPEED;
 }
 
-fn draw_boxes(mut gizmos: Gizmos, boxes: Query<(&BoxPosition, &BoxColor)>) {
-    for (position, color) in &boxes {
+fn draw_boxes(mut gizmos: Gizmos, boxes: Query<(&BoxPosition, &PlayerBox)>) {
+    for (position, player) in &boxes {
         gizmos.rect(
             Vec3::new(position.x, position.y, 0.0),
             Vec2::ONE * 50.0,
-            **color,
+            player.color,
         );
     }
 }
@@ -188,18 +216,30 @@ impl Default for Cli {
     }
 }
 
-/// Identifies which player controls the box.
+/// Player-controlled box.
 ///
 /// We want to replicate all boxes, so we just set [`Replicated`] as a required component.
-#[derive(Component, Clone, Copy, Deref, Serialize, Deserialize)]
-#[require(BoxPosition, BoxColor, Replicated)]
-struct BoxPlayer(ClientId);
+#[derive(Component, Deref, Deserialize, Serialize, Default)]
+#[require(BoxPosition, Replicated)]
+struct PlayerBox {
+    /// Color to visually distinguish boxes.
+    color: Color,
+}
 
+/// Position of a player-controlled box.
+///
+/// This is a separate component from [`PlayerBox`] because, when the position
+/// changes, we only want to send this component (and it changes often!).
 #[derive(Component, Deserialize, Serialize, Deref, DerefMut, Default)]
 struct BoxPosition(Vec2);
 
-#[derive(Component, Deref, Deserialize, Serialize, Default)]
-struct BoxColor(Color);
+/// Identifies which player controls the box.
+///
+/// Points to client entity. Used to apply movement to the correct box.
+///
+/// It's not replicated and present only on server or singleplayer.
+#[derive(Component, Clone, Copy, Deref)]
+struct BoxOwner(Entity);
 
 /// A movement event for the controlled box.
 #[derive(Deserialize, Deref, Event, Serialize)]
diff --git a/bevy_replicon_example_backend/examples/tic_tac_toe.rs b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
index 18871227..9c626df5 100644
--- a/bevy_replicon_example_backend/examples/tic_tac_toe.rs
+++ b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
@@ -43,9 +43,8 @@ impl Plugin for TicTacToePlugin {
             .init_resource::<SymbolFont>()
             .init_resource::<TurnSymbol>()
             .replicate::<Symbol>()
-            .replicate::<Player>()
             .add_client_trigger::<CellPick>(ChannelKind::Ordered)
-            .add_client_trigger::<MapCells>(ChannelKind::Ordered)
+            .add_client_trigger::<MapBoard>(ChannelKind::Ordered)
             .insert_resource(ClearColor(BACKGROUND_COLOR))
             .add_observer(disconnect_by_client)
             .add_observer(init_client)
@@ -97,20 +96,29 @@ fn read_cli(mut commands: Commands, cli: Res<Cli>) -> io::Result<()> {
         Cli::Hotseat => {
             info!("starting hotseat");
             // Set all players to server to play from a single machine and start the game right away.
-            commands.spawn((Player(ClientId::SERVER), Symbol::Cross));
-            commands.spawn((Player(ClientId::SERVER), Symbol::Nought));
+            commands.spawn((
+                LocalPlayer,
+                Symbol::Cross,
+                PlayerClient(Entity::PLACEHOLDER),
+            ));
+            commands.spawn((
+                LocalPlayer,
+                Symbol::Nought,
+                PlayerClient(Entity::PLACEHOLDER),
+            ));
             commands.set_state(GameState::InGame);
         }
         Cli::Server { port, symbol } => {
             info!("starting server as {symbol} at port {port}");
             let server = ExampleServer::new(port)?;
             commands.insert_resource(server);
-            commands.spawn((Player(ClientId::SERVER), symbol));
+            commands.spawn((LocalPlayer, symbol, PlayerClient(Entity::PLACEHOLDER)));
         }
         Cli::Client { port } => {
             info!("connecting to port {port}");
             let client = ExampleClient::new(port)?;
             commands.insert_resource(client);
+            commands.spawn(LocalPlayer);
         }
     }
 
@@ -244,29 +252,29 @@ fn apply_pick(
     mut commands: Commands,
     cells: Query<(Entity, &Cell)>,
     turn_symbol: Res<TurnSymbol>,
-    players: Query<(&Player, &Symbol)>,
+    players: Query<(&PlayerClient, &Symbol)>,
 ) {
     // It's good to check the received data because client could be cheating.
     if trigger.index > GRID_SIZE * GRID_SIZE {
-        debug!("received invalid cell index {:?}", trigger.index);
+        error!("received invalid cell index {}", trigger.index);
         return;
     }
 
     if !players
         .iter()
-        .any(|(&player, &symbol)| *player == trigger.client_id && symbol == **turn_symbol)
+        .any(|(&client, &symbol)| *client == trigger.client_entity && symbol == **turn_symbol)
     {
-        debug!(
-            "{:?} chose cell {:?} at wrong turn",
-            trigger.client_id, trigger.index
+        error!(
+            "`{}` chose cell {} at wrong turn",
+            trigger.client_entity, trigger.index
         );
         return;
     }
 
     let Some((entity, _)) = cells.iter().find(|(_, cell)| cell.index == trigger.index) else {
-        debug!(
-            "{:?} has chosen an already occupied cell {:?}",
-            trigger.client_id, trigger.index
+        error!(
+            "`{}` has chosen an already occupied cell {}",
+            trigger.client_entity, trigger.index
         );
         return;
     };
@@ -302,20 +310,27 @@ fn init_symbols(
         });
 }
 
-/// Sends cell entities and starts the game after successful connection.
+/// Sends cell and local player entities and starts the game.
 ///
 /// Replicon maps entities when you replicate them from server automatically.
 /// But in this game we spawn cells beforehand. So we send a special event to
 /// server to receive replication to already existing entities.
 ///
 /// Used only for client.
-fn client_start(mut commands: Commands, cells: Query<(Entity, &Cell)>) {
-    let mut entities = HashMap::new();
+fn client_start(
+    mut commands: Commands,
+    cells: Query<(Entity, &Cell)>,
+    player_entity: Single<Entity, With<LocalPlayer>>,
+) {
+    let mut cell_entities = HashMap::new();
     for (entity, cell) in &cells {
-        entities.insert(cell.index, entity);
+        cell_entities.insert(cell.index, entity);
     }
 
-    commands.client_trigger(MapCells(entities));
+    commands.client_trigger(MapBoard {
+        cell_entities,
+        player_entity: *player_entity,
+    });
     commands.set_state(GameState::InGame);
 }
 
@@ -323,38 +338,45 @@ fn client_start(mut commands: Commands, cells: Query<(Entity, &Cell)>) {
 ///
 /// Used only for server.
 fn init_client(
-    trigger: Trigger<FromClient<MapCells>>,
+    trigger: Trigger<FromClient<MapBoard>>,
     mut commands: Commands,
-    mut entity_map: ResMut<ClientEntityMap>,
     cells: Query<(Entity, &Cell)>,
-    server_symbol: Single<&Symbol, With<Player>>,
+    server_symbol: Single<&Symbol, With<LocalPlayer>>,
 ) {
+    let mut entity_map = ClientEntityMap::default();
     for (server_entity, cell) in &cells {
-        let Some(&client_entity) = trigger.get(&cell.index) else {
+        let Some(&client_entity) = trigger.cell_entities.get(&cell.index) else {
             error!("received cells missing index {}, disconnecting", cell.index);
             commands.set_state(GameState::Disconnected);
             return;
         };
 
-        entity_map.insert(
-            trigger.client_id,
-            ClientMapping {
-                server_entity,
-                client_entity,
-            },
-        );
+        entity_map.insert(server_entity, client_entity);
     }
 
-    commands.spawn((Player(trigger.client_id), server_symbol.next()));
+    let player_entity = commands
+        .spawn((
+            Player,
+            server_symbol.next(),
+            PlayerClient(trigger.client_entity),
+        ))
+        .id();
+    entity_map.insert(player_entity, trigger.player_entity);
+
+    // When `replicate_after_connect` is set to false, `ReplicatedClient`
+    // and `ClientEntityMap` are not inserted automatically to client entities.
+    // We need to insert them manually to start replication.
     commands.set_state(GameState::InGame);
-    commands.trigger(StartReplication(trigger.client_id));
+    commands
+        .entity(trigger.client_entity)
+        .insert((ReplicatedClient, entity_map));
 }
 
 /// Sets the game in disconnected state if client closes the connection.
 ///
 /// Used only for server.
 fn disconnect_by_client(
-    _trigger: Trigger<ClientDisconnected>,
+    _trigger: Trigger<OnRemove, ConnectedClient>,
     game_state: Res<State<GameState>>,
     mut commands: Commands,
 ) {
@@ -474,13 +496,9 @@ fn show_waiting_client_text(
 /// Returns `true` if the local player can select cells.
 fn local_player_turn(
     turn_symbol: Res<TurnSymbol>,
-    client: Res<RepliconClient>,
-    players: Query<(&Player, &Symbol)>,
+    players: Query<&Symbol, With<LocalPlayer>>,
 ) -> bool {
-    let client_id = client.id().unwrap_or(ClientId::SERVER);
-    players
-        .iter()
-        .any(|(&player, &symbol)| *player == client_id && symbol == **turn_symbol)
+    players.iter().any(|&symbol| symbol == **turn_symbol)
 }
 
 const PORT: u16 = 5000;
@@ -532,7 +550,7 @@ enum GameState {
 #[derive(Resource, Default, Deref, DerefMut)]
 struct TurnSymbol(Symbol);
 
-/// A component that defines the symbol of a player or a filled cell.
+/// A component that defines the symbol of a [`Player`], current [`TurnSymbol`] or a filled cell (see [`CellPick`]).
 #[derive(Clone, Component, Copy, Default, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 enum Symbol {
     #[default]
@@ -595,12 +613,27 @@ struct Cell {
     index: usize,
 }
 
-/// Contains player ID.
-///
-/// We want to replicate all players, so we just set [`Replicated`] as a required component.
-#[derive(Clone, Copy, Component, Deref, Serialize, Deserialize)]
+/// Marker for a player entity.
+#[derive(Component, Default)]
 #[require(Replicated)]
-struct Player(ClientId);
+struct Player;
+
+/// Marks [`Player`] as locally controlled.
+///
+/// Used to determine if player can place a symbol.
+///
+/// See also [`local_player_turn`].
+#[derive(Component)]
+#[require(Player)]
+struct LocalPlayer;
+
+/// Identifies which player controlled by which client.
+///
+/// Points to client entity. Used to verify client's turns.
+///
+/// It's not replicated and present only on server or singleplayer.
+#[derive(Clone, Copy, Component, Deref)]
+struct PlayerClient(Entity);
 
 /// A trigger that indicates a symbol pick.
 ///
@@ -614,5 +647,8 @@ struct CellPick {
 /// A trigger to send client cell entities to server to estabialize mappings for replication.
 ///
 /// See [`TicTacToePlugin::client_start`] for details.
-#[derive(Event, Deref, Serialize, Deserialize)]
-struct MapCells(HashMap<usize, Entity>);
+#[derive(Event, Serialize, Deserialize)]
+struct MapBoard {
+    cell_entities: HashMap<usize, Entity>,
+    player_entity: Entity,
+}
diff --git a/bevy_replicon_example_backend/src/client.rs b/bevy_replicon_example_backend/src/client.rs
index 51b384ad..08948f3c 100644
--- a/bevy_replicon_example_backend/src/client.rs
+++ b/bevy_replicon_example_backend/src/client.rs
@@ -36,12 +36,8 @@ fn set_disconnected(mut replicon_client: ResMut<RepliconClient>) {
     replicon_client.set_status(RepliconClientStatus::Disconnected);
 }
 
-fn set_connected(client: Res<ExampleClient>, mut replicon_client: ResMut<RepliconClient>) {
-    if let Ok(addr) = client.local_addr() {
-        replicon_client.set_status(RepliconClientStatus::Connected {
-            client_id: Some(ClientId::new(addr.port().into())),
-        });
-    }
+fn set_connected(mut replicon_client: ResMut<RepliconClient>) {
+    replicon_client.set_status(RepliconClientStatus::Connected);
 }
 
 fn receive_packets(
@@ -56,7 +52,7 @@ fn receive_packets(
                 match e.kind() {
                     io::ErrorKind::WouldBlock => (),
                     io::ErrorKind::UnexpectedEof => {
-                        debug!("connection was closed by server");
+                        debug!("server closed the connection");
                         commands.remove_resource::<ExampleClient>();
                     }
                     _ => {
@@ -106,10 +102,4 @@ impl ExampleClient {
     pub fn is_connected(&self) -> bool {
         self.local_addr().is_ok()
     }
-
-    /// Returns assigned ID.
-    pub fn id(&self) -> io::Result<ClientId> {
-        self.local_addr()
-            .map(|addr| ClientId::new(addr.port().into()))
-    }
 }
diff --git a/bevy_replicon_example_backend/src/server.rs b/bevy_replicon_example_backend/src/server.rs
index 48a1c9f3..e7017929 100644
--- a/bevy_replicon_example_backend/src/server.rs
+++ b/bevy_replicon_example_backend/src/server.rs
@@ -3,10 +3,7 @@ use std::{
     net::{Ipv4Addr, SocketAddr, TcpListener, TcpStream},
 };
 
-use bevy::{
-    prelude::*,
-    utils::{Entry, HashMap},
-};
+use bevy::{ecs::entity::EntityHashMap, prelude::*, utils::Entry};
 use bevy_replicon::prelude::*;
 
 use super::tcp;
@@ -51,10 +48,10 @@ fn receive_packets(
     loop {
         match server.listener.accept() {
             Ok((stream, addr)) => {
-                let client_id = ClientId::new(addr.port().into());
-                match server.add_connected(client_id, stream) {
-                    Ok(()) => commands.trigger(ClientConnected { client_id }),
-                    Err(e) => error!("unable to accept connection from `{client_id:?}`: {e}"),
+                let client_entity = commands.spawn(ConnectedClient).id();
+                if let Err(e) = server.add_connected(client_entity, stream) {
+                    error!("unable to accept connection from `{addr}`: {e}");
+                    commands.entity(client_entity).despawn();
                 }
             }
             Err(e) => {
@@ -67,25 +64,21 @@ fn receive_packets(
         }
     }
 
-    server.streams.retain(|client_id, stream| loop {
+    server.streams.retain(|&client_entity, stream| loop {
         match tcp::read_message(stream) {
             Ok((channel_id, message)) => {
-                replicon_server.insert_received(*client_id, channel_id, message)
+                replicon_server.insert_received(client_entity, channel_id, message)
             }
             Err(e) => match e.kind() {
                 io::ErrorKind::WouldBlock => return true,
                 io::ErrorKind::UnexpectedEof => {
-                    commands.trigger(ClientDisconnected {
-                        client_id: *client_id,
-                        reason: DisconnectReason::DisconnectedByClient,
-                    });
+                    commands.entity(client_entity).despawn();
+                    debug!("`client {client_entity}` closed the connection");
                     return false;
                 }
                 _ => {
-                    commands.trigger(ClientDisconnected {
-                        client_id: *client_id,
-                        reason: Box::<BackendError>::from(e).into(),
-                    });
+                    commands.entity(client_entity).despawn();
+                    error!("disconnecting due to message read error from client `{client_entity}`: {e}");
                     return false;
                 }
             },
@@ -98,19 +91,17 @@ fn send_packets(
     mut server: ResMut<ExampleServer>,
     mut replicon_server: ResMut<RepliconServer>,
 ) {
-    for (client_id, channel_id, message) in replicon_server.drain_sent() {
-        match server.streams.entry(client_id) {
+    for (client_entity, channel_id, message) in replicon_server.drain_sent() {
+        match server.streams.entry(client_entity) {
             Entry::Occupied(mut entry) => {
                 if let Err(e) = tcp::send_message(entry.get_mut(), channel_id, &message) {
-                    commands.trigger(ClientDisconnected {
-                        client_id,
-                        reason: e.into(),
-                    });
+                    commands.entity(client_entity).despawn();
+                    error!("disconnecting client `{client_entity}` due to error: {e}");
                     entry.remove();
                 }
             }
             Entry::Vacant(_) => error!(
-                "unable to send message over channel {channel_id} for non-existing `{client_id:?}`"
+                "unable to send message over channel {channel_id} for non-existing client `{client_entity}`"
             ),
         }
     }
@@ -120,7 +111,7 @@ fn send_packets(
 #[derive(Resource)]
 pub struct ExampleServer {
     listener: TcpListener,
-    streams: HashMap<ClientId, TcpStream>,
+    streams: EntityHashMap<TcpStream>,
 }
 
 impl ExampleServer {
@@ -145,10 +136,10 @@ impl ExampleServer {
     }
 
     /// Associates a stream with a client and properly configures it.
-    fn add_connected(&mut self, client_id: ClientId, stream: TcpStream) -> io::Result<()> {
+    fn add_connected(&mut self, client_entity: Entity, stream: TcpStream) -> io::Result<()> {
         stream.set_nodelay(true)?;
         stream.set_nonblocking(true)?;
-        self.streams.insert(client_id, stream);
+        self.streams.insert(client_entity, stream);
 
         Ok(())
     }
diff --git a/bevy_replicon_example_backend/tests/backend.rs b/bevy_replicon_example_backend/tests/backend.rs
index c2b2e216..96ed9603 100644
--- a/bevy_replicon_example_backend/tests/backend.rs
+++ b/bevy_replicon_example_backend/tests/backend.rs
@@ -27,8 +27,8 @@ fn connect_disconnect() {
     let renet_server = server_app.world().resource::<ExampleServer>();
     assert_eq!(renet_server.connected_clients(), 1);
 
-    let connected_clients = server_app.world().resource::<ConnectedClients>();
-    assert_eq!(connected_clients.len(), 1);
+    let mut clients = server_app.world_mut().query::<&ConnectedClient>();
+    assert_eq!(clients.iter(server_app.world()).len(), 1);
 
     let replicon_client = client_app.world().resource::<RepliconClient>();
     assert!(replicon_client.is_connected());
@@ -41,8 +41,7 @@ fn connect_disconnect() {
     client_app.update();
     server_app.update();
 
-    let connected_clients = server_app.world().resource::<ConnectedClients>();
-    assert_eq!(connected_clients.len(), 0);
+    assert_eq!(clients.iter(server_app.world()).len(), 0);
 
     let renet_server = server_app.world().resource::<ExampleServer>();
     assert_eq!(renet_server.connected_clients(), 0);
diff --git a/src/client/diagnostics.rs b/src/client/diagnostics.rs
index a75c7454..3f9702d3 100644
--- a/src/client/diagnostics.rs
+++ b/src/client/diagnostics.rs
@@ -108,10 +108,10 @@ fn add_measurements(
     mut last_stats: Local<ClientReplicationStats>,
     client: Res<RepliconClient>,
 ) {
-    diagnostics.add_measurement(&RTT, || client.rtt());
-    diagnostics.add_measurement(&PACKET_LOSS, || client.packet_loss());
-    diagnostics.add_measurement(&SENT_BPS, || client.sent_bps());
-    diagnostics.add_measurement(&RECEIVED_BPS, || client.received_bps());
+    diagnostics.add_measurement(&RTT, || client.stats().rtt);
+    diagnostics.add_measurement(&PACKET_LOSS, || client.stats().packet_loss);
+    diagnostics.add_measurement(&SENT_BPS, || client.stats().sent_bps);
+    diagnostics.add_measurement(&RECEIVED_BPS, || client.stats().received_bps);
 
     diagnostics.add_measurement(&ENTITIES_CHANGED, || {
         (stats.entities_changed - last_stats.entities_changed) as f64
diff --git a/src/core.rs b/src/core.rs
index 5e470889..c9b84129 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -1,6 +1,5 @@
 pub mod channels;
 pub mod common_conditions;
-pub mod connected_clients;
 pub mod entity_serde;
 pub mod event;
 pub mod postcard_utils;
@@ -10,11 +9,7 @@ pub mod replicon_server;
 pub mod replicon_tick;
 pub mod server_entity_map;
 
-use std::error::Error;
-
 use bevy::prelude::*;
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
 
 use channels::RepliconChannels;
 use event::event_registry::EventRegistry;
@@ -29,6 +24,7 @@ pub struct RepliconCorePlugin;
 impl Plugin for RepliconCorePlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Replicated>()
+            .register_type::<NetworkStats>()
             .init_resource::<TrackMutateMessages>()
             .init_resource::<RepliconChannels>()
             .init_resource::<ReplicationRegistry>()
@@ -38,42 +34,44 @@ impl Plugin for RepliconCorePlugin {
     }
 }
 
-/// Unique client ID.
+/// Statistic associated with [`RepliconClient`](replicon_client::RepliconClient) or
+/// [`ConnectedClient`].
 ///
-/// Could be a client or a dual server-client.
-#[derive(
-    Debug, Clone, Copy, Hash, PartialEq, Eq, Ord, PartialOrd, Serialize, Deserialize, Reflect,
-)]
-pub struct ClientId(u64);
-
-impl ClientId {
-    /// The server's client ID when it's a dual server-client.
-    pub const SERVER: Self = Self::new(0);
+/// All values can be zero if not provided by the backend.
+///
+/// <div class="warning">
+///
+/// Should only be modified from the messaging backend.
+///
+/// </div>
+#[derive(Component, Debug, Clone, Copy, Default, Reflect)]
+pub struct NetworkStats {
+    /// Round-time trip in seconds for the connection.
+    pub rtt: f64,
 
-    /// Creates a new ID wrapping the given value.
-    pub const fn new(value: u64) -> Self {
-        Self(value)
-    }
+    /// Packet loss % for the connection.
+    pub packet_loss: f64,
 
-    /// Gets the value of this ID.
-    pub fn get(&self) -> u64 {
-        self.0
-    }
-}
+    /// Bytes sent per second for the connection.
+    pub sent_bps: f64,
 
-/// Possible reason for a disconnection.
-#[derive(Debug, Error)]
-pub enum DisconnectReason {
-    /// Connection was terminated by the client.
-    #[error("connection terminated by the client")]
-    DisconnectedByClient,
-    /// Connection was terminated by the server.
-    #[error("connection terminated by the server")]
-    DisconnectedByServer,
-    /// A reason defined by backend.
-    #[error(transparent)]
-    Backend(#[from] Box<BackendError>),
+    /// Bytes received per second for the connection.
+    pub received_bps: f64,
 }
 
-/// Alias for error inside [`DisconnectReason::Backend`].
-pub type BackendError = dyn Error + Send + Sync;
+/// Marker for a connected client.
+///
+/// Backends should spawn and despawn entities with this component on connect and disconnect.
+///
+/// `Entity` is used an identifier to refer to a client.
+///
+/// <div class="warning">
+///
+/// Entities with this components should be spawned and despawned only from the messaging backend.
+///
+/// </div>
+///
+/// See also [`ReplicatedClient`](crate::server::ReplicatedClient).
+#[derive(Component)]
+#[require(NetworkStats)]
+pub struct ConnectedClient;
diff --git a/src/core/connected_clients.rs b/src/core/connected_clients.rs
deleted file mode 100644
index e9bfec85..00000000
--- a/src/core/connected_clients.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-use bevy::prelude::*;
-
-use crate::core::ClientId;
-
-/// Contains all connected clients.
-///
-/// Inserted as resource by [`ServerPlugin`](crate::server::ServerPlugin).
-///
-/// See also [ReplicatedClients](super::replication::replicated_clients::ReplicatedClients).
-#[derive(Resource, Default, Debug, Deref)]
-pub struct ConnectedClients(Vec<ConnectedClient>);
-
-impl ConnectedClients {
-    pub(crate) fn add(&mut self, client_id: ClientId) {
-        debug!("adding connected `{client_id:?}`");
-
-        self.0.push(ConnectedClient::new(client_id));
-    }
-
-    pub(crate) fn remove(&mut self, client_id: ClientId) {
-        debug!("removing disconnected `{client_id:?}`");
-
-        let index = self
-            .iter()
-            .position(|client| client.id == client_id)
-            .unwrap_or_else(|| panic!("{client_id:?} should be added before removal"));
-        self.0.remove(index);
-    }
-
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut ConnectedClient> {
-        self.0.iter_mut()
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct ConnectedClient {
-    id: ClientId,
-    rtt: f64,
-    packet_loss: f64,
-    sent_bps: f64,
-    received_bps: f64,
-}
-
-impl ConnectedClient {
-    pub fn new(id: ClientId) -> Self {
-        Self {
-            id,
-            rtt: 0.0,
-            packet_loss: 0.0,
-            sent_bps: 0.0,
-            received_bps: 0.0,
-        }
-    }
-
-    /// Returns the associated ID.
-    pub fn id(&self) -> ClientId {
-        self.id
-    }
-
-    /// Returns the round-time trip in seconds for the connection.
-    ///
-    /// Returns zero if not provided by the backend.
-    pub fn rtt(&self) -> f64 {
-        self.rtt
-    }
-
-    /// Sets the round-time trip in seconds for the connection.
-    ///
-    /// <div class="warning">
-    ///
-    /// Should only be called from the messaging backend.
-    ///
-    /// </div>
-    pub fn set_rtt(&mut self, rtt: f64) {
-        self.rtt = rtt;
-    }
-
-    /// Returns the packet loss % for the connection.
-    ///
-    /// Returns zero if not provided by the backend.
-    pub fn packet_loss(&self) -> f64 {
-        self.packet_loss
-    }
-
-    /// Sets the packet loss % for the connection.
-    ///
-    /// <div class="warning">
-    ///
-    /// Should only be called from the messaging backend.
-    ///
-    /// </div>
-    pub fn set_packet_loss(&mut self, packet_loss: f64) {
-        self.packet_loss = packet_loss;
-    }
-
-    /// Returns the bytes sent per second for the connection.
-    ///
-    /// Returns zero if not provided by the backend.
-    pub fn sent_bps(&self) -> f64 {
-        self.sent_bps
-    }
-
-    /// Sets the bytes sent per second for the connection.
-    ///
-    /// <div class="warning">
-    ///
-    /// Should only be called from the messaging backend.
-    ///
-    /// </div>
-    pub fn set_sent_bps(&mut self, sent_bps: f64) {
-        self.sent_bps = sent_bps;
-    }
-
-    /// Returns the bytes received per second for the connection.
-    ///
-    /// Returns zero if not provided by the backend.
-    pub fn received_bps(&self) -> f64 {
-        self.received_bps
-    }
-
-    /// Sets the bytes received per second for the connection.
-    ///
-    /// <div class="warning">
-    ///
-    /// Should only be called from the messaging backend.
-    ///
-    /// </div>
-    pub fn set_received_bps(&mut self, received_bps: f64) {
-        self.received_bps = received_bps;
-    }
-}
diff --git a/src/core/event/client_event.rs b/src/core/event/client_event.rs
index e6ba30dd..9e8ae747 100644
--- a/src/core/event/client_event.rs
+++ b/src/core/event/client_event.rs
@@ -18,7 +18,6 @@ use crate::core::{
     postcard_utils,
     replicon_client::RepliconClient,
     replicon_server::RepliconServer,
-    ClientId,
 };
 
 /// An extension trait for [`App`] for creating client events.
@@ -28,7 +27,7 @@ pub trait ClientEventAppExt {
     /// The API matches [`ClientTriggerAppExt::add_client_trigger`](super::client_trigger::ClientTriggerAppExt::add_client_trigger):
     /// [`FromClient<E>`] will be emitted on the server after sending `E` event on client.
     /// When [`RepliconClient`] is inactive, the event will be drained right after sending and re-emitted
-    /// locally as [`FromClient<E>`] with [`ClientId::SERVER`](crate::core::ClientId::SERVER).
+    /// locally as [`FromClient<E>`] with [`Entity::PLACEHOLDER`].
     ///
     /// Can be called for events that were registered with [add_event](bevy::app::App::add_event).
     /// A duplicate registration for `E` won't be created.
@@ -271,17 +270,20 @@ impl ClientEvent {
         server: &mut RepliconServer,
     ) {
         let client_events: &mut Events<FromClient<E>> = client_events.deref_mut();
-        for (client_id, mut message) in server.receive(self.channel_id) {
+        for (client_entity, mut message) in server.receive(self.channel_id) {
             match self.deserialize::<E, I>(ctx, &mut message) {
                 Ok(event) => {
                     debug!(
-                        "applying event `{}` from `{client_id:?}`",
+                        "applying event `{}` from client `{client_entity}`",
                         any::type_name::<E>()
                     );
-                    client_events.send(FromClient { client_id, event });
+                    client_events.send(FromClient {
+                        client_entity,
+                        event,
+                    });
                 }
                 Err(e) => debug!(
-                    "ignoring event `{}` from {client_id:?} that failed to deserialize: {e}",
+                    "ignoring event `{}` from client `{client_entity}` that failed to deserialize: {e}",
                     any::type_name::<E>()
                 ),
             }
@@ -313,7 +315,7 @@ impl ClientEvent {
                 any::type_name::<E>()
             );
             client_events.send_batch(events.drain().map(|event| FromClient {
-                client_id: ClientId::SERVER,
+                client_entity: Entity::PLACEHOLDER,
                 event,
             }));
         }
@@ -400,10 +402,11 @@ impl<E: Event> FromWorld for ClientEventReader<E> {
 }
 
 /// An event indicating that a message from client was received.
+///
 /// Emitted only on server.
 #[derive(Clone, Copy, Event, Deref, DerefMut)]
 pub struct FromClient<T> {
-    pub client_id: ClientId,
+    pub client_entity: Entity,
     #[deref]
     pub event: T,
 }
diff --git a/src/core/event/client_trigger.rs b/src/core/event/client_trigger.rs
index 4168bd48..1103974c 100644
--- a/src/core/event/client_trigger.rs
+++ b/src/core/event/client_trigger.rs
@@ -22,7 +22,7 @@ pub trait ClientTriggerAppExt {
     /// The API matches [`ClientEventAppExt::add_client_event`](super::client_event::ClientEventAppExt::add_client_event):
     /// [`FromClient<E>`] will be triggered on the server after triggering `E` event on client.
     /// When [`RepliconClient`](crate::core::replicon_client::RepliconClient) is inactive, the event
-    /// will also be triggered locally as [`FromClient<E>`] with [`ClientId::SERVER`](crate::core::ClientId::SERVER).
+    /// will also be triggered locally as [`FromClient<E>`] with [`Entity::PLACEHOLDER`].
     ///
     /// See also [`Self::add_client_trigger_with`] and the [corresponding section](../index.html#from-client-to-server)
     /// from the quick start guide.
@@ -114,14 +114,18 @@ impl ClientTrigger {
     /// and this instance was created for `E`.
     unsafe fn trigger_typed<E: Event>(commands: &mut Commands, client_events: PtrMut) {
         let client_events: &mut Events<FromClient<RemoteTrigger<E>>> = client_events.deref_mut();
-        for FromClient { client_id, event } in client_events.drain() {
+        for FromClient {
+            client_entity,
+            event,
+        } in client_events.drain()
+        {
             debug!(
-                "triggering `{}` from `{client_id:?}`",
+                "triggering `{}` from `{client_entity}`",
                 any::type_name::<FromClient<E>>()
             );
             commands.trigger_targets(
                 FromClient {
-                    client_id,
+                    client_entity,
                     event: event.event,
                 },
                 event.targets,
diff --git a/src/core/event/server_event.rs b/src/core/event/server_event.rs
index dc98d71f..089c7d04 100644
--- a/src/core/event/server_event.rs
+++ b/src/core/event/server_event.rs
@@ -1,7 +1,10 @@
-use std::{any, collections::HashSet, marker::PhantomData, mem};
+use std::{any, marker::PhantomData, mem};
 
 use bevy::{
-    ecs::{component::ComponentId, entity::MapEntities},
+    ecs::{
+        component::ComponentId,
+        entity::{EntityHashSet, MapEntities},
+    },
     prelude::*,
     ptr::{Ptr, PtrMut},
 };
@@ -17,13 +20,12 @@ use super::{
 };
 use crate::core::{
     channels::{RepliconChannel, RepliconChannels},
-    connected_clients::ConnectedClients,
     postcard_utils,
-    replication::replicated_clients::{ReplicatedClient, ReplicatedClients},
+    replication::client_ticks::ClientTicks,
     replicon_client::RepliconClient,
     replicon_server::RepliconServer,
     replicon_tick::RepliconTick,
-    ClientId,
+    ConnectedClient,
 };
 
 /// An extension trait for [`App`] for creating client events.
@@ -31,7 +33,7 @@ pub trait ServerEventAppExt {
     /// Registers `E` and [`ToClients<E>`] events.
     ///
     /// `E` will be emitted on client after sending [`ToClients<E>`] on the server.
-    /// If [`ClientId::SERVER`] is a recipient of the event, then [`ToClients<E>`] will be drained
+    /// If [`Entity::PLACEHOLDER`] is a recipient of the event, then [`ToClients<E>`] will be drained
     /// after sending to clients and `E` events will be emitted on the server.
     ///
     /// Can be called for already existing regular events, a duplicate registration
@@ -279,17 +281,10 @@ impl ServerEvent {
         ctx: &mut ServerSendCtx,
         server_events: &Ptr,
         server: &mut RepliconServer,
-        connected_clients: &ConnectedClients,
+        clients: &Query<Entity, With<ConnectedClient>>,
         buffered_events: &mut BufferedServerEvents,
     ) {
-        (self.send_or_buffer)(
-            self,
-            ctx,
-            server_events,
-            server,
-            connected_clients,
-            buffered_events,
-        );
+        (self.send_or_buffer)(self, ctx, server_events, server, clients, buffered_events);
     }
 
     /// Typed version of [`Self::send_or_buffer`].
@@ -303,7 +298,7 @@ impl ServerEvent {
         ctx: &mut ServerSendCtx,
         server_events: &Ptr,
         server: &mut RepliconServer,
-        connected_clients: &ConnectedClients,
+        clients: &Query<Entity, With<ConnectedClient>>,
         buffered_events: &mut BufferedServerEvents,
     ) {
         let events: &Events<ToClients<E>> = server_events.deref();
@@ -313,7 +308,7 @@ impl ServerEvent {
             debug!("sending event `{}` with `{mode:?}`", any::type_name::<E>());
 
             if self.is_independent() {
-                self.send_independent_event::<E, I>(ctx, event, mode, server, connected_clients)
+                self.send_independent_event::<E, I>(ctx, event, mode, server, clients)
                     .expect("independent server event should be serializable");
             } else {
                 self.buffer_event::<E, I>(ctx, event, *mode, buffered_events)
@@ -335,7 +330,7 @@ impl ServerEvent {
         event: &E,
         mode: &SendMode,
         server: &mut RepliconServer,
-        connected_clients: &ConnectedClients,
+        clients: &Query<Entity, With<ConnectedClient>>,
     ) -> postcard::Result<()> {
         let mut message = Vec::new();
         self.serialize::<E, I>(ctx, event, &mut message)?;
@@ -343,20 +338,20 @@ impl ServerEvent {
 
         match *mode {
             SendMode::Broadcast => {
-                for client in connected_clients.iter() {
-                    server.send(client.id(), self.channel_id, message.clone());
+                for client_entity in clients.iter() {
+                    server.send(client_entity, self.channel_id, message.clone());
                 }
             }
-            SendMode::BroadcastExcept(id) => {
-                for client in connected_clients.iter() {
-                    if client.id() != id {
-                        server.send(client.id(), self.channel_id, message.clone());
+            SendMode::BroadcastExcept(entity) => {
+                for client_entity in clients.iter() {
+                    if client_entity != entity {
+                        server.send(client_entity, self.channel_id, message.clone());
                     }
                 }
             }
-            SendMode::Direct(client_id) => {
-                if client_id != ClientId::SERVER {
-                    server.send(client_id, self.channel_id, message.clone());
+            SendMode::Direct(entity) => {
+                if entity != Entity::PLACEHOLDER {
+                    server.send(entity, self.channel_id, message.clone());
                 }
             }
         }
@@ -513,13 +508,13 @@ impl ServerEvent {
                 SendMode::Broadcast => {
                     events.send(event);
                 }
-                SendMode::BroadcastExcept(client_id) => {
-                    if client_id != ClientId::SERVER {
+                SendMode::BroadcastExcept(entity) => {
+                    if entity != Entity::PLACEHOLDER {
                         events.send(event);
                     }
                 }
-                SendMode::Direct(client_id) => {
-                    if client_id == ClientId::SERVER {
+                SendMode::Direct(entity) => {
+                    if entity == Entity::PLACEHOLDER {
                         events.send(event);
                     }
                 }
@@ -606,7 +601,7 @@ type SendOrBufferFn = unsafe fn(
     &mut ServerSendCtx,
     &Ptr,
     &mut RepliconServer,
-    &ConnectedClients,
+    &Query<Entity, With<ConnectedClient>>,
     &mut BufferedServerEvents,
 );
 
@@ -698,10 +693,11 @@ impl BufferedServerEvent {
     fn send(
         &mut self,
         server: &mut RepliconServer,
-        client: &ReplicatedClient,
+        client_entity: Entity,
+        client: &ClientTicks,
     ) -> postcard::Result<()> {
         let message = self.message.get_bytes(client.update_tick())?;
-        server.send(client.id(), self.channel, message);
+        server.send(client_entity, self.channel, message);
         Ok(())
     }
 }
@@ -709,8 +705,8 @@ impl BufferedServerEvent {
 #[derive(Default)]
 struct BufferedServerEventSet {
     events: Vec<BufferedServerEvent>,
-    /// Client ids excluded from receiving events in this set because they connected after the events were sent.
-    excluded: HashSet<ClientId>,
+    /// Client entities excluded from receiving events in this set because they connected after the events were sent.
+    excluded: EntityHashSet,
 }
 
 impl BufferedServerEventSet {
@@ -757,43 +753,41 @@ impl BufferedServerEvents {
     }
 
     /// Used to prevent newly-connected clients from receiving old events.
-    pub(crate) fn exclude_client(&mut self, client: ClientId) {
+    pub(crate) fn exclude_client(&mut self, client_entity: Entity) {
         for set in self.buffer.iter_mut() {
-            set.excluded.insert(client);
+            set.excluded.insert(client_entity);
         }
     }
 
     pub(crate) fn send_all(
         &mut self,
         server: &mut RepliconServer,
-        replicated_clients: &ReplicatedClients,
+        clients: &Query<(Entity, &ClientTicks)>,
     ) -> postcard::Result<()> {
         for mut set in self.buffer.drain(..) {
             for mut event in set.events.drain(..) {
                 match event.mode {
                     SendMode::Broadcast => {
-                        for client in replicated_clients
-                            .iter()
-                            .filter(|c| !set.excluded.contains(&c.id()))
+                        for (client_entity, client) in
+                            clients.iter().filter(|(e, _)| !set.excluded.contains(e))
                         {
-                            event.send(server, client)?;
+                            event.send(server, client_entity, client)?;
                         }
                     }
-                    SendMode::BroadcastExcept(client_id) => {
-                        for client in replicated_clients
-                            .iter()
-                            .filter(|c| !set.excluded.contains(&c.id()))
+                    SendMode::BroadcastExcept(entity) => {
+                        for (client_entity, client) in
+                            clients.iter().filter(|(e, _)| !set.excluded.contains(e))
                         {
-                            if client.id() == client_id {
+                            if client_entity == entity {
                                 continue;
                             }
-                            event.send(server, client)?;
+                            event.send(server, client_entity, client)?;
                         }
                     }
-                    SendMode::Direct(client_id) => {
-                        if client_id != ClientId::SERVER && !set.excluded.contains(&client_id) {
-                            if let Some(client) = replicated_clients.get_client(client_id) {
-                                event.send(server, client)?;
+                    SendMode::Direct(entity) => {
+                        if entity != Entity::PLACEHOLDER && !set.excluded.contains(&entity) {
+                            if let Ok((client_entity, client)) = clients.get(entity) {
+                                event.send(server, client_entity, client)?;
                             }
                         }
                     }
@@ -825,8 +819,8 @@ pub struct ToClients<T> {
 #[derive(Clone, Copy, Debug)]
 pub enum SendMode {
     Broadcast,
-    BroadcastExcept(ClientId),
-    Direct(ClientId),
+    BroadcastExcept(Entity),
+    Direct(Entity),
 }
 
 /// Stores all received events from server that arrived earlier then replication message with their tick.
diff --git a/src/core/event/server_trigger.rs b/src/core/event/server_trigger.rs
index 12b17551..69d7c3ec 100644
--- a/src/core/event/server_trigger.rs
+++ b/src/core/event/server_trigger.rs
@@ -21,8 +21,8 @@ pub trait ServerTriggerAppExt {
     ///
     /// The API matches [`ServerEventAppExt::add_server_event`](super::server_event::ServerEventAppExt::add_server_event):
     /// `E` will be triggered on the client after triggering [`ToClients<E>`] event on server.
-    /// If [`ClientId::SERVER`](crate::core::ClientId::SERVER) is a recipient of the event, then `E` events will be emitted on the server
-    /// as well.
+    /// If [`Entity::PLACEHOLDER`] is a recipient of the event (not to be confused with trigger target),
+    /// then `E` events will be emitted on the server as well.
     ///
     /// See also [`Self::add_server_trigger_with`] and the [corresponding section](../index.html#from-server-to-client)
     /// from the quick start guide.
@@ -176,7 +176,7 @@ fn trigger_deserialize<'a, E>(
 /// See also [`ServerTriggerAppExt`].
 pub trait ServerTriggerExt {
     /// Like [`Commands::trigger`], but triggers `E` on server and locally
-    /// if [`ClientId::SERVER`](crate::core::ClientId::SERVER) is a recipient of the event).
+    /// if [`Entity::PLACEHOLDER`] is a recipient of the event).
     fn server_trigger(&mut self, event: ToClients<impl Event>);
 
     /// Like [`Self::server_trigger`], but allows you to specify target entities, similar to
diff --git a/src/core/replication.rs b/src/core/replication.rs
index 6b35b79c..ca459f4a 100644
--- a/src/core/replication.rs
+++ b/src/core/replication.rs
@@ -1,7 +1,7 @@
+pub(crate) mod client_ticks;
 pub mod command_markers;
 pub mod deferred_entity;
 pub(crate) mod mutate_index;
-pub mod replicated_clients;
 pub mod replication_registry;
 pub mod replication_rules;
 pub mod track_mutate_messages;
diff --git a/src/core/replication/client_ticks.rs b/src/core/replication/client_ticks.rs
new file mode 100644
index 00000000..dba232ab
--- /dev/null
+++ b/src/core/replication/client_ticks.rs
@@ -0,0 +1,161 @@
+use std::mem;
+
+use bevy::{
+    ecs::{component::Tick, entity::EntityHashMap},
+    prelude::*,
+    utils::{Duration, HashMap},
+};
+
+use super::mutate_index::MutateIndex;
+use crate::core::replicon_tick::RepliconTick;
+
+/// Tracks replication ticks for a client.
+#[derive(Component, Default)]
+pub(crate) struct ClientTicks {
+    /// Lowest tick for use in change detection for each entity.
+    mutation_ticks: EntityHashMap<Tick>,
+
+    /// The last tick in which a replicated entity had an insertion, removal, or gained/lost a component from the
+    /// perspective of the client.
+    ///
+    /// It should be included in mutate messages and server events to avoid needless waiting for the next update
+    /// message to arrive.
+    update_tick: RepliconTick,
+
+    /// Mutate message indices mapped to their info.
+    mutations: HashMap<MutateIndex, MutateInfo>,
+
+    /// Index for the next mutate message to be sent to this client.
+    ///
+    /// See also [`Self::register_mutate_message`].
+    mutate_index: MutateIndex,
+}
+
+impl ClientTicks {
+    /// Sets the client's update tick.
+    pub(crate) fn set_update_tick(&mut self, tick: RepliconTick) {
+        self.update_tick = tick;
+    }
+
+    /// Returns the last tick in which a replicated entity had an insertion, removal, or gained/lost a component from the
+    /// perspective of the client.
+    pub(crate) fn update_tick(&self) -> RepliconTick {
+        self.update_tick
+    }
+
+    /// Registers mutate message at specified `tick` and `timestamp` and returns its index with entities to fill.
+    ///
+    /// Used later to acknowledge updated entities.
+    #[must_use]
+    pub(crate) fn register_mutate_message(
+        &mut self,
+        entity_buffer: &mut EntityBuffer,
+        tick: Tick,
+        timestamp: Duration,
+    ) -> (MutateIndex, &mut Vec<Entity>) {
+        let mutate_index = self.mutate_index.advance();
+
+        let mut entities = entity_buffer.pop().unwrap_or_default();
+        entities.clear();
+        let mutate_info = MutateInfo {
+            tick,
+            timestamp,
+            entities,
+        };
+        let mutate_info = self
+            .mutations
+            .entry(mutate_index)
+            .insert(mutate_info)
+            .into_mut();
+
+        (mutate_index, &mut mutate_info.entities)
+    }
+
+    /// Sets the mutation tick for an entity that is replicated to this client.
+    ///
+    /// The mutation tick is the reference point for determining if components on an entity have mutated and
+    /// need to be replicated. Component mutations older than the update tick are assumed to be acked by the client.
+    pub(crate) fn set_mutation_tick(&mut self, entity: Entity, tick: Tick) {
+        self.mutation_ticks.insert(entity, tick);
+    }
+
+    /// Gets the mutation tick for an entity that is replicated to this client.
+    pub(crate) fn mutation_tick(&self, entity: Entity) -> Option<Tick> {
+        self.mutation_ticks.get(&entity).copied()
+    }
+
+    /// Marks mutate message as acknowledged by its index.
+    ///
+    /// Mutation tick for all entities from this mutate message will be set to the message tick if it's higher.
+    ///
+    /// Keeps allocated memory in the buffers for reuse.
+    pub(crate) fn ack_mutate_message(
+        &mut self,
+        client_entity: Entity,
+        entity_buffer: &mut EntityBuffer,
+        tick: Tick,
+        mutate_index: MutateIndex,
+    ) {
+        let Some(mutate_info) = self.mutations.remove(&mutate_index) else {
+            debug!("received unknown `{mutate_index:?}` from client `{client_entity}`");
+            return;
+        };
+
+        for entity in &mutate_info.entities {
+            let Some(last_tick) = self.mutation_ticks.get_mut(entity) else {
+                // We ignore missing entities, since they were probably despawned.
+                continue;
+            };
+
+            // Received tick could be outdated because we bump it
+            // if we detect any insertion on the entity in `collect_changes`.
+            if !last_tick.is_newer_than(mutate_info.tick, tick) {
+                *last_tick = mutate_info.tick;
+            }
+        }
+        entity_buffer.push(mutate_info.entities);
+
+        trace!(
+            "acknowledged mutate message with `{:?}` from client `{client_entity}`",
+            mutate_info.tick,
+        );
+    }
+
+    /// Removes a despawned or hidden entity from tracking by this client.
+    pub(crate) fn remove_entity(&mut self, entity: Entity) {
+        self.mutation_ticks.remove(&entity);
+        // We don't clean up `self.mutations` for efficiency reasons.
+        // `Self::acknowledge()` will properly ignore despawned entities.
+    }
+
+    /// Removes all mutate messages older then `min_timestamp`.
+    ///
+    /// Keeps allocated memory in the buffers for reuse.
+    pub(crate) fn cleanup_older_mutations(
+        &mut self,
+        entity_buffer: &mut EntityBuffer,
+        min_timestamp: Duration,
+    ) {
+        self.mutations.retain(|_, mutate_info| {
+            if mutate_info.timestamp < min_timestamp {
+                entity_buffer.push(mem::take(&mut mutate_info.entities));
+                false
+            } else {
+                true
+            }
+        });
+    }
+}
+
+/// Reusable buffer for [`ClientTicks`].
+///
+/// Stores [`Vec`]'s from acknowledged [`MutateInfo`]'s.
+/// to reuse allocated capacity.
+#[derive(Default, Resource, Deref, DerefMut)]
+pub(crate) struct EntityBuffer(Vec<Vec<Entity>>);
+
+struct MutateInfo {
+    tick: Tick,
+    timestamp: Duration,
+    entities: Vec<Entity>,
+}
diff --git a/src/core/replication/replicated_clients.rs b/src/core/replication/replicated_clients.rs
deleted file mode 100644
index fa3e9d61..00000000
--- a/src/core/replication/replicated_clients.rs
+++ /dev/null
@@ -1,400 +0,0 @@
-pub mod client_visibility;
-
-use std::mem;
-
-use bevy::{
-    ecs::{component::Tick, entity::EntityHashMap},
-    prelude::*,
-    utils::{Duration, HashMap},
-};
-
-use super::mutate_index::MutateIndex;
-use crate::core::{replicon_tick::RepliconTick, ClientId};
-use client_visibility::ClientVisibility;
-
-/// Stores information about connected clients which are enabled for replication.
-///
-/// Inserted as resource by [`ServerPlugin`](crate::server::ServerPlugin).
-///
-/// See also [ConnectedClients](crate::core::connected_clients::ConnectedClients).
-#[derive(Resource, Default)]
-pub struct ReplicatedClients {
-    clients: Vec<ReplicatedClient>,
-    policy: VisibilityPolicy,
-    replicate_after_connect: bool,
-}
-
-impl ReplicatedClients {
-    /// Makes a new replicated clients struct.
-    ///
-    /// Generally you should not need this except in testing contexts.
-    pub fn new(policy: VisibilityPolicy, replicate_after_connect: bool) -> Self {
-        Self {
-            clients: Default::default(),
-            policy,
-            replicate_after_connect,
-        }
-    }
-
-    /// Returns the configured [`VisibilityPolicy`].
-    pub fn visibility_policy(&self) -> VisibilityPolicy {
-        self.policy
-    }
-
-    /// Returns if clients will automatically have replication enabled for them after they connect.
-    pub fn replicate_after_connect(&self) -> bool {
-        self.replicate_after_connect
-    }
-
-    /// Returns a reference to a connected client.
-    ///
-    /// This operation is *O*(*n*).
-    /// See also [`Self::get_client`] for the fallible version.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the passed client ID is not connected.
-    pub fn client(&self, client_id: ClientId) -> &ReplicatedClient {
-        self.get_client(client_id)
-            .unwrap_or_else(|| panic!("{client_id:?} should be connected"))
-    }
-
-    /// Returns a mutable reference to a connected client.
-    ///
-    /// This operation is *O*(*n*).
-    /// See also [`Self::get_client_mut`] for the fallible version.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the passed client ID is not connected.
-    pub fn client_mut(&mut self, client_id: ClientId) -> &mut ReplicatedClient {
-        self.get_client_mut(client_id)
-            .unwrap_or_else(|| panic!("{client_id:?} should be connected"))
-    }
-
-    /// Returns a reference to a connected client.
-    ///
-    /// This operation is *O*(*n*).
-    /// See also [`Self::client`] for the panicking version.
-    pub fn get_client(&self, client_id: ClientId) -> Option<&ReplicatedClient> {
-        self.clients.iter().find(|client| client.id == client_id)
-    }
-
-    /// Returns a mutable reference to a connected client.
-    ///
-    /// This operation is *O*(*n*).
-    /// See also [`Self::client`] for the panicking version.
-    pub fn get_client_mut(&mut self, client_id: ClientId) -> Option<&mut ReplicatedClient> {
-        self.clients
-            .iter_mut()
-            .find(|client| client.id == client_id)
-    }
-
-    /// Returns an iterator over client IDs.
-    pub fn iter_client_ids(&self) -> impl Iterator<Item = ClientId> + '_ {
-        self.clients.iter().map(|client| client.id())
-    }
-
-    /// Returns an iterator over connected clients.
-    pub fn iter(&self) -> impl Iterator<Item = &ReplicatedClient> {
-        self.clients.iter()
-    }
-
-    /// Returns a mutable iterator over connected clients.
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut ReplicatedClient> {
-        self.clients.iter_mut()
-    }
-
-    /// Returns the number of connected clients.
-    pub fn len(&self) -> usize {
-        self.clients.len()
-    }
-
-    /// Returns `true` if no clients are connected.
-    pub fn is_empty(&self) -> bool {
-        self.clients.is_empty()
-    }
-
-    /// Initializes a new [`ReplicatedClient`] for this client.
-    ///
-    /// Reuses the memory from the buffers if available.
-    pub(crate) fn add(&mut self, client_buffers: &mut ClientBuffers, client_id: ClientId) {
-        if self.clients.iter().any(|client| client.id == client_id) {
-            warn!("ignoring attempt to start replication for `{client_id:?}` that already has replication enabled");
-            return;
-        }
-
-        debug!("starting replication for `{client_id:?}`");
-
-        let client = if let Some(mut client) = client_buffers.clients.pop() {
-            client.reset(client_id);
-            client
-        } else {
-            ReplicatedClient::new(client_id, self.policy)
-        };
-
-        self.clients.push(client);
-    }
-
-    /// Removes a replicated client if replication has already been enabled for it.
-    ///
-    /// Keeps allocated memory in the buffers for reuse.
-    pub(crate) fn remove(&mut self, client_buffers: &mut ClientBuffers, client_id: ClientId) {
-        let Some(index) = self
-            .clients
-            .iter()
-            .position(|client| client.id == client_id)
-        else {
-            // It's valid to remove a client which is connected but not replicating yet,
-            // which is just a no-op.
-            return;
-        };
-
-        debug!("stopping replication for `{client_id:?}`");
-        let mut client = self.clients.remove(index);
-        client_buffers.entities.extend(client.drain_entities());
-        client_buffers.clients.push(client);
-    }
-
-    /// Clears all clients.
-    ///
-    /// Keeps allocated memory in the buffers for reuse.
-    pub(crate) fn clear(&mut self, client_buffers: &mut ClientBuffers) {
-        for mut client in self.clients.drain(..) {
-            client_buffers.entities.extend(client.drain_entities());
-            client_buffers.clients.push(client);
-        }
-    }
-}
-
-pub struct ReplicatedClient {
-    /// Client's ID.
-    id: ClientId,
-
-    /// Lowest tick for use in change detection for each entity.
-    mutation_ticks: EntityHashMap<Tick>,
-
-    /// Entity visibility settings.
-    visibility: ClientVisibility,
-
-    /// The last tick in which a replicated entity had an insertion, removal, or gained/lost a component from the
-    /// perspective of the client.
-    ///
-    /// It should be included in mutate messages and server events to avoid needless waiting for the next update
-    /// message to arrive.
-    update_tick: RepliconTick,
-
-    /// Mutate message indices mapped to their info.
-    mutations: HashMap<MutateIndex, MutateInfo>,
-
-    /// Index for the next mutate message to be sent to this client.
-    ///
-    /// See also [`Self::register_mutate_message`].
-    mutate_index: MutateIndex,
-}
-
-impl ReplicatedClient {
-    fn new(id: ClientId, policy: VisibilityPolicy) -> Self {
-        Self {
-            id,
-            mutation_ticks: Default::default(),
-            visibility: ClientVisibility::new(policy),
-            update_tick: Default::default(),
-            mutations: Default::default(),
-            mutate_index: Default::default(),
-        }
-    }
-
-    // Returns associated client ID.
-    pub fn id(&self) -> ClientId {
-        self.id
-    }
-
-    /// Returns a reference to the client's visibility settings.
-    pub fn visibility(&self) -> &ClientVisibility {
-        &self.visibility
-    }
-
-    /// Returns a mutable reference to the client's visibility settings.
-    pub fn visibility_mut(&mut self) -> &mut ClientVisibility {
-        &mut self.visibility
-    }
-
-    /// Sets the client's update tick.
-    pub(crate) fn set_update_tick(&mut self, tick: RepliconTick) {
-        self.update_tick = tick;
-    }
-
-    /// Returns the last tick in which a replicated entity had an insertion, removal, or gained/lost a component from the
-    /// perspective of the client.
-    pub fn update_tick(&self) -> RepliconTick {
-        self.update_tick
-    }
-
-    /// Clears all entities for unacknowledged mutate messages, returning them as an iterator.
-    ///
-    /// Keeps the allocated memory for reuse.
-    fn drain_entities(&mut self) -> impl Iterator<Item = Vec<Entity>> + '_ {
-        self.mutations
-            .drain()
-            .map(|(_, mutate_info)| mutate_info.entities)
-    }
-
-    /// Resets all data.
-    ///
-    /// Keeps the allocated memory for reuse.
-    fn reset(&mut self, id: ClientId) {
-        self.id = id;
-        self.visibility.clear();
-        self.mutation_ticks.clear();
-        self.mutations.clear();
-        self.mutate_index = Default::default();
-    }
-
-    /// Registers mutate message at specified `tick` and `timestamp` and returns its index with entities to fill.
-    ///
-    /// Used later to acknowledge updated entities.
-    #[must_use]
-    pub(crate) fn register_mutate_message(
-        &mut self,
-        client_buffers: &mut ClientBuffers,
-        tick: Tick,
-        timestamp: Duration,
-    ) -> (MutateIndex, &mut Vec<Entity>) {
-        let mutate_index = self.mutate_index.advance();
-
-        let mut entities = client_buffers.entities.pop().unwrap_or_default();
-        entities.clear();
-        let mutate_info = MutateInfo {
-            tick,
-            timestamp,
-            entities,
-        };
-        let mutate_info = self
-            .mutations
-            .entry(mutate_index)
-            .insert(mutate_info)
-            .into_mut();
-
-        (mutate_index, &mut mutate_info.entities)
-    }
-
-    /// Sets the mutation tick for an entity that is replicated to this client.
-    ///
-    /// The mutation tick is the reference point for determining if components on an entity have mutated and
-    /// need to be replicated. Component mutations older than the update tick are assumed to be acked by the client.
-    pub(crate) fn set_mutation_tick(&mut self, entity: Entity, tick: Tick) {
-        self.mutation_ticks.insert(entity, tick);
-    }
-
-    /// Gets the mutation tick for an entity that is replicated to this client.
-    pub fn mutation_tick(&self, entity: Entity) -> Option<Tick> {
-        self.mutation_ticks.get(&entity).copied()
-    }
-
-    /// Marks mutate message as acknowledged by its index.
-    ///
-    /// Mutation tick for all entities from this mutate message will be set to the message tick if it's higher.
-    ///
-    /// Keeps allocated memory in the buffers for reuse.
-    pub(crate) fn ack_mutate_message(
-        &mut self,
-        client_buffers: &mut ClientBuffers,
-        tick: Tick,
-        mutate_index: MutateIndex,
-    ) {
-        let Some(mutate_info) = self.mutations.remove(&mutate_index) else {
-            debug!("received unknown `{mutate_index:?}` from {:?}", self.id);
-            return;
-        };
-
-        for entity in &mutate_info.entities {
-            let Some(last_tick) = self.mutation_ticks.get_mut(entity) else {
-                // We ignore missing entities, since they were probably despawned.
-                continue;
-            };
-
-            // Received tick could be outdated because we bump it
-            // if we detect any insertion on the entity in `collect_changes`.
-            if !last_tick.is_newer_than(mutate_info.tick, tick) {
-                *last_tick = mutate_info.tick;
-            }
-        }
-        client_buffers.entities.push(mutate_info.entities);
-
-        trace!(
-            "{:?} acknowledged mutate message with {:?}",
-            self.id,
-            mutate_info.tick,
-        );
-    }
-
-    /// Removes a despawned entity tracked by this client.
-    pub fn remove_despawned(&mut self, entity: Entity) {
-        self.mutation_ticks.remove(&entity);
-        self.visibility.remove_despawned(entity);
-        // We don't clean up `self.mutations` for efficiency reasons.
-        // `Self::acknowledge()` will properly ignore despawned entities.
-    }
-
-    /// Drains all entities for which visibility was lost during this tick.
-    ///
-    /// Internal cleanup happens lazily during the iteration.
-    pub(crate) fn drain_lost_visibility(&mut self) -> impl Iterator<Item = Entity> + '_ {
-        self.visibility.drain_lost().inspect(|entity| {
-            self.mutation_ticks.remove(entity);
-        })
-    }
-
-    /// Removes all mutate messages older then `min_timestamp`.
-    ///
-    /// Keeps allocated memory in the buffers for reuse.
-    pub(crate) fn cleanup_older_mutations(
-        &mut self,
-        client_buffers: &mut ClientBuffers,
-        min_timestamp: Duration,
-    ) {
-        self.mutations.retain(|_, mutate_info| {
-            if mutate_info.timestamp < min_timestamp {
-                client_buffers
-                    .entities
-                    .push(mem::take(&mut mutate_info.entities));
-                false
-            } else {
-                true
-            }
-        });
-    }
-}
-
-/// Reusable buffers for [`ReplicatedClients`] and [`ReplicatedClient`].
-#[derive(Default, Resource)]
-pub(crate) struct ClientBuffers {
-    /// [`ReplicatedClient`]'s of previously disconnected clients.
-    ///
-    /// Stored to reuse allocated memory.
-    clients: Vec<ReplicatedClient>,
-
-    /// [`Vec`]'s from acknowledged [`MutateInfo`]'s.
-    ///
-    /// Stored to reuse allocated capacity.
-    entities: Vec<Vec<Entity>>,
-}
-
-struct MutateInfo {
-    tick: Tick,
-    timestamp: Duration,
-    entities: Vec<Entity>,
-}
-
-/// Controls how visibility will be managed via [`ClientVisibility`].
-#[derive(Default, Debug, Clone, Copy)]
-pub enum VisibilityPolicy {
-    /// All entities are visible by default and visibility can't be changed.
-    #[default]
-    All,
-    /// All entities are visible by default and should be explicitly registered to be hidden.
-    Blacklist,
-    /// All entities are hidden by default and should be explicitly registered to be visible.
-    Whitelist,
-}
diff --git a/src/core/replication/replication_registry/test_fns.rs b/src/core/replication/replication_registry/test_fns.rs
index 04cb3b45..8c6016e1 100644
--- a/src/core/replication/replication_registry/test_fns.rs
+++ b/src/core/replication/replication_registry/test_fns.rs
@@ -60,7 +60,7 @@ assert!(!entity.contains::<DummyComponent>());
 
 entity.apply_despawn(tick);
 let mut replicated = app.world_mut().query::<&DummyComponent>();
-assert!(replicated.iter(app.world()).next().is_none());
+assert_eq!(replicated.iter(app.world()).len(), 0);
 
 #[derive(Component, Serialize, Deserialize)]
 struct DummyComponent;
diff --git a/src/core/replicon_client.rs b/src/core/replicon_client.rs
index 048447d6..086015cb 100644
--- a/src/core/replicon_client.rs
+++ b/src/core/replicon_client.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 use bytes::Bytes;
 
-use crate::core::ClientId;
+use super::NetworkStats;
 
 /// Stores information about a client independent from the messaging backend.
 ///
@@ -30,10 +30,7 @@ pub struct RepliconClient {
     /// List of sent messages and their channels since the last tick.
     sent_messages: Vec<(u8, Bytes)>,
 
-    rtt: f64,
-    packet_loss: f64,
-    sent_bps: f64,
-    received_bps: f64,
+    stats: NetworkStats,
 }
 
 impl RepliconClient {
@@ -128,10 +125,7 @@ impl RepliconClient {
             }
             self.sent_messages.clear();
 
-            self.rtt = 0.0;
-            self.packet_loss = 0.0;
-            self.sent_bps = 0.0;
-            self.received_bps = 0.0;
+            self.stats = Default::default();
         }
 
         self.status = status;
@@ -150,7 +144,7 @@ impl RepliconClient {
     /// See also [`Self::status`].
     #[inline]
     pub fn is_disconnected(&self) -> bool {
-        matches!(self.status, RepliconClientStatus::Disconnected)
+        self.status == RepliconClientStatus::Disconnected
     }
 
     /// Returns `true` if the client is connecting.
@@ -158,7 +152,7 @@ impl RepliconClient {
     /// See also [`Self::status`].
     #[inline]
     pub fn is_connecting(&self) -> bool {
-        matches!(self.status, RepliconClientStatus::Connecting)
+        self.status == RepliconClientStatus::Connecting
     }
 
     /// Returns `true` if the client is connected.
@@ -166,20 +160,7 @@ impl RepliconClient {
     /// See also [`Self::status`].
     #[inline]
     pub fn is_connected(&self) -> bool {
-        matches!(self.status, RepliconClientStatus::Connected { .. })
-    }
-
-    /// Returns the client's ID.
-    ///
-    /// The client ID is available only if the client state is [`RepliconClientStatus::Connected`].
-    /// See also [`Self::status`].
-    #[inline]
-    pub fn id(&self) -> Option<ClientId> {
-        if let RepliconClientStatus::Connected { client_id } = self.status {
-            client_id
-        } else {
-            None
-        }
+        self.status == RepliconClientStatus::Connected
     }
 
     /// Removes all sent messages, returning them as an iterator with channel.
@@ -215,81 +196,25 @@ impl RepliconClient {
         channel_messages.push(message.into());
     }
 
-    /// Returns the round-time trip in seconds for the connection.
-    ///
-    /// Returns zero if not provided by the backend.
-    pub fn rtt(&self) -> f64 {
-        self.rtt
+    /// Returns network statistic.
+    pub fn stats(&self) -> &NetworkStats {
+        &self.stats
     }
 
-    /// Sets the round-time trip in seconds for the connection.
+    /// Returns a mutable reference to set network statistic.
     ///
     /// <div class="warning">
     ///
     /// Should only be called from the messaging backend.
     ///
     /// </div>
-    pub fn set_rtt(&mut self, rtt: f64) {
-        self.rtt = rtt;
-    }
-
-    /// Returns the packet loss % for the connection.
-    ///
-    /// Returns zero if not provided by the backend.
-    pub fn packet_loss(&self) -> f64 {
-        self.packet_loss
-    }
-
-    /// Sets the packet loss % for the connection.
-    ///
-    /// <div class="warning">
-    ///
-    /// Should only be called from the messaging backend.
-    ///
-    /// </div>
-    pub fn set_packet_loss(&mut self, packet_loss: f64) {
-        self.packet_loss = packet_loss;
-    }
-
-    /// Returns the bytes sent per second for the connection.
-    ///
-    /// Returns zero if not provided by the backend.
-    pub fn sent_bps(&self) -> f64 {
-        self.sent_bps
-    }
-
-    /// Sets the bytes sent per second for the connection.
-    ///
-    /// <div class="warning">
-    ///
-    /// Should only be called from the messaging backend.
-    ///
-    /// </div>
-    pub fn set_sent_bps(&mut self, sent_bps: f64) {
-        self.sent_bps = sent_bps;
-    }
-
-    /// Returns the bytes received per second for the connection.
-    ///
-    /// Returns zero if not provided by the backend.
-    pub fn received_bps(&self) -> f64 {
-        self.received_bps
-    }
-
-    /// Sets the bytes received per second for the connection.
-    ///
-    /// <div class="warning">
-    ///
-    /// Should only be called from the messaging backend.
-    ///
-    /// </div>
-    pub fn set_received_bps(&mut self, received_bps: f64) {
-        self.received_bps = received_bps;
+    pub fn stats_mut(&mut self) -> &mut NetworkStats {
+        &mut self.stats
     }
 }
 
 /// Connection status of the [`RepliconClient`].
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
 pub enum RepliconClientStatus {
     /// Not connected or trying to connect.
     #[default]
@@ -297,8 +222,5 @@ pub enum RepliconClientStatus {
     /// Trying to connect to the server.
     Connecting,
     /// Connected to the server.
-    ///
-    /// Stores the assigned ID if one was assigned by the server.
-    /// Needed only for users to access ID independent from messaging library.
-    Connected { client_id: Option<ClientId> },
+    Connected,
 }
diff --git a/src/core/replicon_server.rs b/src/core/replicon_server.rs
index 15b39d56..42787083 100644
--- a/src/core/replicon_server.rs
+++ b/src/core/replicon_server.rs
@@ -1,8 +1,6 @@
 use bevy::prelude::*;
 use bytes::Bytes;
 
-use crate::core::ClientId;
-
 /// Stores information about the server independent from the messaging backend.
 ///
 /// The messaging backend is responsible for updating this resource:
@@ -24,10 +22,10 @@ pub struct RepliconServer {
     ///
     /// Top index is channel ID.
     /// Inner [`Vec`] stores received messages since the last tick.
-    received_messages: Vec<Vec<(ClientId, Bytes)>>,
+    received_messages: Vec<Vec<(Entity, Bytes)>>,
 
     /// List of sent messages for each channel since the last tick.
-    sent_messages: Vec<(ClientId, u8, Bytes)>,
+    sent_messages: Vec<(Entity, u8, Bytes)>,
 }
 
 impl RepliconServer {
@@ -37,12 +35,12 @@ impl RepliconServer {
     }
 
     /// Removes a disconnected client.
-    pub(crate) fn remove_client(&mut self, client_id: ClientId) {
+    pub(crate) fn remove_client(&mut self, client_entity: Entity) {
         for receive_channel in &mut self.received_messages {
-            receive_channel.retain(|&(sender_id, _)| sender_id != client_id);
+            receive_channel.retain(|&(entity, _)| entity != client_entity);
         }
         self.sent_messages
-            .retain(|&(sender_id, ..)| sender_id != client_id);
+            .retain(|&(entity, ..)| entity != client_entity);
     }
 
     /// Receives all available messages from clients over a channel.
@@ -57,7 +55,7 @@ impl RepliconServer {
     pub fn receive<I: Into<u8>>(
         &mut self,
         channel_id: I,
-    ) -> impl Iterator<Item = (ClientId, Bytes)> + '_ {
+    ) -> impl Iterator<Item = (Entity, Bytes)> + '_ {
         if !self.running {
             // We can't return here because we need to return an empty iterator.
             warn!("trying to receive a message when the server is not running");
@@ -90,7 +88,7 @@ impl RepliconServer {
     /// </div>
     pub fn send<I: Into<u8>, B: Into<Bytes>>(
         &mut self,
-        client_id: ClientId,
+        client_entity: Entity,
         channel_id: I,
         message: B,
     ) {
@@ -104,7 +102,8 @@ impl RepliconServer {
 
         trace!("sending {} bytes over channel {channel_id}", message.len());
 
-        self.sent_messages.push((client_id, channel_id, message));
+        self.sent_messages
+            .push((client_entity, channel_id, message));
     }
 
     /// Marks the server as running or stopped.
@@ -138,19 +137,19 @@ impl RepliconServer {
     /// Used for testing.
     pub(crate) fn retain_sent<F>(&mut self, f: F)
     where
-        F: FnMut(&(ClientId, u8, Bytes)) -> bool,
+        F: FnMut(&(Entity, u8, Bytes)) -> bool,
     {
         self.sent_messages.retain(f)
     }
 
-    /// Removes all sent messages, returning them as an iterator with client ID and channel.
+    /// Removes all sent messages, returning them as an iterator with client entity and channel.
     ///
     /// <div class="warning">
     ///
     /// Should only be called from the messaging backend.
     ///
     /// </div>
-    pub fn drain_sent(&mut self) -> impl Iterator<Item = (ClientId, u8, Bytes)> + '_ {
+    pub fn drain_sent(&mut self) -> impl Iterator<Item = (Entity, u8, Bytes)> + '_ {
         self.sent_messages.drain(..)
     }
 
@@ -163,7 +162,7 @@ impl RepliconServer {
     /// </div>
     pub fn insert_received<I: Into<u8>, B: Into<Bytes>>(
         &mut self,
-        client_id: ClientId,
+        client_entity: Entity,
         channel_id: I,
         message: B,
     ) {
@@ -178,6 +177,6 @@ impl RepliconServer {
             .get_mut(channel_id as usize)
             .unwrap_or_else(|| panic!("server should have a receive channel with id {channel_id}"));
 
-        receive_channel.push((client_id, message.into()));
+        receive_channel.push((client_entity, message.into()));
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index bac41cf5..a9015a97 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -8,7 +8,7 @@ We provide a [`prelude`] module, which exports most of the typically used traits
 The library doesn't provide any I/O, so you need to add a
 [messaging backend](https://github.com/projectharmonia/bevy_replicon#messaging-backends).
 If you want to write an integration for a messaging backend,
-see the documentation for [`RepliconServer`], [`RepliconClient`], [`ClientConnected`] and [`ClientDisconnected`].
+see the documentation for [`RepliconServer`], [`RepliconClient`] and [`ConnectedClient`].
 You can also use `bevy_replicon_renet`, which we maintain, as a reference.
 
 Also depending on your game, you may want to use additional crates. For example, if your game
@@ -95,7 +95,7 @@ fn send_movement(mut movement_events: EventWriter<MovementEvent>) {
 }
 
 fn apply_movement(mut movement_events: EventReader<FromClient<MovementEvent>>) {
-    for FromClient { client_id, event } in movement_events.read() {
+    for FromClient { client_entity, event } in movement_events.read() {
         // Apply user inputs to entities.
         // Since it runs on server, all changes will be replicated back to clients.
     }
@@ -215,6 +215,8 @@ in combination with [network events](#network-events) instead.
 
 </div>
 
+On server connected clients represented as entities with [`ConnectedClient`] component.
+
 ## System sets and conditions
 
 To run a system based on a network condition, use the [`core::common_conditions`] module.
@@ -238,6 +240,9 @@ keep the world in sync.
 To prevent cheating, we do not support replicating from the client. If you need to send
 information from clients to the server, use [events](#network-events).
 
+Replication is enabled by default for all connected clients via [`ReplicatedClient`] component.
+It can be disabled via [`ServerPlugin::replicate_after_connect`] is set to `false`.
+
 ### Marking for replication
 
 By default nothing is replicated. User needs to choose which entities
@@ -421,8 +426,8 @@ fn send_events(mut dummy_events: EventWriter<DummyEvent>) {
 }
 
 fn receive_events(mut dummy_events: EventReader<FromClient<DummyEvent>>) {
-    for FromClient { client_id, event } in dummy_events.read() {
-        info!("received event {event:?} from {client_id:?}");
+    for FromClient { client_entity, event } in dummy_events.read() {
+        info!("received event `{event:?}` from client `{client_entity}`");
     }
 }
 
@@ -430,7 +435,7 @@ fn receive_events(mut dummy_events: EventReader<FromClient<DummyEvent>>) {
 struct DummyEvent;
 ```
 
-We consider the server or a singleplayer session also as a client with ID [`ClientId::SERVER`].
+We consider the server or a singleplayer session also as a client with ID [`Entity::PLACEHOLDER`].
 So you can send such events even on server and [`FromClient`] will be emitted for them too.
 
 If you remove [`client_connected`] condition and replace [`server_running`] with
@@ -486,7 +491,7 @@ fn send_events(mut commands: Commands) {
 }
 
 fn receive_events(trigger: Trigger<FromClient<DummyEvent>>) {
-    info!("received event {:?} from {:?}", **trigger, trigger.client_id);
+    info!("received event `{:?}` from client `{}`", **trigger, trigger.client_entity);
 }
 # #[derive(Event, Debug, Deserialize, Serialize)]
 # struct DummyEvent;
@@ -535,7 +540,7 @@ struct DummyEvent;
 ```
 
 Just like events sent from the client, you can send these events on the server or
-in singleplayer and they will appear locally as regular events (if [`ClientId::SERVER`] is not excluded
+in singleplayer and they will appear locally as regular events (if [`Entity::PLACEHOLDER`] is not excluded
 from the send list). So the same trick with run conditions will work.
 
 If the event contains an entity, then
@@ -582,13 +587,12 @@ Just like with components, all networked events should be registered in the same
 You can control which parts of the world are visible for each client by setting visibility policy
 in [`ServerPlugin`] to [`VisibilityPolicy::Whitelist`] or [`VisibilityPolicy::Blacklist`].
 
-In order to set which entity is visible, you need to use the [`ReplicatedClients`] resource
-to obtain the [`ReplicatedClient`] for a specific client and get its [`ClientVisibility`]:
+In order to set which entity is visible, you need to use the [`ClientVisibility`] component
+on connected clients.
 
 ```
 # use bevy::prelude::*;
 # use bevy_replicon::prelude::*;
-# use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 app.add_plugins((
     MinimalPlugins,
@@ -601,27 +605,26 @@ app.add_plugins((
 
 /// Disables the visibility of other players' entities that are further away than the visible distance.
 fn update_visibility(
-    mut replicated_clients: ResMut<ReplicatedClients>,
-    moved_players: Query<(&Transform, &Player), Changed<Transform>>,
-    other_players: Query<(Entity, &Transform, &Player)>,
+    mut clients: Query<&mut ClientVisibility>,
+    moved_players: Query<(&Transform, &PlayerOwner), Changed<Transform>>,
+    other_players: Query<(Entity, &Transform, &PlayerOwner)>,
 ) {
-    for (moved_transform, moved_player) in &moved_players {
-        let client = replicated_clients.client_mut(moved_player.0);
+    for (moved_transform, &owner) in &moved_players {
+        let mut visibility = clients.get_mut(*owner).unwrap();
         for (entity, transform, _) in other_players
             .iter()
-            .filter(|(.., player)| player.0 != moved_player.0)
+            .filter(|(.., &other_owner)| *other_owner != *owner)
         {
             const VISIBLE_DISTANCE: f32 = 100.0;
             let distance = moved_transform.translation.distance(transform.translation);
-            client
-                .visibility_mut()
-                .set_visibility(entity, distance < VISIBLE_DISTANCE);
+            visibility.set_visibility(entity, distance < VISIBLE_DISTANCE);
         }
     }
 }
 
-#[derive(Component, Deserialize, Serialize)]
-struct Player(ClientId);
+/// Points to client entity.
+#[derive(Component, Deref, Clone, Copy)]
+struct PlayerOwner(Entity);
 ```
 
 For a higher level API consider using [`bevy_replicon_attributes`](https://docs.rs/bevy_replicon_attributes).
@@ -678,7 +681,6 @@ pub mod prelude {
         core::{
             channels::{ChannelKind, RepliconChannel, RepliconChannels},
             common_conditions::*,
-            connected_clients::ConnectedClients,
             event::{
                 client_event::{ClientEventAppExt, FromClient},
                 client_trigger::{ClientTriggerAppExt, ClientTriggerExt},
@@ -686,17 +688,11 @@ pub mod prelude {
                 server_trigger::{ServerTriggerAppExt, ServerTriggerExt},
             },
             replication::{
-                command_markers::AppMarkerExt,
-                replicated_clients::{
-                    client_visibility::ClientVisibility, ReplicatedClient, ReplicatedClients,
-                    VisibilityPolicy,
-                },
-                replication_rules::AppRuleExt,
-                Replicated,
+                command_markers::AppMarkerExt, replication_rules::AppRuleExt, Replicated,
             },
             replicon_client::{RepliconClient, RepliconClientStatus},
             replicon_server::RepliconServer,
-            BackendError, ClientId, DisconnectReason, RepliconCorePlugin,
+            ConnectedClient, RepliconCorePlugin,
         },
         RepliconPlugins,
     };
@@ -708,9 +704,9 @@ pub mod prelude {
 
     #[cfg(feature = "server")]
     pub use super::server::{
-        client_entity_map::{ClientEntityMap, ClientMapping},
-        event::ServerEventPlugin,
-        ClientConnected, ClientDisconnected, ServerPlugin, ServerSet, StartReplication, TickPolicy,
+        client_entity_map::ClientEntityMap, client_visibility::ClientVisibility,
+        event::ServerEventPlugin, ReplicatedClient, ServerPlugin, ServerSet, TickPolicy,
+        VisibilityPolicy,
     };
 
     #[cfg(feature = "client_diagnostics")]
diff --git a/src/server.rs b/src/server.rs
index e6148f74..58db2b90 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,4 +1,5 @@
 pub mod client_entity_map;
+pub mod client_visibility;
 pub(super) mod despawn_buffer;
 pub mod event;
 pub(super) mod removal_buffer;
@@ -18,14 +19,11 @@ use bytes::Buf;
 
 use crate::core::{
     channels::{ReplicationChannel, RepliconChannels},
-    common_conditions::{server_just_stopped, server_running},
-    connected_clients::ConnectedClients,
+    common_conditions::*,
     event::server_event::BufferedServerEvents,
     postcard_utils,
     replication::{
-        replicated_clients::{
-            client_visibility::Visibility, ClientBuffers, ReplicatedClients, VisibilityPolicy,
-        },
+        client_ticks::{ClientTicks, EntityBuffer},
         replication_registry::{
             component_fns::ComponentFns, ctx::SerializeCtx, rule_fns::UntypedRuleFns,
             ReplicationRegistry,
@@ -34,12 +32,15 @@ use crate::core::{
     },
     replicon_server::RepliconServer,
     replicon_tick::RepliconTick,
-    ClientId, DisconnectReason,
+    ConnectedClient,
 };
 use client_entity_map::ClientEntityMap;
+use client_visibility::{ClientVisibility, Visibility};
 use despawn_buffer::{DespawnBuffer, DespawnBufferPlugin};
 use removal_buffer::{RemovalBuffer, RemovalBufferPlugin};
-use replication_messages::{serialized_data::SerializedData, ReplicationMessages};
+use replication_messages::{
+    mutate_message::MutateMessage, serialized_data::SerializedData, update_message::UpdateMessage,
+};
 use server_tick::ServerTick;
 use server_world::{ReplicatedComponent, ServerWorld};
 
@@ -57,7 +58,7 @@ pub struct ServerPlugin {
 
     /// If enabled, replication will be started automatically after connection.
     ///
-    /// If disabled, replication should be started manually by sending the [`StartReplication`] event.
+    /// If disabled, replication should be started manually by inserting [`ReplicatedClient`] on the client entity.
     /// Until replication has started, the client and server can still exchange network events.
     ///
     /// All events from server will be buffered on client until replication starts, except the ones marked as independent.
@@ -84,22 +85,11 @@ impl Plugin for ServerPlugin {
         app.add_plugins((DespawnBufferPlugin, RemovalBufferPlugin))
             .init_resource::<RepliconServer>()
             .init_resource::<ServerTick>()
-            .init_resource::<ClientBuffers>()
-            .init_resource::<ClientEntityMap>()
-            .init_resource::<ConnectedClients>()
-            .insert_resource(ReplicatedClients::new(
-                self.visibility_policy,
-                self.replicate_after_connect,
-            ))
+            .init_resource::<EntityBuffer>()
             .init_resource::<BufferedServerEvents>()
             .configure_sets(
                 PreUpdate,
-                (
-                    ServerSet::ReceivePackets,
-                    ServerSet::TriggerConnectionEvents,
-                    ServerSet::Receive,
-                )
-                    .chain(),
+                (ServerSet::ReceivePackets, ServerSet::Receive).chain(),
             )
             .configure_sets(
                 PostUpdate,
@@ -112,7 +102,6 @@ impl Plugin for ServerPlugin {
             )
             .add_observer(handle_connects)
             .add_observer(handle_disconnects)
-            .add_observer(enable_replication)
             .add_systems(Startup, setup_channels)
             .add_systems(
                 PreUpdate,
@@ -157,6 +146,17 @@ impl Plugin for ServerPlugin {
             }
             TickPolicy::Manual => (),
         }
+
+        let visibility = match self.visibility_policy {
+            VisibilityPolicy::All => ClientVisibility::all,
+            VisibilityPolicy::Blacklist => ClientVisibility::blacklist,
+            VisibilityPolicy::Whitelist => ClientVisibility::whitelist,
+        };
+        app.register_required_components_with::<ReplicatedClient, _>(visibility);
+
+        if self.replicate_after_connect {
+            app.register_required_components::<ConnectedClient, ReplicatedClient>();
+        }
     }
 }
 
@@ -171,52 +171,30 @@ pub fn increment_tick(mut server_tick: ResMut<ServerTick>) {
 }
 
 fn handle_connects(
-    trigger: Trigger<ClientConnected>,
-    mut connected_clients: ResMut<ConnectedClients>,
-    mut replicated_clients: ResMut<ReplicatedClients>,
+    trigger: Trigger<OnAdd, ConnectedClient>,
     mut buffered_events: ResMut<BufferedServerEvents>,
-    mut client_buffers: ResMut<ClientBuffers>,
 ) {
-    debug!("`{:?}` connected", trigger.client_id);
-    connected_clients.add(trigger.client_id);
-    if replicated_clients.replicate_after_connect() {
-        replicated_clients.add(&mut client_buffers, trigger.client_id);
-    }
-    buffered_events.exclude_client(trigger.client_id);
+    debug!("client `{}` connected", trigger.entity());
+    buffered_events.exclude_client(trigger.entity());
 }
 
 fn handle_disconnects(
-    trigger: Trigger<ClientDisconnected>,
-    mut entity_map: ResMut<ClientEntityMap>,
-    mut connected_clients: ResMut<ConnectedClients>,
-    mut replicated_clients: ResMut<ReplicatedClients>,
+    trigger: Trigger<OnRemove, ConnectedClient>,
     mut server: ResMut<RepliconServer>,
-    mut client_buffers: ResMut<ClientBuffers>,
 ) {
-    debug!("`{:?}` disconnected: {}", trigger.client_id, trigger.reason);
-    entity_map.0.remove(&trigger.client_id);
-    connected_clients.remove(trigger.client_id);
-    replicated_clients.remove(&mut client_buffers, trigger.client_id);
-    server.remove_client(trigger.client_id);
-}
-
-fn enable_replication(
-    trigger: Trigger<StartReplication>,
-    mut replicated_clients: ResMut<ReplicatedClients>,
-    mut client_buffers: ResMut<ClientBuffers>,
-) {
-    replicated_clients.add(&mut client_buffers, **trigger);
+    debug!("client `{}` disconnected", trigger.entity());
+    server.remove_client(trigger.entity());
 }
 
 fn cleanup_acks(
     mutations_timeout: Duration,
-) -> impl FnMut(ResMut<ReplicatedClients>, ResMut<ClientBuffers>, Res<Time>) {
-    move |mut replicated_clients: ResMut<ReplicatedClients>,
-          mut client_buffers: ResMut<ClientBuffers>,
+) -> impl FnMut(Query<&mut ClientTicks>, ResMut<EntityBuffer>, Res<Time>) {
+    move |mut clients: Query<&mut ClientTicks>,
+          mut entity_buffer: ResMut<EntityBuffer>,
           time: Res<Time>| {
         let min_timestamp = time.elapsed().saturating_sub(mutations_timeout);
-        for client in replicated_clients.iter_mut() {
-            client.cleanup_older_mutations(&mut client_buffers, min_timestamp);
+        for mut ticks in &mut clients {
+            ticks.cleanup_older_mutations(&mut entity_buffer, min_timestamp);
         }
     }
 }
@@ -224,21 +202,26 @@ fn cleanup_acks(
 fn receive_acks(
     change_tick: SystemChangeTick,
     mut server: ResMut<RepliconServer>,
-    mut replicated_clients: ResMut<ReplicatedClients>,
-    mut client_buffers: ResMut<ClientBuffers>,
+    mut clients: Query<&mut ClientTicks>,
+    mut entity_buffer: ResMut<EntityBuffer>,
 ) {
-    for (client_id, mut message) in server.receive(ReplicationChannel::Updates) {
+    for (entity, mut message) in server.receive(ReplicationChannel::Updates) {
         while message.has_remaining() {
             match postcard_utils::from_buf(&mut message) {
                 Ok(mutate_index) => {
-                    let client = replicated_clients.client_mut(client_id);
-                    client.ack_mutate_message(
-                        &mut client_buffers,
+                    let mut ticks = clients.get_mut(entity).unwrap_or_else(|_| {
+                        panic!("messages from client `{entity}` should have been removed on disconnect")
+                    });
+                    ticks.ack_mutate_message(
+                        entity,
+                        &mut entity_buffer,
                         change_tick.this_run(),
                         mutate_index,
                     );
                 }
-                Err(e) => debug!("unable to deserialize mutate index from {client_id:?}: {e}"),
+                Err(e) => {
+                    debug!("unable to deserialize mutate index from client `{entity}`: {e}")
+                }
             }
         }
     }
@@ -247,13 +230,18 @@ fn receive_acks(
 /// Collects [`ReplicationMessages`] and sends them.
 pub(super) fn send_replication(
     mut serialized: Local<SerializedData>,
-    mut messages: Local<ReplicationMessages>,
     change_tick: SystemChangeTick,
     world: ServerWorld,
-    mut replicated_clients: ResMut<ReplicatedClients>,
+    mut clients: Query<(
+        Entity,
+        &mut UpdateMessage,
+        &mut MutateMessage,
+        &mut ClientEntityMap,
+        &mut ClientTicks,
+        &mut ClientVisibility,
+    )>,
     mut removal_buffer: ResMut<RemovalBuffer>,
-    mut client_buffers: ResMut<ClientBuffers>,
-    mut entity_map: ResMut<ClientEntityMap>,
+    mut entity_buffer: ResMut<EntityBuffer>,
     mut despawn_buffer: ResMut<DespawnBuffer>,
     mut server: ResMut<RepliconServer>,
     track_mutate_messages: Res<TrackMutateMessages>,
@@ -261,30 +249,17 @@ pub(super) fn send_replication(
     server_tick: Res<ServerTick>,
     time: Res<Time>,
 ) -> postcard::Result<()> {
-    messages.reset(replicated_clients.len());
+    for (_, mut mutate_message, mut update_message, ..) in &mut clients {
+        update_message.clear();
+        mutate_message.clear();
+    }
 
-    collect_mappings(
-        &mut messages,
-        &mut serialized,
-        &replicated_clients,
-        &mut entity_map,
-    )?;
-    collect_despawns(
-        &mut messages,
-        &mut serialized,
-        &mut replicated_clients,
-        &mut despawn_buffer,
-    )?;
-    collect_removals(
-        &mut messages,
-        &mut serialized,
-        &replicated_clients,
-        &removal_buffer,
-    )?;
+    collect_mappings(&mut serialized, &mut clients)?;
+    collect_despawns(&mut serialized, &mut clients, &mut despawn_buffer)?;
+    collect_removals(&mut serialized, &mut clients, &removal_buffer)?;
     collect_changes(
-        &mut messages,
         &mut serialized,
-        &mut replicated_clients,
+        &mut clients,
         &registry,
         &removal_buffer,
         &world,
@@ -294,13 +269,12 @@ pub(super) fn send_replication(
     removal_buffer.clear();
 
     send_messages(
-        &mut messages,
-        &mut replicated_clients,
+        &mut clients,
         &mut server,
         **server_tick,
         **track_mutate_messages,
         &mut serialized,
-        &mut client_buffers,
+        &mut entity_buffer,
         change_tick,
         &time,
     )?;
@@ -310,41 +284,46 @@ pub(super) fn send_replication(
 }
 
 fn reset(
+    mut commands: Commands,
     mut server_tick: ResMut<ServerTick>,
-    mut entity_map: ResMut<ClientEntityMap>,
-    mut replicated_clients: ResMut<ReplicatedClients>,
-    mut client_buffers: ResMut<ClientBuffers>,
+    clients: Query<Entity, With<ConnectedClient>>,
     mut buffered_events: ResMut<BufferedServerEvents>,
 ) {
     *server_tick = Default::default();
-    entity_map.0.clear();
-    replicated_clients.clear(&mut client_buffers);
     buffered_events.clear();
+    for entity in &clients {
+        commands.entity(entity).despawn();
+    }
 }
 
 fn send_messages(
-    messages: &mut ReplicationMessages,
-    replicated_clients: &mut ReplicatedClients,
+    clients: &mut Query<(
+        Entity,
+        &mut UpdateMessage,
+        &mut MutateMessage,
+        &mut ClientEntityMap,
+        &mut ClientTicks,
+        &mut ClientVisibility,
+    )>,
     server: &mut RepliconServer,
     server_tick: RepliconTick,
     track_mutate_messages: bool,
     serialized: &mut SerializedData,
-    client_buffers: &mut ClientBuffers,
+    entity_buffer: &mut EntityBuffer,
     change_tick: SystemChangeTick,
     time: &Time,
 ) -> postcard::Result<()> {
     let mut server_tick_range = None;
-    for ((update_message, mutate_message), client) in
-        messages.iter_mut().zip(replicated_clients.iter_mut())
+    for (client_entity, update_message, mut mutate_message, _, mut ticks, mut visibility) in clients
     {
         if !update_message.is_empty() {
-            client.set_update_tick(server_tick);
+            ticks.set_update_tick(server_tick);
             let server_tick = write_tick_cached(&mut server_tick_range, serialized, server_tick)?;
 
-            trace!("sending update message to {:?}", client.id());
-            update_message.send(server, client, serialized, server_tick)?;
+            trace!("sending update message to client `{client_entity}`");
+            update_message.send(server, client_entity, serialized, server_tick)?;
         } else {
-            trace!("no updates to send for {:?}", client.id());
+            trace!("no updates to send for client `{client_entity}`");
         }
 
         if !mutate_message.is_empty() || track_mutate_messages {
@@ -352,23 +331,21 @@ fn send_messages(
 
             let messages_count = mutate_message.send(
                 server,
-                client,
-                client_buffers,
+                client_entity,
+                &mut ticks,
+                entity_buffer,
                 serialized,
                 track_mutate_messages,
                 server_tick,
                 change_tick.this_run(),
                 time.elapsed(),
             )?;
-            trace!(
-                "sending {messages_count} mutate message(s) to {:?}",
-                client.id()
-            );
+            trace!("sending {messages_count} mutate message(s) to client `{client_entity}`");
         } else {
-            trace!("no mutations to send for {:?}", client.id());
+            trace!("no mutations to send for client `{client_entity}`");
         }
 
-        client.visibility_mut().update();
+        visibility.update();
     }
 
     Ok(())
@@ -376,17 +353,20 @@ fn send_messages(
 
 /// Collects and writes any new entity mappings that happened in this tick.
 fn collect_mappings(
-    messages: &mut ReplicationMessages,
     serialized: &mut SerializedData,
-    replicated_clients: &ReplicatedClients,
-    entity_map: &mut ClientEntityMap,
+    clients: &mut Query<(
+        Entity,
+        &mut UpdateMessage,
+        &mut MutateMessage,
+        &mut ClientEntityMap,
+        &mut ClientTicks,
+        &mut ClientVisibility,
+    )>,
 ) -> postcard::Result<()> {
-    for ((message, _), client) in messages.iter_mut().zip(replicated_clients.iter()) {
-        if let Some(mappings) = entity_map.0.get_mut(&client.id()) {
-            let len = mappings.len();
-            let mappings = serialized.write_mappings(mappings.drain(..))?;
-            message.set_mappings(mappings, len);
-        }
+    for (_, mut message, _, mut entity_map, ..) in clients {
+        let len = entity_map.len();
+        let mappings = serialized.write_mappings(entity_map.0.drain(..))?;
+        message.set_mappings(mappings, len);
     }
 
     Ok(())
@@ -394,25 +374,33 @@ fn collect_mappings(
 
 /// Collect entity despawns from this tick into update messages.
 fn collect_despawns(
-    messages: &mut ReplicationMessages,
     serialized: &mut SerializedData,
-    replicated_clients: &mut ReplicatedClients,
+    clients: &mut Query<(
+        Entity,
+        &mut UpdateMessage,
+        &mut MutateMessage,
+        &mut ClientEntityMap,
+        &mut ClientTicks,
+        &mut ClientVisibility,
+    )>,
     despawn_buffer: &mut DespawnBuffer,
 ) -> postcard::Result<()> {
     for entity in despawn_buffer.drain(..) {
         let entity_range = serialized.write_entity(entity)?;
-        for ((message, _), client) in messages.iter_mut().zip(replicated_clients.iter_mut()) {
-            if client.visibility().is_visible(entity) {
+        for (_, mut message, .., mut ticks, mut visibility) in &mut *clients {
+            if visibility.is_visible(entity) {
                 message.add_despawn(entity_range.clone());
             }
-            client.remove_despawned(entity);
+            visibility.remove_despawned(entity);
+            ticks.remove_entity(entity);
         }
     }
 
-    for ((message, _), client) in messages.iter_mut().zip(replicated_clients.iter_mut()) {
-        for entity in client.drain_lost_visibility() {
+    for (_, mut message, .., mut ticks, mut visibility) in clients {
+        for entity in visibility.drain_lost() {
             let entity_range = serialized.write_entity(entity)?;
             message.add_despawn(entity_range);
+            ticks.remove_entity(entity);
         }
     }
 
@@ -421,17 +409,23 @@ fn collect_despawns(
 
 /// Collects component removals from this tick into update messages.
 fn collect_removals(
-    messages: &mut ReplicationMessages,
     serialized: &mut SerializedData,
-    replicated_clients: &ReplicatedClients,
+    clients: &mut Query<(
+        Entity,
+        &mut UpdateMessage,
+        &mut MutateMessage,
+        &mut ClientEntityMap,
+        &mut ClientTicks,
+        &mut ClientVisibility,
+    )>,
     removal_buffer: &RemovalBuffer,
 ) -> postcard::Result<()> {
     for (&entity, remove_ids) in removal_buffer.iter() {
         let entity_range = serialized.write_entity(entity)?;
         let ids_len = remove_ids.len();
         let fn_ids = serialized.write_fn_ids(remove_ids.iter().map(|&(_, fns_id)| fns_id))?;
-        for ((message, _), client) in messages.iter_mut().zip(replicated_clients.iter()) {
-            if client.visibility().is_visible(entity) {
+        for (_, mut message, .., visibility) in &mut *clients {
+            if visibility.is_visible(entity) {
                 message.add_removals(entity_range.clone(), ids_len, fn_ids.clone());
             }
         }
@@ -442,9 +436,15 @@ fn collect_removals(
 
 /// Collects component changes from this tick into update and mutate messages since the last entity tick.
 fn collect_changes(
-    messages: &mut ReplicationMessages,
     serialized: &mut SerializedData,
-    replicated_clients: &mut ReplicatedClients,
+    clients: &mut Query<(
+        Entity,
+        &mut UpdateMessage,
+        &mut MutateMessage,
+        &mut ClientEntityMap,
+        &mut ClientTicks,
+        &mut ClientVisibility,
+    )>,
     registry: &ReplicationRegistry,
     removal_buffer: &RemovalBuffer,
     world: &ServerWorld,
@@ -454,10 +454,8 @@ fn collect_changes(
     for (archetype, replicated_archetype) in world.iter_archetypes() {
         for entity in archetype.entities() {
             let mut entity_range = None;
-            for ((update_message, mutate_message), client) in
-                messages.iter_mut().zip(replicated_clients.iter())
-            {
-                let visibility = client.visibility().state(entity.id());
+            for (_, mut update_message, mut mutate_message, .., visibility) in &mut *clients {
+                let visibility = visibility.state(entity.id());
                 update_message.start_entity_changes(visibility);
                 mutate_message.start_entity_mutations();
             }
@@ -496,14 +494,14 @@ fn collect_changes(
                     component_id,
                 };
                 let mut component_range = None;
-                for ((update_message, mutate_message), client) in
-                    messages.iter_mut().zip(replicated_clients.iter())
+                for (_, mut update_message, mut mutate_message, .., client_ticks, _) in
+                    &mut *clients
                 {
                     if update_message.entity_visibility() == Visibility::Hidden {
                         continue;
                     }
 
-                    if let Some(tick) = client
+                    if let Some(tick) = client_ticks
                         .mutation_tick(entity.id())
                         .filter(|_| !marker_added)
                         .filter(|_| update_message.entity_visibility() != Visibility::Gained)
@@ -549,9 +547,7 @@ fn collect_changes(
                 }
             }
 
-            for ((update_message, mutate_message), client) in
-                messages.iter_mut().zip(replicated_clients.iter_mut())
-            {
+            for (_, mut update_message, mut mutate_message, .., mut ticks, _) in &mut *clients {
                 let visibility = update_message.entity_visibility();
                 if visibility == Visibility::Hidden {
                     continue;
@@ -564,8 +560,8 @@ fn collect_changes(
                 {
                     // If there is any insertion, removal, or it's a new entity for a client, include all mutations
                     // into update message and bump the last acknowledged tick to keep entity updates atomic.
-                    update_message.take_mutations(mutate_message);
-                    client.set_mutation_tick(entity.id(), change_tick.this_run());
+                    update_message.take_mutations(&mut mutate_message);
+                    ticks.set_mutation_tick(entity.id(), change_tick.this_run());
                 }
 
                 if new_entity && !update_message.entity_written() {
@@ -648,14 +644,6 @@ pub enum ServerSet {
     ///
     /// Runs in [`PreUpdate`].
     ReceivePackets,
-    /// Systems that trigger [`ClientConnected`] and [`ClientDisconnected`].
-    ///
-    /// The messaging backend should convert its own server events in this set.
-    ///
-    /// Needed only for backends that use batched events instead of triggers.
-    ///
-    /// Runs in [`PreUpdate`].
-    TriggerConnectionEvents,
     /// Systems that receive data from [`RepliconServer`].
     ///
     /// Used by `bevy_replicon`.
@@ -701,31 +689,24 @@ pub enum TickPolicy {
     Manual,
 }
 
-/// Triggered on connection on the server.
+/// Marker that enables replication for client entity.
 ///
-/// The messaging backend is responsible for triggering.
+/// If [`ServerPlugin::replicate_after_connect`] is set, it will be marked as required
+/// for [`ConnectedClient`].
 ///
-/// See also [`ClientDisconnected`] and [`Trigger`].
-#[derive(Event, Debug, Clone, Copy)]
-pub struct ClientConnected {
-    pub client_id: ClientId,
+/// Pausing replication by temporarily removing this component is not supported.
+#[derive(Component, Default)]
+#[require(ClientTicks, ClientEntityMap, UpdateMessage, MutateMessage)]
+pub struct ReplicatedClient;
+
+/// Controls how visibility will be managed via [`ClientVisibility`].
+#[derive(Default, Debug, Clone, Copy)]
+pub enum VisibilityPolicy {
+    /// All entities are visible by default and visibility can't be changed.
+    #[default]
+    All,
+    /// All entities are visible by default and should be explicitly registered to be hidden.
+    Blacklist,
+    /// All entities are hidden by default and should be explicitly registered to be visible.
+    Whitelist,
 }
-
-/// Triggered on disconnection on the server.
-///
-/// The messaging backend is responsible for triggering.
-///
-/// See also [`ClientConnected`] and [`Trigger`].
-#[derive(Event, Debug)]
-pub struct ClientDisconnected {
-    pub client_id: ClientId,
-    pub reason: DisconnectReason,
-}
-
-/// Triggers replication for a connected client.
-///
-/// This event needs to be triggered manually if [`ServerPlugin::replicate_after_connect`] is set to `false`.
-///
-/// See also [`Trigger`].
-#[derive(Debug, Clone, Copy, Event, Deref)]
-pub struct StartReplication(pub ClientId);
diff --git a/src/server/client_entity_map.rs b/src/server/client_entity_map.rs
index 1bab796d..759d2c72 100644
--- a/src/server/client_entity_map.rs
+++ b/src/server/client_entity_map.rs
@@ -1,6 +1,4 @@
-use bevy::{prelude::*, utils::HashMap};
-
-use crate::core::ClientId;
+use bevy::prelude::*;
 
 /**
 A resource that exists on the server for mapping server entities to
@@ -13,7 +11,7 @@ then match up that entity with the eventual replicated server spawn, rather than
 a brand new entity on the client.
 
 In this situation, the client can send the server its pre-spawned entity id, then the server can spawn its own entity
-and inject the [`ClientMapping`] into its [`ClientEntityMap`].
+and inject the mapping into its [`ClientEntityMap`].
 
 Replication packets will send a list of such mappings to clients, which will
 be inserted into the client's [`ServerEntityMap`](crate::core::server_entity_map::ServerEntityMap). Using replication
@@ -45,18 +43,12 @@ fn shoot_bullet(mut commands: Commands, mut bullet_events: EventWriter<SpawnBull
 fn confirm_bullet(
     mut commands: Commands,
     mut bullet_events: EventReader<FromClient<SpawnBullet>>,
-    mut entity_map: ResMut<ClientEntityMap>,
+    mut clients: Query<&mut ClientEntityMap>,
 ) {
-    for FromClient { client_id, event } in bullet_events.read() {
+    for event in bullet_events.read() {
+        let mut entity_map = clients.get_mut(event.client_entity).unwrap();
         let server_entity = commands.spawn(Bullet).id(); // You can insert more components, they will be sent to the client's entity correctly.
-
-        entity_map.insert(
-            *client_id,
-            ClientMapping {
-                server_entity,
-                client_entity: event.0,
-            },
-        );
+        entity_map.insert(server_entity, event.0);
     }
 }
 ```
@@ -69,26 +61,16 @@ client entity.
 If client's original entity is not found, a new entity will be spawned on the client,
 just the same as when no client entity is provided.
 **/
-#[derive(Resource, Debug, Default, Deref)]
-pub struct ClientEntityMap(pub(super) HashMap<ClientId, Vec<ClientMapping>>);
+#[derive(Debug, Default, Deref, Component)]
+pub struct ClientEntityMap(pub(super) Vec<(Entity, Entity)>);
 
 impl ClientEntityMap {
-    /// Registers `mapping` for a client entity pre-spawned by the specified client.
+    /// Registers a mapping from server to client entity.
     ///
     /// This will be sent as part of replication data and added to the client's
     /// [`ServerEntityMap`](crate::core::server_entity_map::ServerEntityMap).
-    pub fn insert(&mut self, client_id: ClientId, mapping: ClientMapping) {
-        debug!(
-            "mapping `{}` to `{}` for `{client_id:?}`",
-            mapping.client_entity, mapping.server_entity
-        );
-        self.0.entry(client_id).or_default().push(mapping);
+    pub fn insert(&mut self, server_entity: Entity, client_entity: Entity) {
+        debug!("mapping server's `{server_entity}` to client's `{client_entity}`");
+        self.0.push((server_entity, client_entity));
     }
 }
-
-/// Stores the server entity corresponding to a client's pre-spawned entity.
-#[derive(Debug)]
-pub struct ClientMapping {
-    pub server_entity: Entity,
-    pub client_entity: Entity,
-}
diff --git a/src/core/replication/replicated_clients/client_visibility.rs b/src/server/client_visibility.rs
similarity index 89%
rename from src/core/replication/replicated_clients/client_visibility.rs
rename to src/server/client_visibility.rs
index 021ba697..627c797d 100644
--- a/src/core/replication/replicated_clients/client_visibility.rs
+++ b/src/server/client_visibility.rs
@@ -7,64 +7,45 @@ use bevy::{
 use super::VisibilityPolicy;
 
 /// Entity visibility settings for a client.
+///
+/// Present on connected clients after [`ReplicatedClient`](super::ReplicatedClient) insertion.
+#[derive(Component)]
 pub struct ClientVisibility {
+    /// Wrapped enum to make its fields private.
     filter: VisibilityFilter,
 }
 
 impl ClientVisibility {
-    /// Creates a new instance based on the preconfigured policy.
-    pub(super) fn new(policy: VisibilityPolicy) -> Self {
-        match policy {
-            VisibilityPolicy::All => Self::with_filter(VisibilityFilter::All),
-            VisibilityPolicy::Blacklist => Self::with_filter(VisibilityFilter::Blacklist {
-                list: Default::default(),
-                added: Default::default(),
-                removed: Default::default(),
-            }),
-            VisibilityPolicy::Whitelist => Self::with_filter(VisibilityFilter::Whitelist {
+    pub(super) fn all() -> Self {
+        Self {
+            filter: VisibilityFilter::All,
+        }
+    }
+
+    pub(super) fn blacklist() -> Self {
+        Self {
+            filter: VisibilityFilter::Blacklist {
                 list: Default::default(),
                 added: Default::default(),
                 removed: Default::default(),
-            }),
+            },
         }
     }
 
-    /// Creates a new instance with a specific filter.
-    fn with_filter(filter: VisibilityFilter) -> Self {
-        Self { filter }
-    }
-
-    /// Resets the filter state to as it was after [`Self::new`].
-    ///
-    /// `cached_visibility` remains untouched.
-    pub(super) fn clear(&mut self) {
-        match &mut self.filter {
-            VisibilityFilter::All => (),
-            VisibilityFilter::Blacklist {
-                list,
-                added,
-                removed,
-            } => {
-                list.clear();
-                added.clear();
-                removed.clear();
-            }
-            VisibilityFilter::Whitelist {
-                list,
-                added,
-                removed,
-            } => {
-                list.clear();
-                added.clear();
-                removed.clear();
-            }
+    pub(super) fn whitelist() -> Self {
+        Self {
+            filter: VisibilityFilter::Whitelist {
+                list: Default::default(),
+                added: Default::default(),
+                removed: Default::default(),
+            },
         }
     }
 
     /// Updates list information and its sets based on the filter.
     ///
     /// Should be called after each tick.
-    pub(crate) fn update(&mut self) {
+    pub(super) fn update(&mut self) {
         match &mut self.filter {
             VisibilityFilter::All => (),
             VisibilityFilter::Blacklist {
@@ -226,7 +207,7 @@ impl ClientVisibility {
     }
 
     /// Returns visibility of a specific entity.
-    pub(crate) fn state(&self, entity: Entity) -> Visibility {
+    pub(super) fn state(&self, entity: Entity) -> Visibility {
         match &self.filter {
             VisibilityFilter::All => Visibility::Visible,
             VisibilityFilter::Blacklist { list, .. } => match list.get(&entity) {
@@ -329,7 +310,7 @@ mod tests {
 
     #[test]
     fn all() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::All);
+        let mut visibility = ClientVisibility::all();
         assert!(visibility.is_visible(Entity::PLACEHOLDER));
 
         visibility.set_visibility(Entity::PLACEHOLDER, true);
@@ -344,7 +325,7 @@ mod tests {
 
     #[test]
     fn blacklist_insertion() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Blacklist);
+        let mut visibility = ClientVisibility::blacklist();
         visibility.set_visibility(Entity::PLACEHOLDER, false);
         assert!(!visibility.is_visible(Entity::PLACEHOLDER));
 
@@ -379,7 +360,7 @@ mod tests {
 
     #[test]
     fn blacklist_empty_removal() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Blacklist);
+        let mut visibility = ClientVisibility::blacklist();
         assert!(visibility.is_visible(Entity::PLACEHOLDER));
 
         visibility.set_visibility(Entity::PLACEHOLDER, true);
@@ -401,7 +382,7 @@ mod tests {
 
     #[test]
     fn blacklist_removal() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Blacklist);
+        let mut visibility = ClientVisibility::blacklist();
         visibility.set_visibility(Entity::PLACEHOLDER, false);
         visibility.update();
         visibility.set_visibility(Entity::PLACEHOLDER, true);
@@ -438,7 +419,7 @@ mod tests {
 
     #[test]
     fn blacklist_insertion_removal() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Blacklist);
+        let mut visibility = ClientVisibility::blacklist();
 
         // Insert and remove from the list.
         visibility.set_visibility(Entity::PLACEHOLDER, false);
@@ -461,7 +442,7 @@ mod tests {
 
     #[test]
     fn blacklist_duplicate_insertion() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Blacklist);
+        let mut visibility = ClientVisibility::blacklist();
         visibility.set_visibility(Entity::PLACEHOLDER, false);
         visibility.update();
 
@@ -485,7 +466,7 @@ mod tests {
 
     #[test]
     fn whitelist_insertion() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Whitelist);
+        let mut visibility = ClientVisibility::whitelist();
         visibility.set_visibility(Entity::PLACEHOLDER, true);
         assert!(visibility.is_visible(Entity::PLACEHOLDER));
 
@@ -520,7 +501,7 @@ mod tests {
 
     #[test]
     fn whitelist_empty_removal() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Whitelist);
+        let mut visibility = ClientVisibility::whitelist();
         assert!(!visibility.is_visible(Entity::PLACEHOLDER));
 
         visibility.set_visibility(Entity::PLACEHOLDER, false);
@@ -542,7 +523,7 @@ mod tests {
 
     #[test]
     fn whitelist_removal() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Whitelist);
+        let mut visibility = ClientVisibility::whitelist();
         visibility.set_visibility(Entity::PLACEHOLDER, true);
         visibility.update();
         visibility.set_visibility(Entity::PLACEHOLDER, false);
@@ -579,7 +560,7 @@ mod tests {
 
     #[test]
     fn whitelist_insertion_removal() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Whitelist);
+        let mut visibility = ClientVisibility::whitelist();
 
         // Insert and remove from the list.
         visibility.set_visibility(Entity::PLACEHOLDER, true);
@@ -602,7 +583,7 @@ mod tests {
 
     #[test]
     fn whitelist_duplicate_insertion() {
-        let mut visibility = ClientVisibility::new(VisibilityPolicy::Whitelist);
+        let mut visibility = ClientVisibility::whitelist();
         visibility.set_visibility(Entity::PLACEHOLDER, true);
         visibility.update();
 
diff --git a/src/server/event.rs b/src/server/event.rs
index f2269424..d1e566db 100644
--- a/src/server/event.rs
+++ b/src/server/event.rs
@@ -6,14 +6,14 @@ use bevy::{
 use super::{server_tick::ServerTick, ServerSet};
 use crate::core::{
     common_conditions::*,
-    connected_clients::ConnectedClients,
     event::{
         ctx::{ServerReceiveCtx, ServerSendCtx},
         event_registry::EventRegistry,
         server_event::BufferedServerEvents,
     },
-    replication::replicated_clients::ReplicatedClients,
+    replication::client_ticks::ClientTicks,
     replicon_server::RepliconServer,
+    ConnectedClient,
 };
 
 /// Sending events from the server to clients.
@@ -120,8 +120,8 @@ fn send_or_buffer(
     mut server: ResMut<RepliconServer>,
     mut buffered_events: ResMut<BufferedServerEvents>,
     registry: Res<AppTypeRegistry>,
-    connected_clients: Res<ConnectedClients>,
     event_registry: Res<EventRegistry>,
+    clients: Query<Entity, With<ConnectedClient>>,
 ) {
     buffered_events.start_tick();
     let mut ctx = ServerSendCtx {
@@ -139,7 +139,7 @@ fn send_or_buffer(
                 &mut ctx,
                 &server_events,
                 &mut server,
-                &connected_clients,
+                &clients,
                 &mut buffered_events,
             );
         }
@@ -149,10 +149,10 @@ fn send_or_buffer(
 fn send_buffered(
     mut server: ResMut<RepliconServer>,
     mut buffered_events: ResMut<BufferedServerEvents>,
-    replicated_clients: Res<ReplicatedClients>,
+    clients: Query<(Entity, &ClientTicks)>,
 ) {
     buffered_events
-        .send_all(&mut server, &replicated_clients)
+        .send_all(&mut server, &clients)
         .expect("buffered server events should send");
 }
 
diff --git a/src/server/replication_messages.rs b/src/server/replication_messages.rs
index c73da478..83e833de 100644
--- a/src/server/replication_messages.rs
+++ b/src/server/replication_messages.rs
@@ -2,46 +2,3 @@ mod component_changes;
 pub(super) mod mutate_message;
 pub(super) mod serialized_data;
 pub(super) mod update_message;
-
-use mutate_message::MutateMessage;
-use update_message::UpdateMessage;
-
-/// Accumulates replication messages.
-///
-/// Messages are serialized manually into [`SerializedData`](serialized_data::SerializedData)
-/// and store only ranges that point to data. This helps reduce allocations and share
-/// serialized data across messages.
-#[derive(Default)]
-pub(crate) struct ReplicationMessages {
-    messages: Vec<(UpdateMessage, MutateMessage)>,
-    len: usize,
-}
-
-impl ReplicationMessages {
-    /// Initializes messages for each client.
-    ///
-    /// Reuses already allocated messages.
-    /// Creates new messages if the number of clients is bigger then the number of allocated messages.
-    /// If there are more messages than the number of clients, then the extra messages remain untouched
-    /// and [`Self::iter_mut`] will not include them.
-    pub(super) fn reset(&mut self, clients_count: usize) {
-        self.len = clients_count;
-
-        let additional = clients_count.saturating_sub(self.messages.len());
-        self.messages.reserve(additional);
-
-        for index in 0..clients_count {
-            if let Some((update_message, mutate_message)) = self.messages.get_mut(index) {
-                update_message.clear();
-                mutate_message.clear();
-            } else {
-                self.messages.push(Default::default());
-            }
-        }
-    }
-
-    /// Returns iterator over messages for each client.
-    pub(super) fn iter_mut(&mut self) -> impl Iterator<Item = &mut (UpdateMessage, MutateMessage)> {
-        self.messages.iter_mut().take(self.len)
-    }
-}
diff --git a/src/server/replication_messages/mutate_message.rs b/src/server/replication_messages/mutate_message.rs
index 93a383f5..e0ecc183 100644
--- a/src/server/replication_messages/mutate_message.rs
+++ b/src/server/replication_messages/mutate_message.rs
@@ -8,8 +8,8 @@ use crate::core::{
     channels::ReplicationChannel,
     postcard_utils,
     replication::{
+        client_ticks::{ClientTicks, EntityBuffer},
         mutate_index::MutateIndex,
-        replicated_clients::{ClientBuffers, ReplicatedClient},
     },
     replicon_server::RepliconServer,
     replicon_tick::RepliconTick,
@@ -33,7 +33,7 @@ use crate::core::{
 /// using the last up-to-date mutations to avoid re-sending old values.
 ///
 /// Stored inside [`ReplicationMessages`](super::ReplicationMessages).
-#[derive(Default)]
+#[derive(Default, Component)]
 pub(crate) struct MutateMessage {
     /// List of entity values for [`Self::mutations`].
     ///
@@ -124,8 +124,9 @@ impl MutateMessage {
     pub(crate) fn send(
         &mut self,
         server: &mut RepliconServer,
-        client: &mut ReplicatedClient,
-        client_buffers: &mut ClientBuffers,
+        client_entity: Entity,
+        client: &mut ClientTicks,
+        entity_buffer: &mut EntityBuffer,
         serialized: &SerializedData,
         track_mutate_messages: bool,
         server_tick: Range<usize>,
@@ -143,7 +144,7 @@ impl MutateMessage {
         }
 
         let (mut mutate_index, mut entities) =
-            client.register_mutate_message(client_buffers, tick, timestamp);
+            client.register_mutate_message(entity_buffer, tick, timestamp);
         let mut header_size = metadata_size + serialized_size(&mutate_index)?;
         let mut body_size = 0;
         let mut mutations_range = Range::<usize>::default();
@@ -163,7 +164,7 @@ impl MutateMessage {
 
                 mutations_range.start = mutations_range.end;
                 (mutate_index, entities) =
-                    client.register_mutate_message(client_buffers, tick, timestamp);
+                    client.register_mutate_message(entity_buffer, tick, timestamp);
                 header_size = metadata_size + serialized_size(&mutate_index)?; // Recalculate since the mutate index changed.
                 body_size = 0;
             }
@@ -206,7 +207,7 @@ impl MutateMessage {
 
             debug_assert_eq!(message.len(), message_size);
 
-            server.send(client.id(), ReplicationChannel::Mutations, message);
+            server.send(client_entity, ReplicationChannel::Mutations, message);
         }
 
         Ok(messages_count)
@@ -215,7 +216,7 @@ impl MutateMessage {
     /// Clears all chunks.
     ///
     /// Keeps allocated memory for reuse.
-    pub(super) fn clear(&mut self) {
+    pub(crate) fn clear(&mut self) {
         self.entities.clear();
         self.buffer
             .extend(self.mutations.drain(..).map(|mut mutations| {
diff --git a/src/server/replication_messages/serialized_data.rs b/src/server/replication_messages/serialized_data.rs
index ffdfc195..0a487bab 100644
--- a/src/server/replication_messages/serialized_data.rs
+++ b/src/server/replication_messages/serialized_data.rs
@@ -2,15 +2,12 @@ use std::ops::Range;
 
 use bevy::{prelude::*, ptr::Ptr};
 
-use crate::{
-    core::{
-        entity_serde, postcard_utils,
-        replication::replication_registry::{
-            component_fns::ComponentFns, ctx::SerializeCtx, rule_fns::UntypedRuleFns, FnsId,
-        },
-        replicon_tick::RepliconTick,
+use crate::core::{
+    entity_serde, postcard_utils,
+    replication::replication_registry::{
+        component_fns::ComponentFns, ctx::SerializeCtx, rule_fns::UntypedRuleFns, FnsId,
     },
-    server::client_entity_map::ClientMapping,
+    replicon_tick::RepliconTick,
 };
 
 /// Single continuous buffer that stores serialized data for messages.
@@ -23,13 +20,13 @@ pub(crate) struct SerializedData(Vec<u8>);
 impl SerializedData {
     pub(crate) fn write_mappings(
         &mut self,
-        mappings: impl Iterator<Item = ClientMapping>,
+        mappings: impl Iterator<Item = (Entity, Entity)>,
     ) -> postcard::Result<Range<usize>> {
         let start = self.len();
 
-        for mapping in mappings {
-            self.write_entity(mapping.server_entity)?;
-            self.write_entity(mapping.client_entity)?;
+        for (server_entity, client_entity) in mappings {
+            self.write_entity(server_entity)?;
+            self.write_entity(client_entity)?;
         }
 
         let end = self.len();
diff --git a/src/server/replication_messages/update_message.rs b/src/server/replication_messages/update_message.rs
index 0d9a972d..16c7a3a0 100644
--- a/src/server/replication_messages/update_message.rs
+++ b/src/server/replication_messages/update_message.rs
@@ -1,5 +1,6 @@
 use std::ops::Range;
 
+use bevy::prelude::*;
 use postcard::experimental::serialized_size;
 
 use super::{
@@ -7,14 +8,10 @@ use super::{
     serialized_data::SerializedData,
 };
 use crate::core::{
-    channels::ReplicationChannel,
-    postcard_utils,
-    replication::{
-        replicated_clients::{client_visibility::Visibility, ReplicatedClient},
-        update_message_flags::UpdateMessageFlags,
-    },
-    replicon_server::RepliconServer,
+    channels::ReplicationChannel, postcard_utils,
+    replication::update_message_flags::UpdateMessageFlags, replicon_server::RepliconServer,
 };
+use crate::server::client_visibility::Visibility;
 
 /// A message with replicated data.
 ///
@@ -38,7 +35,7 @@ use crate::core::{
 /// on deserialization just consume all remaining bytes.
 ///
 /// Stored inside [`ReplicationMessages`](super::ReplicationMessages).
-#[derive(Default)]
+#[derive(Default, Component)]
 pub(crate) struct UpdateMessage {
     /// Mappings for client's pre-spawned entities.
     ///
@@ -201,7 +198,7 @@ impl UpdateMessage {
     pub(crate) fn send(
         &self,
         server: &mut RepliconServer,
-        client: &ReplicatedClient,
+        client_entity: Entity,
         serialized: &SerializedData,
         server_tick: Range<usize>,
     ) -> postcard::Result<()> {
@@ -291,7 +288,7 @@ impl UpdateMessage {
 
         debug_assert_eq!(message.len(), message_size);
 
-        server.send(client.id(), ReplicationChannel::Updates, message);
+        server.send(client_entity, ReplicationChannel::Updates, message);
 
         Ok(())
     }
@@ -318,7 +315,7 @@ impl UpdateMessage {
     /// Clears all chunks.
     ///
     /// Keeps allocated memory for reuse.
-    pub(super) fn clear(&mut self) {
+    pub(crate) fn clear(&mut self) {
         self.mappings = Default::default();
         self.mappings_len = 0;
         self.despawns.clear();
diff --git a/src/test_app.rs b/src/test_app.rs
index 7f9570a5..a719e115 100644
--- a/src/test_app.rs
+++ b/src/test_app.rs
@@ -1,13 +1,9 @@
 use bevy::prelude::*;
 
-use crate::{
-    core::{
-        replication::replicated_clients::ReplicatedClients,
-        replicon_client::{RepliconClient, RepliconClientStatus},
-        replicon_server::RepliconServer,
-        ClientId, DisconnectReason,
-    },
-    server::{ClientConnected, ClientDisconnected},
+use crate::core::{
+    replicon_client::{RepliconClient, RepliconClientStatus},
+    replicon_server::RepliconServer,
+    ConnectedClient,
 };
 
 /**
@@ -46,7 +42,7 @@ client_app.update();
 
 let mut relicated = client_app.world_mut().query::<&Replicated>();
 assert_eq!(
-    relicated.iter(client_app.world()).count(),
+    relicated.iter(client_app.world()).len(),
     1,
     "client should replicate spawned entity"
 );
@@ -61,6 +57,8 @@ pub trait ServerTestAppExt {
     /// Can be called multiple times on different client apps.
     /// Internally updates both apps one time.
     ///
+    /// Inserts [`TestClientEntity`] for tracking.
+    ///
     /// # Panics
     ///
     /// Panics if a client app has been connected before.
@@ -88,29 +86,19 @@ pub trait ServerTestAppExt {
 
 impl ServerTestAppExt for App {
     fn connect_client(&mut self, client_app: &mut App) {
+        let mut server = self.world_mut().resource_mut::<RepliconServer>();
+        server.set_running(true);
+        let client_entity = self.world_mut().spawn(ConnectedClient).id();
+
         let mut client = client_app.world_mut().resource_mut::<RepliconClient>();
         assert!(
             client.is_disconnected(),
             "client can't be connected multiple times"
         );
-
-        // Use client number as ID.
-        // Server ID (0) will always be skipped.
-        let max_id = self
+        client.set_status(RepliconClientStatus::Connected);
+        client_app
             .world_mut()
-            .resource_mut::<ReplicatedClients>()
-            .iter_client_ids()
-            .max()
-            .unwrap_or(ClientId::SERVER);
-        let client_id = ClientId::new(max_id.get() + 1);
-        client.set_status(RepliconClientStatus::Connected {
-            client_id: Some(client_id),
-        });
-
-        let mut server = self.world_mut().resource_mut::<RepliconServer>();
-        server.set_running(true);
-
-        self.world_mut().trigger(ClientConnected { client_id });
+            .insert_resource(TestClientEntity(client_entity));
 
         self.update();
         client_app.update();
@@ -118,34 +106,29 @@ impl ServerTestAppExt for App {
 
     fn disconnect_client(&mut self, client_app: &mut App) {
         let mut client = client_app.world_mut().resource_mut::<RepliconClient>();
-        let client_id = client
-            .id()
-            .expect("client should have an assigned ID for disconnect");
-
         client.set_status(RepliconClientStatus::Disconnected);
+        let client_entity = *client_app
+            .world_mut()
+            .remove_resource::<TestClientEntity>()
+            .expect("client should have an assigned ID for disconnect");
 
-        self.world_mut().trigger(ClientDisconnected {
-            client_id,
-            reason: DisconnectReason::DisconnectedByServer,
-        });
+        self.world_mut().entity_mut(client_entity).despawn();
 
         self.update();
         client_app.update();
     }
 
     fn exchange_with_client(&mut self, client_app: &mut App) {
+        let client_entity = **client_app.world().resource::<TestClientEntity>();
         let mut client = client_app.world_mut().resource_mut::<RepliconClient>();
-        let client_id = client
-            .id()
-            .expect("client should have an assigned ID for exchanging messages");
 
         let mut server = self.world_mut().resource_mut::<RepliconServer>();
         for (channel_id, message) in client.drain_sent() {
-            server.insert_received(client_id, channel_id, message)
+            server.insert_received(client_entity, channel_id, message)
         }
 
-        server.retain_sent(|(sender_id, channel_id, message)| {
-            if *sender_id == client_id {
+        server.retain_sent(|(entity, channel_id, message)| {
+            if *entity == client_entity {
                 client.insert_received(*channel_id, message.clone());
                 false
             } else {
@@ -154,3 +137,10 @@ impl ServerTestAppExt for App {
         })
     }
 }
+
+/// Stores connected client entity from server on client.
+///
+/// Inserted in [`ServerTestAppExt::connect_client`] and removed by [`ServerTestAppExt::disconnect_client`].
+/// Used to track which client corresponds to which connection.
+#[derive(Resource, Deref, Clone, Copy, Debug)]
+pub struct TestClientEntity(Entity);
diff --git a/tests/connection.rs b/tests/connection.rs
index b1ec9640..1b27e177 100644
--- a/tests/connection.rs
+++ b/tests/connection.rs
@@ -1,6 +1,8 @@
 use bevy::prelude::*;
 use bevy_replicon::{
-    core::channels::ReplicationChannel, prelude::*, server::server_tick::ServerTick,
+    core::{channels::ReplicationChannel, ConnectedClient},
+    prelude::*,
+    server::server_tick::ServerTick,
     test_app::ServerTestAppExt,
 };
 
@@ -14,12 +16,8 @@ fn client_to_server() {
     }
 
     const MESSAGES: &[&[u8]] = &[&[0], &[1]];
-    const CLIENT_ID: ClientId = ClientId::new(0);
-
     let mut client = client_app.world_mut().resource_mut::<RepliconClient>();
-    client.set_status(RepliconClientStatus::Connected {
-        client_id: Some(CLIENT_ID),
-    });
+    client.set_status(RepliconClientStatus::Connected);
     for &message in MESSAGES {
         client.send(ReplicationChannel::Updates, message);
     }
@@ -28,7 +26,7 @@ fn client_to_server() {
     server.set_running(true);
 
     for (channel_id, message) in client.drain_sent() {
-        server.insert_received(CLIENT_ID, channel_id, message);
+        server.insert_received(Entity::PLACEHOLDER, channel_id, message);
     }
 
     let messages: Vec<_> = server
@@ -48,18 +46,14 @@ fn server_to_client() {
     }
 
     const MESSAGES: &[&[u8]] = &[&[0], &[1]];
-    const CLIENT_ID: ClientId = ClientId::new(0);
-
     let mut server = server_app.world_mut().resource_mut::<RepliconServer>();
     server.set_running(true);
     for &message in MESSAGES {
-        server.send(CLIENT_ID, ReplicationChannel::Updates, message);
+        server.send(Entity::PLACEHOLDER, ReplicationChannel::Updates, message);
     }
 
     let mut client = client_app.world_mut().resource_mut::<RepliconClient>();
-    client.set_status(RepliconClientStatus::Connected {
-        client_id: Some(CLIENT_ID),
-    });
+    client.set_status(RepliconClientStatus::Connected);
 
     for (_, channel_id, message) in server.drain_sent() {
         client.insert_received(channel_id, message);
@@ -85,13 +79,11 @@ fn connect_disconnect() {
 
     server_app.connect_client(&mut client_app);
 
-    let replicated_clients = server_app.world().resource::<ReplicatedClients>();
-    assert_eq!(replicated_clients.len(), 1);
+    let mut clients = server_app.world_mut().query::<&ConnectedClient>();
+    assert_eq!(clients.iter(server_app.world()).len(), 1);
 
     server_app.disconnect_client(&mut client_app);
-
-    let replicated_clients = server_app.world().resource::<ReplicatedClients>();
-    assert!(replicated_clients.is_empty());
+    assert_eq!(clients.iter(server_app.world()).len(), 0);
 }
 
 #[test]
@@ -108,7 +100,7 @@ fn client_cleanup_on_disconnect() {
     app.update();
 
     let mut client = app.world_mut().resource_mut::<RepliconClient>();
-    client.set_status(RepliconClientStatus::Connected { client_id: None });
+    client.set_status(RepliconClientStatus::Connected);
 
     client.send(ReplicationChannel::Updates, Vec::new());
     client.insert_received(ReplicationChannel::Updates, Vec::new());
@@ -137,9 +129,8 @@ fn server_cleanup_on_stop() {
     let mut server = app.world_mut().resource_mut::<RepliconServer>();
     server.set_running(true);
 
-    const DUMMY_CLIENT_ID: ClientId = ClientId::new(1);
-    server.send(DUMMY_CLIENT_ID, ReplicationChannel::Updates, Vec::new());
-    server.insert_received(DUMMY_CLIENT_ID, ReplicationChannel::Updates, Vec::new());
+    server.send(Entity::PLACEHOLDER, ReplicationChannel::Updates, Vec::new());
+    server.insert_received(Entity::PLACEHOLDER, ReplicationChannel::Updates, Vec::new());
 
     server.set_running(false);
 
@@ -190,10 +181,8 @@ fn server_inactive() {
 
     let mut server = app.world_mut().resource_mut::<RepliconServer>();
 
-    const DUMMY_CLIENT_ID: ClientId = ClientId::new(1);
-
-    server.send(DUMMY_CLIENT_ID, ReplicationChannel::Updates, Vec::new());
-    server.insert_received(DUMMY_CLIENT_ID, ReplicationChannel::Updates, Vec::new());
+    server.send(Entity::PLACEHOLDER, ReplicationChannel::Updates, Vec::new());
+    server.insert_received(Entity::PLACEHOLDER, ReplicationChannel::Updates, Vec::new());
 
     assert_eq!(server.drain_sent().count(), 0);
     assert_eq!(server.receive(ReplicationChannel::Updates).count(), 0);
@@ -220,28 +209,8 @@ fn deferred_replication() {
 
     server_app.connect_client(&mut client_app);
 
-    let connected_clients = server_app.world().resource::<ConnectedClients>();
-    assert!(!connected_clients.is_empty());
-
-    let replicated_clients = server_app.world().resource::<ReplicatedClients>();
-    assert!(
-        replicated_clients.is_empty(),
-        "server shouldn't replicate to yet"
-    );
-
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-    server_app.world_mut().trigger(StartReplication(client_id));
-
-    let replicated_clients = server_app.world().resource::<ReplicatedClients>();
-    assert!(
-        !replicated_clients.is_empty(),
-        "server now should start replicating"
-    );
-
-    // Make sure that enabling replication twice do nothing.
-    server_app.world_mut().trigger(StartReplication(client_id));
-
-    let replicated_clients = server_app.world().resource::<ReplicatedClients>();
-    assert_eq!(replicated_clients.len(), 1);
+    server_app
+        .world_mut()
+        .query_filtered::<&ConnectedClient, Without<ReplicatedClient>>()
+        .single(server_app.world());
 }
diff --git a/tests/despawn.rs b/tests/despawn.rs
index bf6662b9..1f63d4d8 100644
--- a/tests/despawn.rs
+++ b/tests/despawn.rs
@@ -83,7 +83,7 @@ fn with_hierarchy() {
     client_app.update();
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(replicated.iter(client_app.world()).next().is_none());
+    assert_eq!(replicated.iter(client_app.world()).len(), 0);
 }
 
 #[test]
@@ -114,7 +114,7 @@ fn after_spawn() {
     client_app.update();
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(replicated.iter(client_app.world()).next().is_none());
+    assert_eq!(replicated.iter(client_app.world()).len(), 0);
 }
 
 #[test]
diff --git a/tests/insertion.rs b/tests/insertion.rs
index e3cfaf15..f6b76e10 100644
--- a/tests/insertion.rs
+++ b/tests/insertion.rs
@@ -10,7 +10,7 @@ use bevy_replicon::{
     },
     prelude::*,
     server::server_tick::ServerTick,
-    test_app::ServerTestAppExt,
+    test_app::{ServerTestAppExt, TestClientEntity},
 };
 use bytes::Bytes;
 use serde::{Deserialize, Serialize};
@@ -110,12 +110,10 @@ fn mapped_existing_entity() {
 
     server_app.connect_client(&mut client_app);
 
-    // Make client and server have different entity IDs.
-    server_app.world_mut().spawn_empty();
-
     let server_entity = server_app.world_mut().spawn(Replicated).id();
     let server_map_entity = server_app.world_mut().spawn_empty().id();
     let client_map_entity = client_app.world_mut().spawn_empty().id();
+    assert_ne!(server_map_entity, client_map_entity);
 
     client_app
         .world_mut()
@@ -160,9 +158,6 @@ fn mapped_new_entity() {
 
     server_app.connect_client(&mut client_app);
 
-    // Make client and server have different entity IDs.
-    server_app.world_mut().spawn_empty();
-
     let server_entity = server_app.world_mut().spawn(Replicated).id();
     let server_map_entity = server_app.world_mut().spawn_empty().id();
 
@@ -254,18 +249,14 @@ fn marker() {
 
     let server_entity = server_app.world_mut().spawn(Replicated).id();
     let client_entity = client_app.world_mut().spawn(ReplaceMarker).id();
+    assert_ne!(server_entity, client_entity);
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
-    let mut entity_map = server_app.world_mut().resource_mut::<ClientEntityMap>();
-    entity_map.insert(
-        client_id,
-        ClientMapping {
-            server_entity,
-            client_entity,
-        },
-    );
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut entity_map = server_app
+        .world_mut()
+        .get_mut::<ClientEntityMap>(test_client_entity)
+        .unwrap();
+    entity_map.insert(server_entity, client_entity);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
@@ -445,9 +436,11 @@ fn before_started_replication() {
         "no entities should have been sent to the client"
     );
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-    server_app.world_mut().trigger(StartReplication(client_id));
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    server_app
+        .world_mut()
+        .entity_mut(test_client_entity)
+        .insert(ReplicatedClient);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
@@ -478,9 +471,11 @@ fn after_started_replication() {
 
     server_app.connect_client(&mut client_app);
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-    server_app.world_mut().trigger(StartReplication(client_id));
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    server_app
+        .world_mut()
+        .entity_mut(test_client_entity)
+        .insert(ReplicatedClient);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
diff --git a/tests/mutations.rs b/tests/mutations.rs
index ea13bffd..47b2875a 100644
--- a/tests/mutations.rs
+++ b/tests/mutations.rs
@@ -14,7 +14,7 @@ use bevy_replicon::{
     },
     prelude::*,
     server::server_tick::ServerTick,
-    test_app::ServerTestAppExt,
+    test_app::{ServerTestAppExt, TestClientEntity},
 };
 use bytes::Bytes;
 use serde::{Deserialize, Serialize};
@@ -249,17 +249,12 @@ fn marker() {
 
     let client_entity = client_app.world_mut().spawn(ReplaceMarker).id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
-    let mut entity_map = server_app.world_mut().resource_mut::<ClientEntityMap>();
-    entity_map.insert(
-        client_id,
-        ClientMapping {
-            server_entity,
-            client_entity,
-        },
-    );
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut entity_map = server_app
+        .world_mut()
+        .get_mut::<ClientEntityMap>(test_client_entity)
+        .unwrap();
+    entity_map.insert(server_entity, client_entity);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
@@ -316,17 +311,12 @@ fn marker_with_history() {
 
     let client_entity = client_app.world_mut().spawn(HistoryMarker).id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
-    let mut entity_map = server_app.world_mut().resource_mut::<ClientEntityMap>();
-    entity_map.insert(
-        client_id,
-        ClientMapping {
-            server_entity,
-            client_entity,
-        },
-    );
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut entity_map = server_app
+        .world_mut()
+        .get_mut::<ClientEntityMap>(test_client_entity)
+        .unwrap();
+    entity_map.insert(server_entity, client_entity);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
@@ -402,17 +392,12 @@ fn marker_with_history_consume() {
 
     let client_entity = client_app.world_mut().spawn(HistoryMarker).id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
-    let mut entity_map = server_app.world_mut().resource_mut::<ClientEntityMap>();
-    entity_map.insert(
-        client_id,
-        ClientMapping {
-            server_entity,
-            client_entity,
-        },
-    );
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut entity_map = server_app
+        .world_mut()
+        .get_mut::<ClientEntityMap>(test_client_entity)
+        .unwrap();
+    entity_map.insert(server_entity, client_entity);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
@@ -489,17 +474,12 @@ fn marker_with_history_old_update() {
 
     let client_entity = client_app.world_mut().spawn(HistoryMarker).id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
-    let mut entity_map = server_app.world_mut().resource_mut::<ClientEntityMap>();
-    entity_map.insert(
-        client_id,
-        ClientMapping {
-            server_entity,
-            client_entity,
-        },
-    );
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut entity_map = server_app
+        .world_mut()
+        .get_mut::<ClientEntityMap>(test_client_entity)
+        .unwrap();
+    entity_map.insert(server_entity, client_entity);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
@@ -721,7 +701,7 @@ fn with_despawn() {
     server_app.update(); // Let server receive an update to trigger acknowledgment.
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(replicated.iter(client_app.world()).next().is_none());
+    assert_eq!(replicated.iter(client_app.world()).len(), 0);
 }
 
 #[test]
@@ -997,6 +977,53 @@ fn confirm_history() {
     assert_eq!(event.tick, tick);
 }
 
+#[test]
+fn after_disconnect() {
+    let mut server_app = App::new();
+    let mut client_app = App::new();
+    for app in [&mut server_app, &mut client_app] {
+        app.add_plugins((
+            MinimalPlugins,
+            RepliconPlugins.set(ServerPlugin {
+                tick_policy: TickPolicy::EveryFrame,
+                ..Default::default()
+            }),
+        ))
+        .replicate::<BoolComponent>();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    let server_entity = server_app
+        .world_mut()
+        .spawn((Replicated, BoolComponent(false)))
+        .id();
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    // Change value.
+    let mut component = server_app
+        .world_mut()
+        .get_mut::<BoolComponent>(server_entity)
+        .unwrap();
+    component.0 = true;
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    server_app
+        .world_mut()
+        .entity_mut(test_client_entity)
+        .despawn();
+    server_app.update();
+}
+
 #[derive(Component, Deserialize, Serialize)]
 struct DummyComponent;
 
diff --git a/tests/removal.rs b/tests/removal.rs
index ad953bd0..38096ca7 100644
--- a/tests/removal.rs
+++ b/tests/removal.rs
@@ -7,7 +7,7 @@ use bevy_replicon::{
     },
     prelude::*,
     server::server_tick::ServerTick,
-    test_app::ServerTestAppExt,
+    test_app::{ServerTestAppExt, TestClientEntity},
 };
 use bytes::Bytes;
 use serde::{Deserialize, Serialize};
@@ -132,17 +132,12 @@ fn marker() {
 
     let client_entity = client_app.world_mut().spawn(ReplaceMarker).id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
-    let mut entity_map = server_app.world_mut().resource_mut::<ClientEntityMap>();
-    entity_map.insert(
-        client_id,
-        ClientMapping {
-            server_entity,
-            client_entity,
-        },
-    );
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut entity_map = server_app
+        .world_mut()
+        .get_mut::<ClientEntityMap>(test_client_entity)
+        .unwrap();
+    entity_map.insert(server_entity, client_entity);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
@@ -380,7 +375,7 @@ fn with_despawn() {
     client_app.update();
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(replicated.iter(client_app.world()).next().is_none());
+    assert_eq!(replicated.iter(client_app.world()).len(), 0);
 }
 
 #[test]
@@ -488,8 +483,9 @@ fn hidden() {
     client_app.update();
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(
-        replicated.iter(client_app.world()).next().is_none(),
+    assert_eq!(
+        replicated.iter(client_app.world()).len(),
+        0,
         "client shouldn't know about hidden entity"
     );
 }
diff --git a/tests/server_event.rs b/tests/server_event.rs
index eda06f90..fd3aeb96 100644
--- a/tests/server_event.rs
+++ b/tests/server_event.rs
@@ -4,8 +4,11 @@ use bevy::{
     time::TimePlugin,
 };
 use bevy_replicon::{
-    client::ServerUpdateTick, core::server_entity_map::ServerEntityMap, prelude::*,
-    server::server_tick::ServerTick, test_app::ServerTestAppExt,
+    client::ServerUpdateTick,
+    core::server_entity_map::ServerEntityMap,
+    prelude::*,
+    server::server_tick::ServerTick,
+    test_app::{ServerTestAppExt, TestClientEntity},
 };
 use serde::{Deserialize, Serialize};
 
@@ -27,15 +30,13 @@ fn sending_receiving() {
 
     server_app.connect_client(&mut client_app);
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
     for (mode, events_count) in [
         (SendMode::Broadcast, 1),
-        (SendMode::Direct(ClientId::SERVER), 0),
-        (SendMode::Direct(client_id), 1),
-        (SendMode::BroadcastExcept(ClientId::SERVER), 1),
-        (SendMode::BroadcastExcept(client_id), 0),
+        (SendMode::Direct(Entity::PLACEHOLDER), 0),
+        (SendMode::Direct(test_client_entity), 1),
+        (SendMode::BroadcastExcept(Entity::PLACEHOLDER), 1),
+        (SendMode::BroadcastExcept(test_client_entity), 0),
     ] {
         server_app.world_mut().send_event(ToClients {
             mode,
@@ -130,15 +131,13 @@ fn sending_receiving_without_plugins() {
 
     server_app.connect_client(&mut client_app);
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
     for (mode, events_count) in [
         (SendMode::Broadcast, 1),
-        (SendMode::Direct(ClientId::SERVER), 0),
-        (SendMode::Direct(client_id), 1),
-        (SendMode::BroadcastExcept(ClientId::SERVER), 1),
-        (SendMode::BroadcastExcept(client_id), 0),
+        (SendMode::Direct(Entity::PLACEHOLDER), 0),
+        (SendMode::Direct(test_client_entity), 1),
+        (SendMode::BroadcastExcept(Entity::PLACEHOLDER), 1),
+        (SendMode::BroadcastExcept(test_client_entity), 0),
     ] {
         server_app.world_mut().send_event(ToClients {
             mode,
@@ -172,12 +171,12 @@ fn local_resending() {
     .add_server_event::<DummyEvent>(ChannelKind::Ordered)
     .finish();
 
-    const DUMMY_CLIENT_ID: ClientId = ClientId::new(1);
+    const DUMMY_CLIENT_ID: Entity = Entity::from_raw(1);
     for (mode, events_count) in [
         (SendMode::Broadcast, 1),
-        (SendMode::Direct(ClientId::SERVER), 1),
+        (SendMode::Direct(Entity::PLACEHOLDER), 1),
         (SendMode::Direct(DUMMY_CLIENT_ID), 0),
-        (SendMode::BroadcastExcept(ClientId::SERVER), 0),
+        (SendMode::BroadcastExcept(Entity::PLACEHOLDER), 0),
         (SendMode::BroadcastExcept(DUMMY_CLIENT_ID), 1),
     ] {
         app.world_mut().send_event(ToClients {
@@ -307,7 +306,7 @@ fn event_queue_and_mapping() {
                 ..Default::default()
             }),
         ))
-        .add_server_event::<EntityEvent>(ChannelKind::Ordered)
+        .add_mapped_server_event::<EntityEvent>(ChannelKind::Ordered)
         .finish();
     }
 
@@ -316,6 +315,8 @@ fn event_queue_and_mapping() {
     // Spawn an entity to trigger world change.
     let server_entity = server_app.world_mut().spawn(Replicated).id();
     let client_entity = client_app.world_mut().spawn_empty().id();
+    assert_ne!(server_entity, client_entity);
+
     client_app
         .world_mut()
         .resource_mut::<ServerEntityMap>()
@@ -450,15 +451,13 @@ fn independent() {
     // but our independent event should be triggered immediately.
     *client_app.world_mut().resource_mut::<ServerUpdateTick>() = Default::default();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
     for (mode, events_count) in [
         (SendMode::Broadcast, 1),
-        (SendMode::Direct(ClientId::SERVER), 0),
-        (SendMode::Direct(client_id), 1),
-        (SendMode::BroadcastExcept(ClientId::SERVER), 1),
-        (SendMode::BroadcastExcept(client_id), 0),
+        (SendMode::Direct(Entity::PLACEHOLDER), 0),
+        (SendMode::Direct(test_client_entity), 1),
+        (SendMode::BroadcastExcept(Entity::PLACEHOLDER), 1),
+        (SendMode::BroadcastExcept(test_client_entity), 0),
     ] {
         server_app.world_mut().send_event(ToClients {
             mode,
diff --git a/tests/spawn.rs b/tests/spawn.rs
index 89b02d96..a497c483 100644
--- a/tests/spawn.rs
+++ b/tests/spawn.rs
@@ -1,7 +1,9 @@
 use bevy::prelude::*;
 use bevy_replicon::{
-    client::confirm_history::ConfirmHistory, core::server_entity_map::ServerEntityMap, prelude::*,
-    test_app::ServerTestAppExt,
+    client::confirm_history::ConfirmHistory,
+    core::server_entity_map::ServerEntityMap,
+    prelude::*,
+    test_app::{ServerTestAppExt, TestClientEntity},
 };
 use serde::{Deserialize, Serialize};
 
@@ -100,7 +102,7 @@ fn with_old_component() {
     server_app.exchange_with_client(&mut client_app);
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(replicated.iter(client_app.world()).next().is_none());
+    assert_eq!(replicated.iter(client_app.world()).len(), 0);
 
     // Enable replication for previously spawned entity
     server_app
@@ -164,26 +166,18 @@ fn pre_spawn() {
 
     server_app.connect_client(&mut client_app);
 
-    // Make client and server have different entity IDs.
-    server_app.world_mut().spawn_empty();
-
     let client_entity = client_app.world_mut().spawn_empty().id();
     let server_entity = server_app
         .world_mut()
         .spawn((Replicated, DummyComponent))
         .id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
-    let mut entity_map = server_app.world_mut().resource_mut::<ClientEntityMap>();
-    entity_map.insert(
-        client_id,
-        ClientMapping {
-            server_entity,
-            client_entity,
-        },
-    );
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut entity_map = server_app
+        .world_mut()
+        .get_mut::<ClientEntityMap>(test_client_entity)
+        .unwrap();
+    entity_map.insert(server_entity, client_entity);
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
diff --git a/tests/stats.rs b/tests/stats.rs
index 959b915e..bc61c9f0 100644
--- a/tests/stats.rs
+++ b/tests/stats.rs
@@ -1,5 +1,8 @@
 use bevy::prelude::*;
-use bevy_replicon::{prelude::*, test_app::ServerTestAppExt};
+use bevy_replicon::{
+    prelude::*,
+    test_app::{ServerTestAppExt, TestClientEntity},
+};
 use serde::{Deserialize, Serialize};
 
 #[test]
@@ -25,17 +28,12 @@ fn client_stats() {
         .spawn((Replicated, DummyComponent))
         .id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-
-    let mut entity_map = server_app.world_mut().resource_mut::<ClientEntityMap>();
-    entity_map.insert(
-        client_id,
-        ClientMapping {
-            server_entity,
-            client_entity,
-        },
-    );
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut entity_map = server_app
+        .world_mut()
+        .get_mut::<ClientEntityMap>(test_client_entity)
+        .unwrap();
+    entity_map.insert(server_entity, client_entity);
 
     server_app.world_mut().spawn(Replicated).despawn();
 
diff --git a/tests/visibility.rs b/tests/visibility.rs
index 73f37498..e80f500a 100644
--- a/tests/visibility.rs
+++ b/tests/visibility.rs
@@ -1,5 +1,8 @@
 use bevy::prelude::*;
-use bevy_replicon::{prelude::*, test_app::ServerTestAppExt};
+use bevy_replicon::{
+    prelude::*,
+    test_app::{ServerTestAppExt, TestClientEntity},
+};
 use serde::{Deserialize, Serialize};
 
 #[test]
@@ -24,10 +27,11 @@ fn all() {
         .spawn((Replicated, DummyComponent))
         .id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-    let mut replicated_clients = server_app.world_mut().resource_mut::<ReplicatedClients>();
-    let visibility = replicated_clients.client_mut(client_id).visibility_mut();
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut visibility = server_app
+        .world_mut()
+        .get_mut::<ClientVisibility>(test_client_entity)
+        .unwrap();
     visibility.set_visibility(server_entity, false); // Shouldn't have any effect for this policy.
 
     server_app.update();
@@ -41,8 +45,10 @@ fn all() {
         .single(client_app.world());
 
     // Reverse visibility back.
-    let mut replicated_clients = server_app.world_mut().resource_mut::<ReplicatedClients>();
-    let visibility = replicated_clients.client_mut(client_id).visibility_mut();
+    let mut visibility = server_app
+        .world_mut()
+        .get_mut::<ClientVisibility>(test_client_entity)
+        .unwrap();
     visibility.set_visibility(server_entity, true);
 
     server_app.update();
@@ -108,10 +114,11 @@ fn blacklist() {
         .spawn((Replicated, DummyComponent))
         .id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-    let mut replicated_clients = server_app.world_mut().resource_mut::<ReplicatedClients>();
-    let visibility = replicated_clients.client_mut(client_id).visibility_mut();
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut visibility = server_app
+        .world_mut()
+        .get_mut::<ClientVisibility>(test_client_entity)
+        .unwrap();
     visibility.set_visibility(server_entity, false);
 
     server_app.update();
@@ -120,11 +127,13 @@ fn blacklist() {
     server_app.exchange_with_client(&mut client_app);
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(replicated.iter(client_app.world()).next().is_none());
+    assert_eq!(replicated.iter(client_app.world()).len(), 0);
 
     // Reverse visibility back.
-    let mut replicated_clients = server_app.world_mut().resource_mut::<ReplicatedClients>();
-    let visibility = replicated_clients.client_mut(client_id).visibility_mut();
+    let mut visibility = server_app
+        .world_mut()
+        .get_mut::<ClientVisibility>(test_client_entity)
+        .unwrap();
     visibility.set_visibility(server_entity, true);
 
     server_app.update();
@@ -157,10 +166,11 @@ fn blacklist_with_despawn() {
 
     let server_entity = server_app.world_mut().spawn(Replicated).id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-    let mut replicated_clients = server_app.world_mut().resource_mut::<ReplicatedClients>();
-    let visibility = replicated_clients.client_mut(client_id).visibility_mut();
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut visibility = server_app
+        .world_mut()
+        .get_mut::<ClientVisibility>(test_client_entity)
+        .unwrap();
     visibility.set_visibility(server_entity, false);
     server_app.world_mut().despawn(server_entity);
 
@@ -169,10 +179,12 @@ fn blacklist_with_despawn() {
     client_app.update();
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(replicated.iter(client_app.world()).next().is_none());
+    assert_eq!(replicated.iter(client_app.world()).len(), 0);
 
-    let replicated_clients = server_app.world().resource::<ReplicatedClients>();
-    let visibility = replicated_clients.client(client_id).visibility();
+    let visibility = server_app
+        .world()
+        .get::<ClientVisibility>(test_client_entity)
+        .unwrap();
     assert!(visibility.is_visible(server_entity)); // The missing entity must be removed from the list, so this should return `true`.
 }
 
@@ -201,8 +213,9 @@ fn empty_whitelist() {
     client_app.update();
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(
-        replicated.iter(client_app.world()).next().is_none(),
+    assert_eq!(
+        replicated.iter(client_app.world()).len(),
+        0,
         "no entities should be replicated without adding to whitelist"
     );
 }
@@ -230,10 +243,11 @@ fn whitelist() {
         .spawn((Replicated, DummyComponent))
         .id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-    let mut replicated_clients = server_app.world_mut().resource_mut::<ReplicatedClients>();
-    let visibility = replicated_clients.client_mut(client_id).visibility_mut();
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut visibility = server_app
+        .world_mut()
+        .get_mut::<ClientVisibility>(test_client_entity)
+        .unwrap();
     visibility.set_visibility(server_entity, true);
 
     server_app.update();
@@ -247,8 +261,10 @@ fn whitelist() {
         .single(client_app.world());
 
     // Reverse visibility.
-    let mut replicated_clients = server_app.world_mut().resource_mut::<ReplicatedClients>();
-    let visibility = replicated_clients.client_mut(client_id).visibility_mut();
+    let mut visibility = server_app
+        .world_mut()
+        .get_mut::<ClientVisibility>(test_client_entity)
+        .unwrap();
     visibility.set_visibility(server_entity, false);
 
     server_app.update();
@@ -281,10 +297,11 @@ fn whitelist_with_despawn() {
 
     let server_entity = server_app.world_mut().spawn(Replicated).id();
 
-    let client = client_app.world().resource::<RepliconClient>();
-    let client_id = client.id().unwrap();
-    let mut replicated_clients = server_app.world_mut().resource_mut::<ReplicatedClients>();
-    let visibility = replicated_clients.client_mut(client_id).visibility_mut();
+    let test_client_entity = **client_app.world().resource::<TestClientEntity>();
+    let mut visibility = server_app
+        .world_mut()
+        .get_mut::<ClientVisibility>(test_client_entity)
+        .unwrap();
     visibility.set_visibility(server_entity, true);
     server_app.world_mut().despawn(server_entity);
 
@@ -293,10 +310,12 @@ fn whitelist_with_despawn() {
     client_app.update();
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
-    assert!(replicated.iter(client_app.world()).next().is_none());
+    assert_eq!(replicated.iter(client_app.world()).len(), 0);
 
-    let replicated_clients = server_app.world().resource::<ReplicatedClients>();
-    let visibility = replicated_clients.client(client_id).visibility();
+    let visibility = server_app
+        .world()
+        .get::<ClientVisibility>(test_client_entity)
+        .unwrap();
     assert!(!visibility.is_visible(server_entity));
 }
 

From a4b6a42bc871cf7aca904a069353268efc60596a Mon Sep 17 00:00:00 2001
From: Shatur <genaloner@gmail.com>
Date: Sat, 22 Feb 2025 18:12:21 +0200
Subject: [PATCH 02/14] Remove extra `.iter()` call

---
 src/core/event/server_event.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/event/server_event.rs b/src/core/event/server_event.rs
index 089c7d04..90b64e3f 100644
--- a/src/core/event/server_event.rs
+++ b/src/core/event/server_event.rs
@@ -338,12 +338,12 @@ impl ServerEvent {
 
         match *mode {
             SendMode::Broadcast => {
-                for client_entity in clients.iter() {
+                for client_entity in clients {
                     server.send(client_entity, self.channel_id, message.clone());
                 }
             }
             SendMode::BroadcastExcept(entity) => {
-                for client_entity in clients.iter() {
+                for client_entity in clients {
                     if client_entity != entity {
                         server.send(client_entity, self.channel_id, message.clone());
                     }

From bbdf346c9a8b139cb247a3225a95330f1ef6e107 Mon Sep 17 00:00:00 2001
From: Shatur <genaloner@gmail.com>
Date: Sat, 22 Feb 2025 18:58:44 +0200
Subject: [PATCH 03/14] Rename

---
 src/core/event/server_event.rs | 12 ++++++------
 src/server.rs                  | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/core/event/server_event.rs b/src/core/event/server_event.rs
index 90b64e3f..dbcb8356 100644
--- a/src/core/event/server_event.rs
+++ b/src/core/event/server_event.rs
@@ -768,26 +768,26 @@ impl BufferedServerEvents {
             for mut event in set.events.drain(..) {
                 match event.mode {
                     SendMode::Broadcast => {
-                        for (client_entity, client) in
+                        for (client_entity, ticks) in
                             clients.iter().filter(|(e, _)| !set.excluded.contains(e))
                         {
-                            event.send(server, client_entity, client)?;
+                            event.send(server, client_entity, ticks)?;
                         }
                     }
                     SendMode::BroadcastExcept(entity) => {
-                        for (client_entity, client) in
+                        for (client_entity, ticks) in
                             clients.iter().filter(|(e, _)| !set.excluded.contains(e))
                         {
                             if client_entity == entity {
                                 continue;
                             }
-                            event.send(server, client_entity, client)?;
+                            event.send(server, client_entity, ticks)?;
                         }
                     }
                     SendMode::Direct(entity) => {
                         if entity != Entity::PLACEHOLDER && !set.excluded.contains(&entity) {
-                            if let Ok((client_entity, client)) = clients.get(entity) {
-                                event.send(server, client_entity, client)?;
+                            if let Ok((client_entity, ticks)) = clients.get(entity) {
+                                event.send(server, client_entity, ticks)?;
                             }
                         }
                     }
diff --git a/src/server.rs b/src/server.rs
index 58db2b90..01df28b4 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -205,22 +205,22 @@ fn receive_acks(
     mut clients: Query<&mut ClientTicks>,
     mut entity_buffer: ResMut<EntityBuffer>,
 ) {
-    for (entity, mut message) in server.receive(ReplicationChannel::Updates) {
+    for (client_entity, mut message) in server.receive(ReplicationChannel::Updates) {
         while message.has_remaining() {
             match postcard_utils::from_buf(&mut message) {
                 Ok(mutate_index) => {
-                    let mut ticks = clients.get_mut(entity).unwrap_or_else(|_| {
-                        panic!("messages from client `{entity}` should have been removed on disconnect")
+                    let mut ticks = clients.get_mut(client_entity).unwrap_or_else(|_| {
+                        panic!("messages from client `{client_entity}` should have been removed on disconnect previously")
                     });
                     ticks.ack_mutate_message(
-                        entity,
+                        client_entity,
                         &mut entity_buffer,
                         change_tick.this_run(),
                         mutate_index,
                     );
                 }
                 Err(e) => {
-                    debug!("unable to deserialize mutate index from client `{entity}`: {e}")
+                    debug!("unable to deserialize mutate index from client `{client_entity}`: {e}")
                 }
             }
         }

From 1241f5ade94cbd0ebf349990089e01953e51d8ab Mon Sep 17 00:00:00 2001
From: Shatur <genaloner@gmail.com>
Date: Sat, 22 Feb 2025 18:58:59 +0200
Subject: [PATCH 04/14] Adjust docs

---
 src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
index a9015a97..0a4d23d5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -588,7 +588,7 @@ You can control which parts of the world are visible for each client by setting
 in [`ServerPlugin`] to [`VisibilityPolicy::Whitelist`] or [`VisibilityPolicy::Blacklist`].
 
 In order to set which entity is visible, you need to use the [`ClientVisibility`] component
-on connected clients.
+on replicated clients.
 
 ```
 # use bevy::prelude::*;

From 8bfd7918919f600ee9fdbeb81791b8230b24e22d Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Sun, 2 Mar 2025 01:42:48 +0200
Subject: [PATCH 05/14] Add `NetworkStats` to prelude

---
 src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
index 0a4d23d5..bc9a4580 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -692,7 +692,7 @@ pub mod prelude {
             },
             replicon_client::{RepliconClient, RepliconClientStatus},
             replicon_server::RepliconServer,
-            ConnectedClient, RepliconCorePlugin,
+            ConnectedClient, NetworkStats, RepliconCorePlugin,
         },
         RepliconPlugins,
     };

From e301c0e25b71aa28aacb8990eff0ad111c696bd8 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Sun, 2 Mar 2025 01:49:37 +0200
Subject: [PATCH 06/14] Add dedicated constant for server

---
 .../examples/simple_box.rs                       |  4 ++--
 .../examples/tic_tac_toe.rs                      | 14 +++-----------
 src/core.rs                                      |  7 +++++++
 src/core/event/client_event.rs                   |  5 +++--
 src/core/event/client_trigger.rs                 |  2 +-
 src/core/event/server_event.rs                   | 12 ++++++------
 src/core/event/server_trigger.rs                 |  4 ++--
 src/lib.rs                                       |  6 +++---
 tests/server_event.rs                            | 16 ++++++++--------
 9 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/bevy_replicon_example_backend/examples/simple_box.rs b/bevy_replicon_example_backend/examples/simple_box.rs
index 14129d87..08410e79 100644
--- a/bevy_replicon_example_backend/examples/simple_box.rs
+++ b/bevy_replicon_example_backend/examples/simple_box.rs
@@ -56,7 +56,7 @@ fn read_cli(mut commands: Commands, cli: Res<Cli>) -> io::Result<()> {
                 PlayerBox {
                     color: GREEN.into(),
                 },
-                BoxOwner(Entity::PLACEHOLDER),
+                BoxOwner(SERVER),
             ));
         }
         Cli::Server { port } => {
@@ -75,7 +75,7 @@ fn read_cli(mut commands: Commands, cli: Res<Cli>) -> io::Result<()> {
                 PlayerBox {
                     color: GREEN.into(),
                 },
-                BoxOwner(Entity::PLACEHOLDER),
+                BoxOwner(SERVER),
             ));
         }
         Cli::Client { port } => {
diff --git a/bevy_replicon_example_backend/examples/tic_tac_toe.rs b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
index 9c626df5..bd4041bb 100644
--- a/bevy_replicon_example_backend/examples/tic_tac_toe.rs
+++ b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
@@ -96,23 +96,15 @@ fn read_cli(mut commands: Commands, cli: Res<Cli>) -> io::Result<()> {
         Cli::Hotseat => {
             info!("starting hotseat");
             // Set all players to server to play from a single machine and start the game right away.
-            commands.spawn((
-                LocalPlayer,
-                Symbol::Cross,
-                PlayerClient(Entity::PLACEHOLDER),
-            ));
-            commands.spawn((
-                LocalPlayer,
-                Symbol::Nought,
-                PlayerClient(Entity::PLACEHOLDER),
-            ));
+            commands.spawn((LocalPlayer, Symbol::Cross, PlayerClient(SERVER)));
+            commands.spawn((LocalPlayer, Symbol::Nought, PlayerClient(SERVER)));
             commands.set_state(GameState::InGame);
         }
         Cli::Server { port, symbol } => {
             info!("starting server as {symbol} at port {port}");
             let server = ExampleServer::new(port)?;
             commands.insert_resource(server);
-            commands.spawn((LocalPlayer, symbol, PlayerClient(Entity::PLACEHOLDER)));
+            commands.spawn((LocalPlayer, symbol, PlayerClient(SERVER)));
         }
         Cli::Client { port } => {
             info!("connecting to port {port}");
diff --git a/src/core.rs b/src/core.rs
index c9b84129..45d9c6ff 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -75,3 +75,10 @@ pub struct NetworkStats {
 #[derive(Component)]
 #[require(NetworkStats)]
 pub struct ConnectedClient;
+
+/// A placeholder entity for a connected client that refers to the listen server (when the server is also a client).
+///
+/// Equal to [`Entity::PLACEHOLDER`].
+///
+/// See also [`ToClients`](event::server_event::ToClients) and [`FromClient`](event::client_event::FromClient) events.
+pub const SERVER: Entity = Entity::PLACEHOLDER;
diff --git a/src/core/event/client_event.rs b/src/core/event/client_event.rs
index 9e8ae747..521b4570 100644
--- a/src/core/event/client_event.rs
+++ b/src/core/event/client_event.rs
@@ -18,6 +18,7 @@ use crate::core::{
     postcard_utils,
     replicon_client::RepliconClient,
     replicon_server::RepliconServer,
+    SERVER,
 };
 
 /// An extension trait for [`App`] for creating client events.
@@ -27,7 +28,7 @@ pub trait ClientEventAppExt {
     /// The API matches [`ClientTriggerAppExt::add_client_trigger`](super::client_trigger::ClientTriggerAppExt::add_client_trigger):
     /// [`FromClient<E>`] will be emitted on the server after sending `E` event on client.
     /// When [`RepliconClient`] is inactive, the event will be drained right after sending and re-emitted
-    /// locally as [`FromClient<E>`] with [`Entity::PLACEHOLDER`].
+    /// locally as [`FromClient<E>`] with [`SERVER`].
     ///
     /// Can be called for events that were registered with [add_event](bevy::app::App::add_event).
     /// A duplicate registration for `E` won't be created.
@@ -315,7 +316,7 @@ impl ClientEvent {
                 any::type_name::<E>()
             );
             client_events.send_batch(events.drain().map(|event| FromClient {
-                client_entity: Entity::PLACEHOLDER,
+                client_entity: SERVER,
                 event,
             }));
         }
diff --git a/src/core/event/client_trigger.rs b/src/core/event/client_trigger.rs
index 1103974c..833cdcdf 100644
--- a/src/core/event/client_trigger.rs
+++ b/src/core/event/client_trigger.rs
@@ -22,7 +22,7 @@ pub trait ClientTriggerAppExt {
     /// The API matches [`ClientEventAppExt::add_client_event`](super::client_event::ClientEventAppExt::add_client_event):
     /// [`FromClient<E>`] will be triggered on the server after triggering `E` event on client.
     /// When [`RepliconClient`](crate::core::replicon_client::RepliconClient) is inactive, the event
-    /// will also be triggered locally as [`FromClient<E>`] with [`Entity::PLACEHOLDER`].
+    /// will also be triggered locally as [`FromClient<E>`] with [`SERVER`](crate::core::SERVER).
     ///
     /// See also [`Self::add_client_trigger_with`] and the [corresponding section](../index.html#from-client-to-server)
     /// from the quick start guide.
diff --git a/src/core/event/server_event.rs b/src/core/event/server_event.rs
index dbcb8356..50a5de27 100644
--- a/src/core/event/server_event.rs
+++ b/src/core/event/server_event.rs
@@ -25,7 +25,7 @@ use crate::core::{
     replicon_client::RepliconClient,
     replicon_server::RepliconServer,
     replicon_tick::RepliconTick,
-    ConnectedClient,
+    ConnectedClient, SERVER,
 };
 
 /// An extension trait for [`App`] for creating client events.
@@ -33,7 +33,7 @@ pub trait ServerEventAppExt {
     /// Registers `E` and [`ToClients<E>`] events.
     ///
     /// `E` will be emitted on client after sending [`ToClients<E>`] on the server.
-    /// If [`Entity::PLACEHOLDER`] is a recipient of the event, then [`ToClients<E>`] will be drained
+    /// If [`SERVER`] is a recipient of the event, then [`ToClients<E>`] will be drained
     /// after sending to clients and `E` events will be emitted on the server.
     ///
     /// Can be called for already existing regular events, a duplicate registration
@@ -350,7 +350,7 @@ impl ServerEvent {
                 }
             }
             SendMode::Direct(entity) => {
-                if entity != Entity::PLACEHOLDER {
+                if entity != SERVER {
                     server.send(entity, self.channel_id, message.clone());
                 }
             }
@@ -509,12 +509,12 @@ impl ServerEvent {
                     events.send(event);
                 }
                 SendMode::BroadcastExcept(entity) => {
-                    if entity != Entity::PLACEHOLDER {
+                    if entity != SERVER {
                         events.send(event);
                     }
                 }
                 SendMode::Direct(entity) => {
-                    if entity == Entity::PLACEHOLDER {
+                    if entity == SERVER {
                         events.send(event);
                     }
                 }
@@ -785,7 +785,7 @@ impl BufferedServerEvents {
                         }
                     }
                     SendMode::Direct(entity) => {
-                        if entity != Entity::PLACEHOLDER && !set.excluded.contains(&entity) {
+                        if entity != SERVER && !set.excluded.contains(&entity) {
                             if let Ok((client_entity, ticks)) = clients.get(entity) {
                                 event.send(server, client_entity, ticks)?;
                             }
diff --git a/src/core/event/server_trigger.rs b/src/core/event/server_trigger.rs
index 69d7c3ec..495d46fa 100644
--- a/src/core/event/server_trigger.rs
+++ b/src/core/event/server_trigger.rs
@@ -21,7 +21,7 @@ pub trait ServerTriggerAppExt {
     ///
     /// The API matches [`ServerEventAppExt::add_server_event`](super::server_event::ServerEventAppExt::add_server_event):
     /// `E` will be triggered on the client after triggering [`ToClients<E>`] event on server.
-    /// If [`Entity::PLACEHOLDER`] is a recipient of the event (not to be confused with trigger target),
+    /// If [`SERVER`](crate::core::SERVER) is a recipient of the event (not to be confused with trigger target),
     /// then `E` events will be emitted on the server as well.
     ///
     /// See also [`Self::add_server_trigger_with`] and the [corresponding section](../index.html#from-server-to-client)
@@ -176,7 +176,7 @@ fn trigger_deserialize<'a, E>(
 /// See also [`ServerTriggerAppExt`].
 pub trait ServerTriggerExt {
     /// Like [`Commands::trigger`], but triggers `E` on server and locally
-    /// if [`Entity::PLACEHOLDER`] is a recipient of the event).
+    /// if [`SERVER`](crate::core::SERVER) is a recipient of the event).
     fn server_trigger(&mut self, event: ToClients<impl Event>);
 
     /// Like [`Self::server_trigger`], but allows you to specify target entities, similar to
diff --git a/src/lib.rs b/src/lib.rs
index bc9a4580..ae5efa72 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -435,7 +435,7 @@ fn receive_events(mut dummy_events: EventReader<FromClient<DummyEvent>>) {
 struct DummyEvent;
 ```
 
-We consider the server or a singleplayer session also as a client with ID [`Entity::PLACEHOLDER`].
+We consider the server or a singleplayer session also as a client with ID [`SERVER`].
 So you can send such events even on server and [`FromClient`] will be emitted for them too.
 
 If you remove [`client_connected`] condition and replace [`server_running`] with
@@ -540,7 +540,7 @@ struct DummyEvent;
 ```
 
 Just like events sent from the client, you can send these events on the server or
-in singleplayer and they will appear locally as regular events (if [`Entity::PLACEHOLDER`] is not excluded
+in singleplayer and they will appear locally as regular events (if [`SERVER`] is not excluded
 from the send list). So the same trick with run conditions will work.
 
 If the event contains an entity, then
@@ -692,7 +692,7 @@ pub mod prelude {
             },
             replicon_client::{RepliconClient, RepliconClientStatus},
             replicon_server::RepliconServer,
-            ConnectedClient, NetworkStats, RepliconCorePlugin,
+            ConnectedClient, NetworkStats, RepliconCorePlugin, SERVER,
         },
         RepliconPlugins,
     };
diff --git a/tests/server_event.rs b/tests/server_event.rs
index fd3aeb96..feb2391b 100644
--- a/tests/server_event.rs
+++ b/tests/server_event.rs
@@ -33,9 +33,9 @@ fn sending_receiving() {
     let test_client_entity = **client_app.world().resource::<TestClientEntity>();
     for (mode, events_count) in [
         (SendMode::Broadcast, 1),
-        (SendMode::Direct(Entity::PLACEHOLDER), 0),
+        (SendMode::Direct(SERVER), 0),
         (SendMode::Direct(test_client_entity), 1),
-        (SendMode::BroadcastExcept(Entity::PLACEHOLDER), 1),
+        (SendMode::BroadcastExcept(SERVER), 1),
         (SendMode::BroadcastExcept(test_client_entity), 0),
     ] {
         server_app.world_mut().send_event(ToClients {
@@ -134,9 +134,9 @@ fn sending_receiving_without_plugins() {
     let test_client_entity = **client_app.world().resource::<TestClientEntity>();
     for (mode, events_count) in [
         (SendMode::Broadcast, 1),
-        (SendMode::Direct(Entity::PLACEHOLDER), 0),
+        (SendMode::Direct(SERVER), 0),
         (SendMode::Direct(test_client_entity), 1),
-        (SendMode::BroadcastExcept(Entity::PLACEHOLDER), 1),
+        (SendMode::BroadcastExcept(SERVER), 1),
         (SendMode::BroadcastExcept(test_client_entity), 0),
     ] {
         server_app.world_mut().send_event(ToClients {
@@ -174,9 +174,9 @@ fn local_resending() {
     const DUMMY_CLIENT_ID: Entity = Entity::from_raw(1);
     for (mode, events_count) in [
         (SendMode::Broadcast, 1),
-        (SendMode::Direct(Entity::PLACEHOLDER), 1),
+        (SendMode::Direct(SERVER), 1),
         (SendMode::Direct(DUMMY_CLIENT_ID), 0),
-        (SendMode::BroadcastExcept(Entity::PLACEHOLDER), 0),
+        (SendMode::BroadcastExcept(SERVER), 0),
         (SendMode::BroadcastExcept(DUMMY_CLIENT_ID), 1),
     ] {
         app.world_mut().send_event(ToClients {
@@ -454,9 +454,9 @@ fn independent() {
     let test_client_entity = **client_app.world().resource::<TestClientEntity>();
     for (mode, events_count) in [
         (SendMode::Broadcast, 1),
-        (SendMode::Direct(Entity::PLACEHOLDER), 0),
+        (SendMode::Direct(SERVER), 0),
         (SendMode::Direct(test_client_entity), 1),
-        (SendMode::BroadcastExcept(Entity::PLACEHOLDER), 1),
+        (SendMode::BroadcastExcept(SERVER), 1),
         (SendMode::BroadcastExcept(test_client_entity), 0),
     ] {
         server_app.world_mut().send_event(ToClients {

From ef039fddf6c0df7152a658577491027aaa35b178 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Sun, 2 Mar 2025 02:03:53 +0200
Subject: [PATCH 07/14] Fix log output for `simple_box ` example

---
 bevy_replicon_example_backend/examples/simple_box.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bevy_replicon_example_backend/examples/simple_box.rs b/bevy_replicon_example_backend/examples/simple_box.rs
index 08410e79..350f02c8 100644
--- a/bevy_replicon_example_backend/examples/simple_box.rs
+++ b/bevy_replicon_example_backend/examples/simple_box.rs
@@ -168,7 +168,7 @@ fn apply_movement(
     mut boxes: Query<(&BoxOwner, &mut BoxPosition)>,
 ) {
     const MOVE_SPEED: f32 = 300.0;
-    info!("received movement from `{}`", trigger.entity());
+    info!("received movement from `{}`", trigger.client_entity);
 
     // Find the sender entity. We don't include the entity as a trigger target to save traffic, since the server knows
     // which entity to apply the input to. We could have a resource that maps connected clients to controlled entities,

From d364aa59226db5202b275a2067eebcbe89594f64 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Sun, 2 Mar 2025 02:04:02 +0200
Subject: [PATCH 08/14] Do not use debug print for entities

---
 bevy_replicon_example_backend/examples/simple_box.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bevy_replicon_example_backend/examples/simple_box.rs b/bevy_replicon_example_backend/examples/simple_box.rs
index 350f02c8..98cc26ad 100644
--- a/bevy_replicon_example_backend/examples/simple_box.rs
+++ b/bevy_replicon_example_backend/examples/simple_box.rs
@@ -115,7 +115,7 @@ fn spawn_clients(trigger: Trigger<OnAdd, ConnectedClient>, mut commands: Command
     let b = (hash & 0xFF) as f32 / 255.0;
 
     // Generate pseudo random color from client entity.
-    info!("spawning box for `{:?}`", trigger.entity());
+    info!("spawning box for `{}`", trigger.entity());
     commands.spawn((
         PlayerBox {
             color: Color::srgb(r, g, b),

From c63ede376c576710970d56d13bf53e4eaa31ba58 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Mon, 3 Mar 2025 00:41:13 +0200
Subject: [PATCH 09/14] Fix example doc link

---
 bevy_replicon_example_backend/examples/tic_tac_toe.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bevy_replicon_example_backend/examples/tic_tac_toe.rs b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
index bd4041bb..382e9273 100644
--- a/bevy_replicon_example_backend/examples/tic_tac_toe.rs
+++ b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
@@ -638,7 +638,7 @@ struct CellPick {
 
 /// A trigger to send client cell entities to server to estabialize mappings for replication.
 ///
-/// See [`TicTacToePlugin::client_start`] for details.
+/// See [`client_start`] for details.
 #[derive(Event, Serialize, Deserialize)]
 struct MapBoard {
     cell_entities: HashMap<usize, Entity>,

From d54ba507a824ba7dc5a5755d47557ded6bfadff6 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Mon, 3 Mar 2025 00:47:16 +0200
Subject: [PATCH 10/14] Adjust naming

---
 .../examples/tic_tac_toe.rs                        | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/bevy_replicon_example_backend/examples/tic_tac_toe.rs b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
index 382e9273..70420d48 100644
--- a/bevy_replicon_example_backend/examples/tic_tac_toe.rs
+++ b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
@@ -96,15 +96,15 @@ fn read_cli(mut commands: Commands, cli: Res<Cli>) -> io::Result<()> {
         Cli::Hotseat => {
             info!("starting hotseat");
             // Set all players to server to play from a single machine and start the game right away.
-            commands.spawn((LocalPlayer, Symbol::Cross, PlayerClient(SERVER)));
-            commands.spawn((LocalPlayer, Symbol::Nought, PlayerClient(SERVER)));
+            commands.spawn((LocalPlayer, PlayerOwner(SERVER), Symbol::Cross));
+            commands.spawn((LocalPlayer, PlayerOwner(SERVER), Symbol::Nought));
             commands.set_state(GameState::InGame);
         }
         Cli::Server { port, symbol } => {
             info!("starting server as {symbol} at port {port}");
             let server = ExampleServer::new(port)?;
             commands.insert_resource(server);
-            commands.spawn((LocalPlayer, symbol, PlayerClient(SERVER)));
+            commands.spawn((LocalPlayer, PlayerOwner(SERVER), symbol));
         }
         Cli::Client { port } => {
             info!("connecting to port {port}");
@@ -244,7 +244,7 @@ fn apply_pick(
     mut commands: Commands,
     cells: Query<(Entity, &Cell)>,
     turn_symbol: Res<TurnSymbol>,
-    players: Query<(&PlayerClient, &Symbol)>,
+    players: Query<(&PlayerOwner, &Symbol)>,
 ) {
     // It's good to check the received data because client could be cheating.
     if trigger.index > GRID_SIZE * GRID_SIZE {
@@ -254,7 +254,7 @@ fn apply_pick(
 
     if !players
         .iter()
-        .any(|(&client, &symbol)| *client == trigger.client_entity && symbol == **turn_symbol)
+        .any(|(&owner, &symbol)| *owner == trigger.client_entity && symbol == **turn_symbol)
     {
         error!(
             "`{}` chose cell {} at wrong turn",
@@ -349,8 +349,8 @@ fn init_client(
     let player_entity = commands
         .spawn((
             Player,
+            PlayerOwner(trigger.client_entity),
             server_symbol.next(),
-            PlayerClient(trigger.client_entity),
         ))
         .id();
     entity_map.insert(player_entity, trigger.player_entity);
@@ -625,7 +625,7 @@ struct LocalPlayer;
 ///
 /// It's not replicated and present only on server or singleplayer.
 #[derive(Clone, Copy, Component, Deref)]
-struct PlayerClient(Entity);
+struct PlayerOwner(Entity);
 
 /// A trigger that indicates a symbol pick.
 ///

From fb83066cc9828f6509c21a245acf135889bda962 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Tue, 4 Mar 2025 01:21:58 +0200
Subject: [PATCH 11/14] Document events

---
 src/core/event/client_event.rs | 4 ++++
 src/core/event/server_event.rs | 7 ++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/core/event/client_event.rs b/src/core/event/client_event.rs
index 521b4570..f8997b4b 100644
--- a/src/core/event/client_event.rs
+++ b/src/core/event/client_event.rs
@@ -407,7 +407,11 @@ impl<E: Event> FromWorld for ClientEventReader<E> {
 /// Emitted only on server.
 #[derive(Clone, Copy, Event, Deref, DerefMut)]
 pub struct FromClient<T> {
+    /// Entity that represents a connected client.
+    ///
+    /// See also [`ConnectedClient`](crate::core::ConnectedClient).
     pub client_entity: Entity,
+    /// Transmitted event.
     #[deref]
     pub event: T,
 }
diff --git a/src/core/event/server_event.rs b/src/core/event/server_event.rs
index 50a5de27..071bccae 100644
--- a/src/core/event/server_event.rs
+++ b/src/core/event/server_event.rs
@@ -810,16 +810,21 @@ impl BufferedServerEvents {
 /// An event that will be send to client(s).
 #[derive(Clone, Copy, Debug, Event, Deref, DerefMut)]
 pub struct ToClients<T> {
+    /// Recipients.
     pub mode: SendMode,
+    /// Transmitted event.
     #[deref]
     pub event: T,
 }
 
-/// Type of server message sending.
+/// Type of server event sending.
 #[derive(Clone, Copy, Debug)]
 pub enum SendMode {
+    /// Send to every client.
     Broadcast,
+    /// Send to every client except the specified connected client.
     BroadcastExcept(Entity),
+    /// Send only to the specified client.
     Direct(Entity),
 }
 

From fd4a394159d50add88f4d7122a8f18996fe5762c Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Tue, 4 Mar 2025 01:27:10 +0200
Subject: [PATCH 12/14] Refactor Tic Tac Toe example

---
 .../examples/tic_tac_toe.rs                   | 115 ++++++++----------
 1 file changed, 54 insertions(+), 61 deletions(-)

diff --git a/bevy_replicon_example_backend/examples/tic_tac_toe.rs b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
index 70420d48..4f0f172a 100644
--- a/bevy_replicon_example_backend/examples/tic_tac_toe.rs
+++ b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
@@ -44,10 +44,12 @@ impl Plugin for TicTacToePlugin {
             .init_resource::<TurnSymbol>()
             .replicate::<Symbol>()
             .add_client_trigger::<CellPick>(ChannelKind::Ordered)
-            .add_client_trigger::<MapBoard>(ChannelKind::Ordered)
+            .add_client_trigger::<MapCells>(ChannelKind::Ordered)
+            .add_server_trigger::<MakeLocal>(ChannelKind::Ordered)
             .insert_resource(ClearColor(BACKGROUND_COLOR))
             .add_observer(disconnect_by_client)
             .add_observer(init_client)
+            .add_observer(make_local)
             .add_observer(apply_pick)
             .add_observer(init_symbols)
             .add_observer(advance_turn)
@@ -96,21 +98,20 @@ fn read_cli(mut commands: Commands, cli: Res<Cli>) -> io::Result<()> {
         Cli::Hotseat => {
             info!("starting hotseat");
             // Set all players to server to play from a single machine and start the game right away.
-            commands.spawn((LocalPlayer, PlayerOwner(SERVER), Symbol::Cross));
-            commands.spawn((LocalPlayer, PlayerOwner(SERVER), Symbol::Nought));
+            commands.spawn((LocalPlayer, Symbol::Cross));
+            commands.spawn((LocalPlayer, Symbol::Nought));
             commands.set_state(GameState::InGame);
         }
         Cli::Server { port, symbol } => {
             info!("starting server as {symbol} at port {port}");
             let server = ExampleServer::new(port)?;
             commands.insert_resource(server);
-            commands.spawn((LocalPlayer, PlayerOwner(SERVER), symbol));
+            commands.spawn((LocalPlayer, symbol));
         }
         Cli::Client { port } => {
             info!("connecting to port {port}");
             let client = ExampleClient::new(port)?;
             commands.insert_resource(client);
-            commands.spawn(LocalPlayer);
         }
     }
 
@@ -231,6 +232,8 @@ fn pick_cell(
         let cell = cells
             .get(trigger.entity())
             .expect("cells should have assigned indices");
+        // We don't check if a cell can't be picked on client on purpose
+        // just to demonstrate how server can receive invalid requests from a client.
         info!("picking cell {}", cell.index);
         commands.client_trigger(CellPick { index: cell.index });
     }
@@ -242,30 +245,27 @@ fn pick_cell(
 fn apply_pick(
     trigger: Trigger<FromClient<CellPick>>,
     mut commands: Commands,
-    cells: Query<(Entity, &Cell)>,
+    cells: Query<(Entity, &Cell), Without<Symbol>>,
     turn_symbol: Res<TurnSymbol>,
-    players: Query<(&PlayerOwner, &Symbol)>,
+    players: Query<&Symbol>,
 ) {
     // It's good to check the received data because client could be cheating.
-    if trigger.index > GRID_SIZE * GRID_SIZE {
-        error!("received invalid cell index {}", trigger.index);
-        return;
-    }
-
-    if !players
-        .iter()
-        .any(|(&owner, &symbol)| *owner == trigger.client_entity && symbol == **turn_symbol)
-    {
-        error!(
-            "`{}` chose cell {} at wrong turn",
-            trigger.client_entity, trigger.index
-        );
-        return;
+    if trigger.client_entity != SERVER {
+        let symbol = *players
+            .get(trigger.client_entity)
+            .expect("all clients should have assigned symbols");
+        if symbol != **turn_symbol {
+            error!(
+                "`{}` chose cell {} at wrong turn",
+                trigger.client_entity, trigger.index
+            );
+            return;
+        }
     }
 
     let Some((entity, _)) = cells.iter().find(|(_, cell)| cell.index == trigger.index) else {
         error!(
-            "`{}` has chosen an already occupied cell {}",
+            "`{}` has chosen occupied or invalid cell {}",
             trigger.client_entity, trigger.index
         );
         return;
@@ -309,20 +309,13 @@ fn init_symbols(
 /// server to receive replication to already existing entities.
 ///
 /// Used only for client.
-fn client_start(
-    mut commands: Commands,
-    cells: Query<(Entity, &Cell)>,
-    player_entity: Single<Entity, With<LocalPlayer>>,
-) {
-    let mut cell_entities = HashMap::new();
+fn client_start(mut commands: Commands, cells: Query<(Entity, &Cell)>) {
+    let mut entities = HashMap::new();
     for (entity, cell) in &cells {
-        cell_entities.insert(cell.index, entity);
+        entities.insert(cell.index, entity);
     }
 
-    commands.client_trigger(MapBoard {
-        cell_entities,
-        player_entity: *player_entity,
-    });
+    commands.client_trigger(MapCells(entities));
     commands.set_state(GameState::InGame);
 }
 
@@ -330,14 +323,14 @@ fn client_start(
 ///
 /// Used only for server.
 fn init_client(
-    trigger: Trigger<FromClient<MapBoard>>,
+    trigger: Trigger<FromClient<MapCells>>,
     mut commands: Commands,
     cells: Query<(Entity, &Cell)>,
     server_symbol: Single<&Symbol, With<LocalPlayer>>,
 ) {
     let mut entity_map = ClientEntityMap::default();
     for (server_entity, cell) in &cells {
-        let Some(&client_entity) = trigger.cell_entities.get(&cell.index) else {
+        let Some(&client_entity) = trigger.get(&cell.index) else {
             error!("received cells missing index {}, disconnecting", cell.index);
             commands.set_state(GameState::Disconnected);
             return;
@@ -346,22 +339,29 @@ fn init_client(
         entity_map.insert(server_entity, client_entity);
     }
 
-    let player_entity = commands
-        .spawn((
-            Player,
-            PlayerOwner(trigger.client_entity),
-            server_symbol.next(),
-        ))
-        .id();
-    entity_map.insert(player_entity, trigger.player_entity);
-
     // When `replicate_after_connect` is set to false, `ReplicatedClient`
-    // and `ClientEntityMap` are not inserted automatically to client entities.
-    // We need to insert them manually to start replication.
+    // needs to be manually inserted to start replication.
+    // We also utilize the same entity as a player.
+    commands.entity(trigger.client_entity).insert((
+        Player,
+        server_symbol.next(),
+        ReplicatedClient,
+        entity_map,
+    ));
+
+    commands.server_trigger_targets(
+        ToClients {
+            mode: SendMode::Direct(trigger.client_entity),
+            event: MakeLocal,
+        },
+        trigger.client_entity,
+    );
+
     commands.set_state(GameState::InGame);
-    commands
-        .entity(trigger.client_entity)
-        .insert((ReplicatedClient, entity_map));
+}
+
+fn make_local(trigger: Trigger<MakeLocal>, mut commands: Commands) {
+    commands.entity(trigger.entity()).insert(LocalPlayer);
 }
 
 /// Sets the game in disconnected state if client closes the connection.
@@ -619,14 +619,6 @@ struct Player;
 #[require(Player)]
 struct LocalPlayer;
 
-/// Identifies which player controlled by which client.
-///
-/// Points to client entity. Used to verify client's turns.
-///
-/// It's not replicated and present only on server or singleplayer.
-#[derive(Clone, Copy, Component, Deref)]
-struct PlayerOwner(Entity);
-
 /// A trigger that indicates a symbol pick.
 ///
 /// We don't replicate the whole UI, so we can't just send the picked entity because on server it may be different.
@@ -639,8 +631,9 @@ struct CellPick {
 /// A trigger to send client cell entities to server to estabialize mappings for replication.
 ///
 /// See [`client_start`] for details.
+#[derive(Event, Deref, Serialize, Deserialize)]
+struct MapCells(HashMap<usize, Entity>);
+
+/// A trigger that instructs the client to mark a specific entity as [`LocalPlayer`].
 #[derive(Event, Serialize, Deserialize)]
-struct MapBoard {
-    cell_entities: HashMap<usize, Entity>,
-    player_entity: Entity,
-}
+struct MakeLocal;

From 066734c3998379b167d4c2d4566830525c426bc8 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Tue, 4 Mar 2025 01:32:16 +0200
Subject: [PATCH 13/14] Adjust docs

---
 bevy_replicon_example_backend/examples/tic_tac_toe.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/bevy_replicon_example_backend/examples/tic_tac_toe.rs b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
index 4f0f172a..2aefbd4c 100644
--- a/bevy_replicon_example_backend/examples/tic_tac_toe.rs
+++ b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
@@ -328,6 +328,10 @@ fn init_client(
     cells: Query<(Entity, &Cell)>,
     server_symbol: Single<&Symbol, With<LocalPlayer>>,
 ) {
+    // Usually entity map modified directly on an connected client entity,
+    // it's a required component of `ReplicatedClient`.
+    // But since we set `replicate_after_connect` to `false`,
+    // we insert it together with `ReplicatedClient`.
     let mut entity_map = ClientEntityMap::default();
     for (server_entity, cell) in &cells {
         let Some(&client_entity) = trigger.get(&cell.index) else {
@@ -339,9 +343,7 @@ fn init_client(
         entity_map.insert(server_entity, client_entity);
     }
 
-    // When `replicate_after_connect` is set to false, `ReplicatedClient`
-    // needs to be manually inserted to start replication.
-    // We also utilize the same entity as a player.
+    // Utilize client entity as a player for convenient lookups by `client_entity`.
     commands.entity(trigger.client_entity).insert((
         Player,
         server_symbol.next(),

From 1e217497ad7b8114e2e912e8943ba5028ff3d7cf Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Tue, 4 Mar 2025 18:54:30 +0200
Subject: [PATCH 14/14] Add name to `ConnectedClient`

---
 src/core.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core.rs b/src/core.rs
index 45d9c6ff..80168550 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -73,7 +73,7 @@ pub struct NetworkStats {
 ///
 /// See also [`ReplicatedClient`](crate::server::ReplicatedClient).
 #[derive(Component)]
-#[require(NetworkStats)]
+#[require(Name(|| Name::new("Connected client")), NetworkStats)]
 pub struct ConnectedClient;
 
 /// A placeholder entity for a connected client that refers to the listen server (when the server is also a client).