diff --git a/CHANGELOG.md b/CHANGELOG.md
index 27a014bf..b6130e3c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Rename `client_event_registry` module into `registry`.
+- Replace "event" with "message" and "trigger" with "event" in types, methods and modules according to the new naming in Bevy.
+- Split `RemoteMessageRegistry::*_channel` methods for messages and events into dedicated methods for each type.
+
+### Removed
+
+- `trigger_*_targets`. Targets in Bevy now stored inside events. When you move entities to your events, dont't forget to use `register_*_event_mapped` in order to properly map them.
 
 ### Added
 
diff --git a/Cargo.toml b/Cargo.toml
index 45067840..01f7b90c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,9 +28,7 @@ all-features = true
 members = ["bevy_replicon_example_backend"]
 
 [dependencies]
-bevy = { version = "0.16.0", default-features = false, features = [
-  "bevy_state",
-] }
+bevy = { version = "0.17", default-features = false, features = ["bevy_state"] }
 log = "0.4" # Directly depend on `log` like other `no_std` Bevy crates, since `bevy_log` currently requires `std`.
 petgraph = { version = "0.8", default-features = false, features = [
   "stable_graph",
@@ -52,9 +50,9 @@ bytes = { version = "1.10", default-features = false, features = [
 ] }
 
 [dev-dependencies]
-bevy = { version = "0.16.0", default-features = false, features = [
+bevy = { version = "0.17", default-features = false, features = [
   "bevy_log",
-  "bevy_sprite",
+  "bevy_sprite_render",
   "serialize",
 ] }
 test-log = "0.2"
@@ -90,11 +88,11 @@ name = "mutations"
 required-features = ["client", "server"]
 
 [[test]]
-name = "client_event"
+name = "client_message"
 required-features = ["client", "server"]
 
 [[test]]
-name = "client_trigger"
+name = "client_event"
 required-features = ["client", "server"]
 
 [[test]]
@@ -122,11 +120,11 @@ name = "scene"
 required-features = ["scene"]
 
 [[test]]
-name = "server_event"
+name = "server_message"
 required-features = ["client", "server"]
 
 [[test]]
-name = "server_trigger"
+name = "server_event"
 required-features = ["client", "server"]
 
 [[test]]
diff --git a/bevy_replicon_example_backend/Cargo.toml b/bevy_replicon_example_backend/Cargo.toml
index c22a7d92..2bb15ec9 100644
--- a/bevy_replicon_example_backend/Cargo.toml
+++ b/bevy_replicon_example_backend/Cargo.toml
@@ -21,20 +21,21 @@ license = "MIT OR Apache-2.0"
 include = ["/src", "../LICENSE*"]
 
 [dependencies]
-bevy = { version = "0.16.0", default-features = false, features = ["bevy_log"] }
+bevy = { version = "0.17", default-features = false, features = ["bevy_log"] }
 bevy_replicon = { path = "..", version = "0.35.0", default-features = false }
 fastrand = "2.3"
 
 [dev-dependencies]
-bevy = { version = "0.16.0", default-features = false, features = [
+bevy = { version = "0.17", default-features = false, features = [
   "bevy_gizmos",
   "bevy_text",
   "bevy_ui_picking_backend",
-  "bevy_ui",
+  "bevy_ui_render",
   "bevy_window",
   "default_font",
   "serialize",
   "x11",
+  "zstd_rust",
 ] }
 clap = { version = "4.1", features = ["derive"] }
 fastrand-contrib = "0.1"
diff --git a/bevy_replicon_example_backend/examples/authoritative_rts.rs b/bevy_replicon_example_backend/examples/authoritative_rts.rs
index 89865613..bbd37b73 100644
--- a/bevy_replicon_example_backend/examples/authoritative_rts.rs
+++ b/bevy_replicon_example_backend/examples/authoritative_rts.rs
@@ -16,6 +16,7 @@ use std::{
 };
 
 use bevy::{
+    camera::primitives::Aabb,
     color::palettes::tailwind::{
         BLUE_500, GREEN_500, LIME_500, ORANGE_500, PINK_500, PURPLE_500, RED_500, TEAL_500,
         YELLOW_500,
@@ -23,7 +24,6 @@ use bevy::{
     ecs::entity::MapEntities,
     platform::collections::HashMap,
     prelude::*,
-    render::primitives::Aabb,
 };
 use bevy_replicon::prelude::*;
 use bevy_replicon_example_backend::{ExampleClient, ExampleServer, RepliconExampleBackendPlugins};
@@ -44,9 +44,9 @@ fn main() {
         .replicate::<Unit>()
         .replicate::<Command>()
         .replicate_as::<Transform, Transform2DWithoutScale>()
-        .add_client_trigger::<TeamRequest>(Channel::Unordered)
-        .add_client_trigger::<UnitSpawn>(Channel::Unordered)
-        .add_mapped_client_trigger::<UnitsMove>(Channel::Unordered)
+        .add_client_event::<TeamRequest>(Channel::Unordered)
+        .add_client_event::<UnitSpawn>(Channel::Unordered)
+        .add_mapped_client_event::<MoveUnits>(Channel::Unordered)
         .add_observer(apply_team_request)
         .add_observer(trigger_unit_spawn)
         .add_observer(apply_unit_spawn)
@@ -131,29 +131,29 @@ fn trigger_team_request(mut commands: Commands, team: Res<Team>) {
 
 /// Assigns a team to a player.
 fn apply_team_request(
-    trigger: Trigger<FromClient<TeamRequest>>,
-    mut events: EventWriter<DisconnectRequest>,
+    team_request: On<FromClient<TeamRequest>>,
+    mut disconnects: MessageWriter<DisconnectRequest>,
     mut teams: ResMut<ClientTeams>,
 ) {
-    if let Some((client_id, team)) = teams.iter().find(|&(_, team)| *team == trigger.team) {
+    if let Some((client_id, team)) = teams.iter().find(|&(_, team)| *team == team_request.team) {
         error!(
             "`{}` requested team `{team:?}`, but it's already taken by `{client_id}`",
-            trigger.client_id,
+            team_request.client_id,
         );
-        let client = trigger
+        let client = team_request
             .client_id
             .entity()
             .expect("server can't request an invalid team");
-        events.write(DisconnectRequest { client });
+        disconnects.write(DisconnectRequest { client });
         return;
     }
 
     info!(
         "associating `{}` with team `{:?}`",
-        trigger.client_id, trigger.team
+        team_request.client_id, team_request.team
     );
 
-    teams.insert(trigger.client_id, trigger.team);
+    teams.insert(team_request.client_id, team_request.team);
 }
 
 /// Requests spawning a unit at the click location.
@@ -165,16 +165,16 @@ fn apply_team_request(
 /// This also makes the logic independent of camera position - even though in
 /// this demo the camera cannot move.
 fn trigger_unit_spawn(
-    trigger: Trigger<Pointer<Pressed>>,
+    press: On<Pointer<Press>>,
     mut commands: Commands,
     camera: Single<(&Camera, &GlobalTransform)>,
 ) -> Result<()> {
-    if trigger.button != PointerButton::Middle {
+    if press.button != PointerButton::Middle {
         return Ok(());
     }
 
     let (camera, transform) = *camera;
-    let position = camera.viewport_to_world_2d(transform, trigger.pointer_location.position)?;
+    let position = camera.viewport_to_world_2d(transform, press.pointer_location.position)?;
 
     commands.client_trigger(UnitSpawn { position });
 
@@ -186,21 +186,21 @@ fn trigger_unit_spawn(
 /// Executed on server and singleplayer.
 /// The unit will be replicated back to clients.
 fn apply_unit_spawn(
-    trigger: Trigger<FromClient<UnitSpawn>>,
+    spawn: On<FromClient<UnitSpawn>>,
     mut commands: Commands,
     teams: Res<ClientTeams>,
 ) {
-    let Some(&team) = teams.get(&trigger.client_id) else {
+    let Some(&team) = teams.get(&spawn.client_id) else {
         error!(
             "`{}` attempted to spawn a unit but has no team",
-            trigger.client_id
+            spawn.client_id
         );
         return;
     };
 
     commands.spawn((
         Unit { team },
-        Transform::from_translation(trigger.position.extend(0.0)),
+        Transform::from_translation(spawn.position.extend(0.0)),
     ));
 }
 
@@ -215,12 +215,12 @@ fn apply_unit_spawn(
 /// Works for initialization on both the server (when a unit
 /// is spawned) and the client (when the unit is replicated).
 fn init_unit(
-    trigger: Trigger<OnInsert, Unit>,
+    insert: On<Insert, Unit>,
     unit_mesh: Local<UnitMesh>,
     unit_materials: Local<UnitMaterials>,
     mut units: Query<(&Unit, &mut Mesh2d, &mut MeshMaterial2d<ColorMaterial>)>,
 ) {
-    let (unit, mut mesh, mut material) = units.get_mut(trigger.target()).unwrap();
+    let (unit, mut mesh, mut material) = units.get_mut(insert.entity).unwrap();
     **mesh = unit_mesh.0.clone();
     **material = unit_materials.get(&unit.team).unwrap().clone();
 }
@@ -229,24 +229,22 @@ fn init_unit(
 ///
 /// The selection is local to the player and is not networked.
 fn select_units(
-    trigger: Trigger<Pointer<Drag>>,
+    drag: On<Pointer<Drag>>,
     mut commands: Commands,
     mut selection: ResMut<Selection>,
     team: Res<Team>,
     camera: Single<(&Camera, &GlobalTransform)>,
     units: Query<(Entity, &Unit, &GlobalTransform, &Aabb, Has<Selected>)>,
 ) -> Result<()> {
-    if trigger.button != PointerButton::Primary {
+    if drag.button != PointerButton::Primary {
         return Ok(());
     }
 
     let (camera, transform) = *camera;
 
-    let origin = camera.viewport_to_world_2d(
-        transform,
-        trigger.pointer_location.position - trigger.distance,
-    )?;
-    let end = camera.viewport_to_world_2d(transform, trigger.pointer_location.position)?;
+    let origin =
+        camera.viewport_to_world_2d(transform, drag.pointer_location.position - drag.distance)?;
+    let end = camera.viewport_to_world_2d(transform, drag.pointer_location.position)?;
 
     selection.rect = Rect::from_corners(origin, end);
     selection.active = true;
@@ -268,16 +266,16 @@ fn select_units(
 }
 
 /// Stops displaying the selection rectangle.
-fn end_selection(_trigger: Trigger<Pointer<DragEnd>>, mut rect: ResMut<Selection>) {
+fn end_selection(_on: On<Pointer<DragEnd>>, mut rect: ResMut<Selection>) {
     rect.active = false;
 }
 
 fn clear_selection(
-    trigger: Trigger<Pointer<Pressed>>,
+    press: On<Pointer<Press>>,
     mut commands: Commands,
     units: Query<Entity, With<Selected>>,
 ) {
-    if trigger.button != PointerButton::Primary {
+    if press.button != PointerButton::Primary {
         return;
     }
     for unit in &units {
@@ -287,19 +285,19 @@ fn clear_selection(
 
 /// Requests movement into a location for previously the selected units.
 fn trigger_units_move(
-    trigger: Trigger<Pointer<Pressed>>,
+    press: On<Pointer<Press>>,
     mut commands: Commands,
     camera: Single<(&Camera, &GlobalTransform)>,
     units: Populated<Entity, With<Selected>>,
 ) -> Result<()> {
-    if trigger.button != PointerButton::Secondary {
+    if press.button != PointerButton::Secondary {
         return Ok(());
     }
 
     let (camera, transform) = *camera;
-    let position = camera.viewport_to_world_2d(transform, trigger.pointer_location.position)?;
+    let position = camera.viewport_to_world_2d(transform, press.pointer_location.position)?;
 
-    commands.client_trigger(UnitsMove {
+    commands.client_trigger(MoveUnits {
         units: units.iter().collect(),
         position,
     });
@@ -314,7 +312,7 @@ const MOVE_SPACING: f32 = 30.0;
 /// Each unit receives a unique `Command::Move`, arranged in a grid formation
 /// centered on the requested position. The grid is oriented toward that position.
 fn apply_units_move(
-    trigger: Trigger<FromClient<UnitsMove>>,
+    move_units: On<FromClient<MoveUnits>>,
     teams: Res<ClientTeams>,
     mut slots: Local<Vec<Vec2>>,
     mut positions: Local<Vec<Vec2>>,
@@ -323,26 +321,26 @@ fn apply_units_move(
     // Validate the received data since the client could be malicious.
     // For example, on the client side we skip empty selections, but a modified
     // client could bypass this and cause a division by zero on the server.
-    if trigger.units.is_empty() {
-        error!("`{}` attempted to move zero units", trigger.client_id);
+    if move_units.units.is_empty() {
+        error!("`{}` attempted to move zero units", move_units.client_id);
         return;
     }
 
-    let Some(&client_team) = teams.get(&trigger.client_id) else {
+    let Some(&client_team) = teams.get(&move_units.client_id) else {
         error!(
             "`{}` attempted to move units but has no team",
-            trigger.client_id
+            move_units.client_id
         );
         return;
     };
 
     positions.clear();
-    positions.reserve(trigger.units.len());
-    for (unit, transform, _) in units.iter_many(&trigger.units) {
+    positions.reserve(move_units.units.len());
+    for (unit, transform, _) in units.iter_many(&move_units.units) {
         if unit.team != client_team {
             error!(
                 "`{}` has team `{client_team:?}`, but tried to move unit with team `{:?}`",
-                trigger.client_id, unit.team
+                move_units.client_id, unit.team
             );
             return;
         }
@@ -350,7 +348,7 @@ fn apply_units_move(
         positions.push(transform.translation().truncate());
     }
 
-    let units_count = trigger.units.len();
+    let units_count = move_units.units.len();
     let cols = (units_count as f32).sqrt().ceil() as usize;
     let rows = units_count.div_ceil(cols);
     let centering_offset = -Vec2::new(cols as f32 - 1.0, rows as f32 - 1.0) / 2.0 * MOVE_SPACING;
@@ -358,7 +356,7 @@ fn apply_units_move(
     // Orientation basis to make grid facing from group centroid toward the click.
     let positions_sum = positions.iter().sum::<Vec2>();
     let centroid = positions_sum / units_count as f32;
-    let forward = (trigger.position - centroid).normalize_or(Vec2::Y);
+    let forward = (move_units.position - centroid).normalize_or(Vec2::Y);
     let right = Vec2::new(forward.y, -forward.x);
     let rotation = Mat2::from_cols(right, forward);
 
@@ -369,7 +367,7 @@ fn apply_units_move(
         let col = index % cols;
 
         let grid_position = centering_offset + Vec2::new(col as f32, row as f32) * MOVE_SPACING;
-        slots.push(trigger.position + rotation * grid_position);
+        slots.push(move_units.position + rotation * grid_position);
     }
 
     // Pick closest slot for each unit using
@@ -385,7 +383,7 @@ fn apply_units_move(
         .collect();
     let (_, unit_to_slot) = kuhn_munkres_min(&weights);
 
-    let mut iter = units.iter_many_mut(&trigger.units);
+    let mut iter = units.iter_many_mut(&move_units.units);
     for &slot_index in &unit_to_slot {
         let (.., mut command) = iter.fetch_next().unwrap();
         *command = Command::Move(slots[slot_index]);
@@ -649,21 +647,21 @@ impl FromWorld for UnitMaterials {
     }
 }
 
-/// A trigger to join a specific team for a client.
+/// Request to join a team.
 #[derive(Event, Serialize, Deserialize)]
 struct TeamRequest {
     team: Team,
 }
 
-/// A trigger that spawns a unit at a location.
+/// Request to spawn a unit at a location.
 #[derive(Event, Serialize, Deserialize)]
 struct UnitSpawn {
     position: Vec2,
 }
 
-/// A trigger that orders units to move to a specified location.
+/// Orders units to move to a specified location.
 #[derive(Event, Serialize, Deserialize, MapEntities, Clone)]
-struct UnitsMove {
+struct MoveUnits {
     #[entities]
     units: Vec<Entity>,
     position: Vec2,
diff --git a/bevy_replicon_example_backend/examples/deterministic_boids.rs b/bevy_replicon_example_backend/examples/deterministic_boids.rs
index 9dde35c0..14de1052 100644
--- a/bevy_replicon_example_backend/examples/deterministic_boids.rs
+++ b/bevy_replicon_example_backend/examples/deterministic_boids.rs
@@ -132,12 +132,12 @@ fn spawn_boids(commands: &mut Commands) {
 /// is inserted. This way, visuals are applied automatically both when a boid is spawned
 /// manually on the server (or in singleplayer) and when it is replicated to a client.
 fn init_boid(
-    trigger: Trigger<OnInsert, Boid>,
+    insert: On<Insert, Boid>,
     boid_mesh: Local<BoidMesh>,
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut boids: Query<(&Boid, &mut Mesh2d, &mut MeshMaterial2d<ColorMaterial>)>,
 ) {
-    let (boid, mut mesh, mut material) = boids.get_mut(trigger.target()).unwrap();
+    let (boid, mut mesh, mut material) = boids.get_mut(insert.entity).unwrap();
 
     // All boids share the same mesh, but each gets a unique material from its color.
     **mesh = boid_mesh.0.clone();
diff --git a/bevy_replicon_example_backend/examples/simple_button.rs b/bevy_replicon_example_backend/examples/simple_button.rs
index d3a4fb4e..6c32d017 100644
--- a/bevy_replicon_example_backend/examples/simple_button.rs
+++ b/bevy_replicon_example_backend/examples/simple_button.rs
@@ -4,7 +4,7 @@
 
 use std::net::{IpAddr, Ipv4Addr};
 
-use bevy::prelude::*;
+use bevy::{ecs::entity::MapEntities, prelude::*};
 use bevy_replicon::prelude::*;
 use bevy_replicon_example_backend::{ExampleClient, ExampleServer, RepliconExampleBackendPlugins};
 use clap::Parser;
@@ -21,7 +21,7 @@ fn main() {
         .replicate::<UiRoot>()
         .replicate::<ToggleButton>()
         .replicate_filtered::<ChildOf, With<ToggleButton>>() // Replicate parent only for `ToggleButton`.
-        .add_client_trigger::<RemoteToggle>(Channel::Unordered)
+        .add_mapped_client_event::<RemoteToggle>(Channel::Unordered)
         .add_observer(init_toggle_button)
         .add_observer(trigger_remote_toggle)
         .add_observer(apply_remote_toggle)
@@ -64,8 +64,8 @@ fn setup(mut commands: Commands, cli: Res<Cli>) -> Result<()> {
 }
 
 /// Since we can't include hierarchy into required components, initialize it on insertion.
-fn init_toggle_button(trigger: Trigger<OnAdd, ToggleButton>, mut commands: Commands) {
-    commands.entity(trigger.target()).with_child((
+fn init_toggle_button(add: On<Add, ToggleButton>, mut commands: Commands) {
+    commands.entity(add.entity).with_child((
         Text::default(),
         TextShadow::default(),
         TextFont {
@@ -81,12 +81,14 @@ fn init_toggle_button(trigger: Trigger<OnAdd, ToggleButton>, mut commands: Comma
 /// Used on both the server and the clients.
 /// Triggering this on the server will emit [`FromClient`] with [`ClientId::Server`].
 fn trigger_remote_toggle(
-    trigger: Trigger<Pointer<Click>>,
+    click: On<Pointer<Click>>,
     mut commands: Commands,
     buttons: Query<(), With<ToggleButton>>,
 ) {
-    if buttons.get(trigger.target()).is_ok() {
-        commands.client_trigger_targets(RemoteToggle, trigger.target());
+    if buttons.get(click.entity).is_ok() {
+        commands.client_trigger(RemoteToggle {
+            entity: click.entity,
+        });
     }
 }
 
@@ -95,10 +97,10 @@ fn trigger_remote_toggle(
 /// Executed on server and singleplayer.
 /// The state will be replicated back to clients.
 fn apply_remote_toggle(
-    trigger: Trigger<FromClient<RemoteToggle>>,
+    toggle: On<FromClient<RemoteToggle>>,
     mut buttons: Query<&mut ToggleButton>,
 ) {
-    if let Ok(mut toggle) = buttons.get_mut(trigger.target()) {
+    if let Ok(mut toggle) = buttons.get_mut(toggle.entity) {
         **toggle = !**toggle
     }
 }
@@ -200,11 +202,14 @@ struct UiRoot;
         align_items: AlignItems::Center,
         ..Default::default()
     },
-    BorderColor(Color::WHITE),
+    BorderColor::all(Color::WHITE),
     BorderRadius::MAX,
 )]
 struct ToggleButton(bool);
 
-/// A client trigger that toggles the buttons it targets.
-#[derive(Event, Serialize, Deserialize)]
-struct RemoteToggle;
+/// Toggles the buttons it targets.
+#[derive(EntityEvent, MapEntities, Serialize, Deserialize, Clone, Copy)]
+struct RemoteToggle {
+    #[entities]
+    entity: Entity,
+}
diff --git a/bevy_replicon_example_backend/examples/tic_tac_toe.rs b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
index 9b295915..901cc496 100644
--- a/bevy_replicon_example_backend/examples/tic_tac_toe.rs
+++ b/bevy_replicon_example_backend/examples/tic_tac_toe.rs
@@ -22,7 +22,7 @@ fn main() {
             DefaultPlugins.build().set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Tic-Tac-Toe".into(),
-                    resolution: (800.0, 600.0).into(),
+                    resolution: (800, 600).into(),
                     ..Default::default()
                 }),
                 ..Default::default()
@@ -34,7 +34,7 @@ fn main() {
         .init_resource::<SymbolFont>()
         .init_resource::<TurnSymbol>()
         .replicate::<Symbol>()
-        .add_client_trigger::<CellPick>(Channel::Ordered)
+        .add_client_event::<PickCell>(Channel::Ordered)
         .insert_resource(ClearColor(BACKGROUND_COLOR))
         .add_observer(disconnect_by_client)
         .add_observer(init_client)
@@ -214,7 +214,7 @@ fn setup_ui(mut commands: Commands, symbol_font: Res<SymbolFont>) {
 ///
 /// We don't just send mouse clicks to save traffic, they contain a lot of extra information.
 fn pick_cell(
-    trigger: Trigger<Pointer<Click>>,
+    click: On<Pointer<Click>>,
     mut commands: Commands,
     turn_symbol: Res<TurnSymbol>,
     game_state: Res<State<GameState>>,
@@ -230,39 +230,39 @@ fn pick_cell(
     }
 
     let cell = cells
-        .get(trigger.target())
+        .get(click.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 });
+    commands.client_trigger(PickCell { index: cell.index });
 }
 
 /// Handles cell pick events.
 ///
 /// Used only for single-player and server.
 fn apply_pick(
-    trigger: Trigger<FromClient<CellPick>>,
+    pick: On<FromClient<PickCell>>,
     mut commands: Commands,
     cells: Query<(Entity, &Cell), Without<Symbol>>,
     turn_symbol: Res<TurnSymbol>,
     players: Query<&Symbol>,
 ) {
     // It's good to check the received data because client could be cheating.
-    if let ClientId::Client(client) = trigger.client_id {
+    if let ClientId::Client(client) = pick.client_id {
         let symbol = *players
             .get(client)
             .expect("all clients should have assigned symbols");
         if symbol != **turn_symbol {
-            error!("`{client}` chose cell {} at wrong turn", trigger.index);
+            error!("`{client}` chose cell {} at wrong turn", pick.index);
             return;
         }
     }
 
-    let Some((entity, _)) = cells.iter().find(|(_, cell)| cell.index == trigger.index) else {
+    let Some((entity, _)) = cells.iter().find(|(_, cell)| cell.index == pick.index) else {
         error!(
             "`{}` has chosen occupied or invalid cell {}",
-            trigger.client_id, trigger.index
+            pick.client_id, pick.index
         );
         return;
     };
@@ -272,18 +272,18 @@ fn apply_pick(
 
 /// Initializes spawned symbol on client after replication and on server / single-player right after the spawn.
 fn init_symbols(
-    trigger: Trigger<OnAdd, Symbol>,
+    add: On<Add, Symbol>,
     mut commands: Commands,
     symbol_font: Res<SymbolFont>,
     mut cells: Query<(&mut BackgroundColor, &Symbol), With<Button>>,
 ) {
-    let Ok((mut background, symbol)) = cells.get_mut(trigger.target()) else {
+    let Ok((mut background, symbol)) = cells.get_mut(add.entity) else {
         return;
     };
     *background = BACKGROUND_COLOR.into();
 
     commands
-        .entity(trigger.target())
+        .entity(add.entity)
         .remove::<Interaction>()
         .with_child((
             Text::new(symbol.glyph()),
@@ -307,12 +307,12 @@ fn client_start(mut commands: Commands) {
 ///
 /// Used only for server.
 fn init_client(
-    trigger: Trigger<OnAdd, AuthorizedClient>,
+    add: On<Add, AuthorizedClient>,
     mut commands: Commands,
     server_symbol: Single<&Symbol, With<LocalPlayer>>,
 ) {
     // Utilize client entity as a player for convenient lookups by `client`.
-    commands.entity(trigger.target()).insert((
+    commands.entity(add.entity).insert((
         ClientPlayer,
         Signature::of::<ClientPlayer>(),
         server_symbol.next(),
@@ -325,7 +325,7 @@ fn init_client(
 ///
 /// Used only for server.
 fn disconnect_by_client(
-    _trigger: Trigger<OnRemove, ConnectedClient>,
+    _on: On<Remove, ConnectedClient>,
     game_state: Res<State<GameState>>,
     mut commands: Commands,
 ) {
@@ -351,7 +351,7 @@ fn stop_networking(mut commands: Commands) {
 
 /// Checks the winner and advances the turn.
 fn advance_turn(
-    _trigger: Trigger<OnAdd, Symbol>,
+    _on: On<Add, Symbol>,
     mut commands: Commands,
     mut turn_symbol: ResMut<TurnSymbol>,
     symbols: Query<(&Cell, &Symbol)>,
@@ -586,11 +586,11 @@ struct LocalPlayer;
 #[require(Replicated, Signature::of::<ClientPlayer>())]
 struct ClientPlayer;
 
-/// A trigger that indicates a symbol pick.
+/// 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.
 /// So we send the cell location in grid and calculate the entity on server based on this.
-#[derive(Clone, Copy, Deserialize, Event, Serialize)]
-struct CellPick {
+#[derive(Event, Deserialize, Serialize, Clone, Copy)]
+struct PickCell {
     index: usize,
 }
diff --git a/bevy_replicon_example_backend/src/server.rs b/bevy_replicon_example_backend/src/server.rs
index 4744c7ae..7eb5ce65 100644
--- a/bevy_replicon_example_backend/src/server.rs
+++ b/bevy_replicon_example_backend/src/server.rs
@@ -123,7 +123,7 @@ fn receive_packets(
 
 fn send_packets(
     mut commands: Commands,
-    mut disconnect_events: EventReader<DisconnectRequest>,
+    mut disconnects: MessageReader<DisconnectRequest>,
     mut messages: ResMut<ServerMessages>,
     mut clients: Query<&mut ExampleConnection>,
 ) {
@@ -137,9 +137,9 @@ fn send_packets(
         }
     }
 
-    for event in disconnect_events.read() {
-        debug!("disconnecting client `{}` by request", event.client);
-        commands.entity(event.client).despawn();
+    for disconnect in disconnects.read() {
+        debug!("disconnecting client `{}` by request", disconnect.client);
+        commands.entity(disconnect.client).despawn();
     }
 }
 
diff --git a/bevy_replicon_example_backend/tests/backend.rs b/bevy_replicon_example_backend/tests/backend.rs
index ee855f84..e03d5838 100644
--- a/bevy_replicon_example_backend/tests/backend.rs
+++ b/bevy_replicon_example_backend/tests/backend.rs
@@ -58,16 +58,16 @@ fn disconnect_request() {
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
             RepliconExampleBackendPlugins,
         ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
+        .add_server_message::<TestEvent>(Channel::Ordered)
         .finish();
     }
 
     setup(&mut server_app, &mut client_app).unwrap();
 
     server_app.world_mut().spawn(Replicated);
-    server_app.world_mut().send_event(ToClients {
+    server_app.world_mut().write_message(ToClients {
         mode: SendMode::Broadcast,
-        event: TestEvent,
+        message: TestEvent,
     });
 
     let mut clients = server_app
@@ -76,7 +76,7 @@ fn disconnect_request() {
     let client = clients.single(server_app.world()).unwrap();
     server_app
         .world_mut()
-        .send_event(DisconnectRequest { client });
+        .write_message(DisconnectRequest { client });
 
     server_app.update();
     client_app.update();
@@ -86,8 +86,8 @@ fn disconnect_request() {
     let client_state = client_app.world().resource::<State<ClientState>>();
     assert_eq!(*client_state, ClientState::Disconnected);
 
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert_eq!(events.len(), 1, "last event should be received");
+    let messages = client_app.world().resource::<Messages<TestEvent>>();
+    assert_eq!(messages.len(), 1, "last message should be received");
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
     assert_eq!(
@@ -108,7 +108,7 @@ fn server_stop() {
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
             RepliconExampleBackendPlugins,
         ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
+        .add_server_message::<TestEvent>(Channel::Ordered)
         .finish();
     }
 
@@ -116,9 +116,9 @@ fn server_stop() {
 
     server_app.world_mut().remove_resource::<ExampleServer>();
     server_app.world_mut().spawn(Replicated);
-    server_app.world_mut().send_event(ToClients {
+    server_app.world_mut().write_message(ToClients {
         mode: SendMode::Broadcast,
-        event: TestEvent,
+        message: TestEvent,
     });
 
     server_app.update();
@@ -133,8 +133,11 @@ fn server_stop() {
     let client_state = client_app.world().resource::<State<ClientState>>();
     assert_eq!(*client_state, ClientState::Disconnected);
 
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert!(events.is_empty(), "event after stop shouldn't be received");
+    let messages = client_app.world().resource::<Messages<TestEvent>>();
+    assert!(
+        messages.is_empty(),
+        "message shouldn't be received after stop"
+    );
 
     let mut replicated = client_app.world_mut().query::<&Replicated>();
     assert_eq!(
@@ -180,22 +183,22 @@ fn server_event() {
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
             RepliconExampleBackendPlugins,
         ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
+        .add_server_message::<TestEvent>(Channel::Ordered)
         .finish();
     }
 
     setup(&mut server_app, &mut client_app).unwrap();
 
-    server_app.world_mut().send_event(ToClients {
+    server_app.world_mut().write_message(ToClients {
         mode: SendMode::Broadcast,
-        event: TestEvent,
+        message: TestEvent,
     });
 
     server_app.update();
     client_app.update();
 
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert_eq!(events.len(), 1);
+    let messages = client_app.world().resource::<Messages<TestEvent>>();
+    assert_eq!(messages.len(), 1);
 }
 
 #[test]
@@ -209,21 +212,21 @@ fn client_event() {
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
             RepliconExampleBackendPlugins,
         ))
-        .add_client_event::<TestEvent>(Channel::Ordered)
+        .add_client_message::<TestEvent>(Channel::Ordered)
         .finish();
     }
 
     setup(&mut server_app, &mut client_app).unwrap();
 
-    client_app.world_mut().send_event(TestEvent);
+    client_app.world_mut().write_message(TestEvent);
 
     client_app.update();
     server_app.update();
 
-    let client_events = server_app
+    let messages = server_app
         .world()
-        .resource::<Events<FromClient<TestEvent>>>();
-    assert_eq!(client_events.len(), 1);
+        .resource::<Messages<FromClient<TestEvent>>>();
+    assert_eq!(messages.len(), 1);
 }
 
 fn setup(server_app: &mut App, client_app: &mut App) -> io::Result<()> {
@@ -242,5 +245,5 @@ fn setup(server_app: &mut App, client_app: &mut App) -> io::Result<()> {
     Ok(())
 }
 
-#[derive(Deserialize, Event, Serialize)]
+#[derive(Message, Serialize, Deserialize)]
 struct TestEvent;
diff --git a/src/client.rs b/src/client.rs
index ec567bda..001c0c5e 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,7 +1,7 @@
 pub mod confirm_history;
 #[cfg(feature = "client_diagnostics")]
 pub mod diagnostics;
-pub mod event;
+pub mod message;
 pub mod server_mutate_ticks;
 
 use bevy::prelude::*;
@@ -44,8 +44,8 @@ impl Plugin for ClientPlugin {
             .init_resource::<ServerEntityMap>()
             .init_resource::<ServerUpdateTick>()
             .init_resource::<BufferedMutations>()
-            .add_event::<EntityReplicated>()
-            .add_event::<MutateTickReceived>()
+            .add_message::<EntityReplicated>()
+            .add_message::<MutateTickReceived>()
             .configure_sets(
                 PreUpdate,
                 (
@@ -134,7 +134,7 @@ pub(super) fn receive_replication(
                     world.resource_scope(|world, command_markers: Mut<CommandMarkers>| {
                         world.resource_scope(|world, registry: Mut<ReplicationRegistry>| {
                             world.resource_scope(
-                                |world, mut replicated_events: Mut<Events<EntityReplicated>>| {
+                                |world, mut replicated: Mut<Messages<EntityReplicated>>| {
                                     let type_registry = world.resource::<AppTypeRegistry>().clone();
                                     let mut stats =
                                         world.remove_resource::<ClientReplicationStats>();
@@ -145,7 +145,7 @@ pub(super) fn receive_replication(
                                         entity_markers: &mut entity_markers,
                                         entity_map: &mut entity_map,
                                         signature_map: &mut signature_map,
-                                        replicated_events: &mut replicated_events,
+                                        replicated: &mut replicated,
                                         mutate_ticks: mutate_ticks.as_mut(),
                                         stats: stats.as_mut(),
                                         command_markers: &command_markers,
@@ -203,7 +203,7 @@ fn send_protocol_hash(mut commands: Commands, protocol: Res<ProtocolHash>) {
     commands.client_trigger(*protocol);
 }
 
-fn log_protocol_error(_trigger: Trigger<ProtocolMismatch>) {
+fn log_protocol_error(_on: On<ProtocolMismatch>) {
     error!(
         "server reported protocol mismatch; make sure replication rules and events registration order match with the server"
     );
@@ -390,7 +390,7 @@ fn apply_mutate_messages(
         if let Some(mutate_ticks) = &mut params.mutate_ticks
             && mutate_ticks.confirm(mutate.message_tick, mutate.messages_count)
         {
-            world.send_event(MutateTickReceived {
+            world.write_message(MutateTickReceived {
                 tick: mutate.message_tick,
             });
         }
@@ -477,7 +477,7 @@ fn apply_removals(
         .entity_markers
         .read(params.command_markers, &*client_entity);
 
-    confirm_tick(&mut client_entity, params.replicated_events, message_tick);
+    confirm_tick(&mut client_entity, params.replicated, message_tick);
 
     let len = apply_array(ArrayKind::Sized, message, |message| {
         let fns_id = postcard_utils::from_buf(message)?;
@@ -536,7 +536,7 @@ fn apply_changes(
         .entity_markers
         .read(params.command_markers, &*client_entity);
 
-    confirm_tick(&mut client_entity, params.replicated_events, message_tick);
+    confirm_tick(&mut client_entity, params.replicated, message_tick);
 
     let len = apply_array(ArrayKind::Sized, message, |message| {
         let fns_id = postcard_utils::from_buf(message)?;
@@ -614,7 +614,7 @@ enum ArrayKind {
 
 fn confirm_tick(
     entity: &mut DeferredEntity,
-    replicated_events: &mut Events<EntityReplicated>,
+    replicated: &mut Messages<EntityReplicated>,
     tick: RepliconTick,
 ) {
     if let Some(mut history) = entity.get_mut::<ConfirmHistory>() {
@@ -622,7 +622,7 @@ fn confirm_tick(
     } else {
         entity.insert(ConfirmHistory::new(tick));
     }
-    replicated_events.send(EntityReplicated {
+    replicated.write(EntityReplicated {
         entity: entity.id(),
         tick,
     });
@@ -687,7 +687,7 @@ fn apply_mutations(
 
         history.set(ago);
     }
-    params.replicated_events.send(EntityReplicated {
+    params.replicated.write(EntityReplicated {
         entity: client_entity.id(),
         tick: message_tick,
     });
@@ -752,7 +752,7 @@ struct ReceiveParams<'a> {
     entity_markers: &'a mut EntityMarkers,
     entity_map: &'a mut ServerEntityMap,
     signature_map: &'a mut SignatureMap,
-    replicated_events: &'a mut Events<EntityReplicated>,
+    replicated: &'a mut Messages<EntityReplicated>,
     mutate_ticks: Option<&'a mut ServerMutateTicks>,
     stats: Option<&'a mut ClientReplicationStats>,
     command_markers: &'a CommandMarkers,
diff --git a/src/client/confirm_history.rs b/src/client/confirm_history.rs
index c0262113..a949d634 100644
--- a/src/client/confirm_history.rs
+++ b/src/client/confirm_history.rs
@@ -126,10 +126,10 @@ impl ConfirmHistory {
     }
 }
 
-/// Triggered for an entity when it receives updates for a tick.
+/// A message that indicates that an entity received update for a tick.
 ///
 /// See also [`ConfirmHistory`].
-#[derive(Debug, Event, Clone, Copy)]
+#[derive(Message, Debug, Clone, Copy)]
 pub struct EntityReplicated {
     /// Entity that received an update.
     pub entity: Entity,
diff --git a/src/client/event.rs b/src/client/message.rs
similarity index 51%
rename from src/client/event.rs
rename to src/client/message.rs
index d7809364..31468b02 100644
--- a/src/client/event.rs
+++ b/src/client/message.rs
@@ -7,40 +7,40 @@ use super::ServerUpdateTick;
 use crate::{
     prelude::*,
     shared::{
-        event::{
+        message::{
             ctx::{ClientReceiveCtx, ClientSendCtx},
-            registry::RemoteEventRegistry,
+            registry::RemoteMessageRegistry,
         },
         server_entity_map::ServerEntityMap,
     },
 };
 
-/// Sending events from a client to the server.
+/// Sending messages and events from a client to the server.
 ///
 /// Requires [`ClientPlugin`].
 /// Can be disabled for apps that act only as servers.
-pub struct ClientEventPlugin;
+pub struct ClientMessagePlugin;
 
-impl Plugin for ClientEventPlugin {
+impl Plugin for ClientMessagePlugin {
     fn build(&self, _app: &mut App) {}
 
     fn finish(&self, app: &mut App) {
         // Construct systems dynamically after all plugins initialization
         // because we need to access resources by registered IDs.
-        let event_registry = app
+        let registry = app
             .world_mut()
-            .remove_resource::<RemoteEventRegistry>()
-            .expect("event registry should be initialized on app build");
+            .remove_resource::<RemoteMessageRegistry>()
+            .expect("message registry should be initialized on app build");
 
         let send_fn = (
             FilteredResourcesParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_client() {
-                    builder.add_read_by_id(event.events_id());
+                for message in registry.iter_all_client() {
+                    builder.add_read_by_id(message.messages_id());
                 }
             }),
             FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_client() {
-                    builder.add_write_by_id(event.reader_id());
+                for message in registry.iter_all_client() {
+                    builder.add_write_by_id(message.reader_id());
                 }
             }),
             ParamBuilder,
@@ -53,13 +53,13 @@ impl Plugin for ClientEventPlugin {
 
         let receive_builder = (
             FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_server() {
-                    builder.add_write_by_id(event.events_id());
+                for message in registry.iter_all_server() {
+                    builder.add_write_by_id(message.messages_id());
                 }
             }),
             FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_server() {
-                    builder.add_write_by_id(event.queue_id());
+                for message in registry.iter_all_server() {
+                    builder.add_write_by_id(message.queue_id());
                 }
             }),
             ParamBuilder,
@@ -80,8 +80,8 @@ impl Plugin for ClientEventPlugin {
 
         let trigger_builder = (
             FilteredResourcesMutParamBuilder::new(|builder| {
-                for trigger in event_registry.iter_server_triggers() {
-                    builder.add_write_by_id(trigger.event().events_id());
+                for event in registry.iter_server_events() {
+                    builder.add_write_by_id(event.message().messages_id());
                 }
             }),
             ParamBuilder,
@@ -97,31 +97,31 @@ impl Plugin for ClientEventPlugin {
             .build_state(app.world_mut())
             .build_system(trigger);
 
-        let resend_locally_fn = (
+        let send_locally_fn = (
             FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_client() {
-                    builder.add_write_by_id(event.client_events_id());
+                for message in registry.iter_all_client() {
+                    builder.add_write_by_id(message.from_messages_id());
                 }
             }),
             FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_client() {
-                    builder.add_write_by_id(event.events_id());
+                for message in registry.iter_all_client() {
+                    builder.add_write_by_id(message.messages_id());
                 }
             }),
             ParamBuilder,
         )
             .build_state(app.world_mut())
-            .build_system(resend_locally);
+            .build_system(send_locally);
 
         let reset_fn = (
             FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_client() {
-                    builder.add_write_by_id(event.events_id());
+                for message in registry.iter_all_client() {
+                    builder.add_write_by_id(message.messages_id());
                 }
             }),
             FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_server() {
-                    builder.add_write_by_id(event.queue_id());
+                for message in registry.iter_all_server() {
+                    builder.add_write_by_id(message.queue_id());
                 }
             }),
             ParamBuilder,
@@ -129,7 +129,7 @@ impl Plugin for ClientEventPlugin {
             .build_state(app.world_mut())
             .build_system(reset);
 
-        app.insert_resource(event_registry)
+        app.insert_resource(registry)
             .add_systems(
                 PreUpdate,
                 (
@@ -154,7 +154,7 @@ impl Plugin for ClientEventPlugin {
                 PostUpdate,
                 (
                     send_fn.run_if(in_state(ClientState::Connected)),
-                    resend_locally_fn.run_if(in_state(ClientState::Disconnected)),
+                    send_locally_fn.run_if(in_state(ClientState::Disconnected)),
                 )
                     .chain()
                     .in_set(ClientSystems::Send),
@@ -163,12 +163,12 @@ impl Plugin for ClientEventPlugin {
 }
 
 fn send(
-    events: FilteredResources,
+    messages: FilteredResources,
     mut readers: FilteredResourcesMut,
-    mut messages: ResMut<ClientMessages>,
+    mut client_messages: ResMut<ClientMessages>,
     type_registry: Res<AppTypeRegistry>,
     entity_map: Res<ServerEntityMap>,
-    event_registry: Res<RemoteEventRegistry>,
+    registry: Res<RemoteMessageRegistry>,
 ) {
     let mut ctx = ClientSendCtx {
         entity_map: &entity_map,
@@ -176,28 +176,33 @@ fn send(
         invalid_entities: Vec::new(),
     };
 
-    for event in event_registry.iter_all_client() {
-        let events = events
-            .get_by_id(event.events_id())
-            .expect("events resource should be accessible");
+    for message in registry.iter_all_client() {
+        let messages = messages
+            .get_by_id(message.messages_id())
+            .expect("messages resource should be accessible");
         let reader = readers
-            .get_mut_by_id(event.reader_id())
-            .expect("event reader resource should be accessible");
+            .get_mut_by_id(message.reader_id())
+            .expect("message reader resource should be accessible");
 
-        // SAFETY: passed pointers were obtained using this event data.
+        // SAFETY: passed pointers were obtained using this message data.
         unsafe {
-            event.send(&mut ctx, &events, reader.into_inner(), &mut messages);
+            message.send(
+                &mut ctx,
+                &messages,
+                reader.into_inner(),
+                &mut client_messages,
+            );
         }
     }
 }
 
 fn receive(
-    mut events: FilteredResourcesMut,
+    mut messages: FilteredResourcesMut,
     mut queues: FilteredResourcesMut,
-    mut messages: ResMut<ClientMessages>,
+    mut client_messages: ResMut<ClientMessages>,
     type_registry: Res<AppTypeRegistry>,
     entity_map: Res<ServerEntityMap>,
-    event_registry: Res<RemoteEventRegistry>,
+    message_registry: Res<RemoteMessageRegistry>,
     update_tick: Res<ServerUpdateTick>,
 ) {
     let mut ctx = ClientReceiveCtx {
@@ -206,21 +211,21 @@ fn receive(
         invalid_entities: Vec::new(),
     };
 
-    for event in event_registry.iter_all_server() {
-        let events = events
-            .get_mut_by_id(event.events_id())
-            .expect("events resource should be accessible");
+    for message in message_registry.iter_all_server() {
+        let messages = messages
+            .get_mut_by_id(message.messages_id())
+            .expect("messages resource should be accessible");
         let queue = queues
-            .get_mut_by_id(event.queue_id())
+            .get_mut_by_id(message.queue_id())
             .expect("queue resource should be accessible");
 
-        // SAFETY: passed pointers were obtained using this event data.
+        // SAFETY: passed pointers were obtained using this message data.
         unsafe {
-            event.receive(
+            message.receive(
                 &mut ctx,
-                events.into_inner(),
+                messages.into_inner(),
                 queue.into_inner(),
-                &mut messages,
+                &mut client_messages,
                 **update_tick,
             )
         };
@@ -228,56 +233,56 @@ fn receive(
 }
 
 fn trigger(
-    mut events: FilteredResourcesMut,
+    mut messages: FilteredResourcesMut,
     mut commands: Commands,
-    event_registry: Res<RemoteEventRegistry>,
+    registry: Res<RemoteMessageRegistry>,
 ) {
-    for trigger in event_registry.iter_server_triggers() {
-        let events = events
-            .get_mut_by_id(trigger.event().events_id())
-            .expect("events resource should be accessible");
-        trigger.trigger(&mut commands, events.into_inner());
+    for event in registry.iter_server_events() {
+        let messages = messages
+            .get_mut_by_id(event.message().messages_id())
+            .expect("messages resource should be accessible");
+        event.trigger(&mut commands, messages.into_inner());
     }
 }
 
-fn resend_locally(
-    mut client_events: FilteredResourcesMut,
-    mut events: FilteredResourcesMut,
-    event_registry: Res<RemoteEventRegistry>,
+fn send_locally(
+    mut from_messages: FilteredResourcesMut,
+    mut messages: FilteredResourcesMut,
+    registry: Res<RemoteMessageRegistry>,
 ) {
-    for event in event_registry.iter_all_client() {
-        let client_events = client_events
-            .get_mut_by_id(event.client_events_id())
-            .expect("client events resource should be accessible");
-        let events = events
-            .get_mut_by_id(event.events_id())
-            .expect("events resource should be accessible");
+    for message in registry.iter_all_client() {
+        let from_messages = from_messages
+            .get_mut_by_id(message.from_messages_id())
+            .expect("from messages resource should be accessible");
+        let messages = messages
+            .get_mut_by_id(message.messages_id())
+            .expect("messages resource should be accessible");
 
-        // SAFETY: passed pointers were obtained using this event data.
-        unsafe { event.resend_locally(client_events.into_inner(), events.into_inner()) };
+        // SAFETY: passed pointers were obtained using this message data.
+        unsafe { message.send_locally(from_messages.into_inner(), messages.into_inner()) };
     }
 }
 
 fn reset(
-    mut events: FilteredResourcesMut,
+    mut messages: FilteredResourcesMut,
     mut queues: FilteredResourcesMut,
-    event_registry: Res<RemoteEventRegistry>,
+    registry: Res<RemoteMessageRegistry>,
 ) {
-    for event in event_registry.iter_all_client() {
-        let events = events
-            .get_mut_by_id(event.events_id())
-            .expect("events resource should be accessible");
+    for message in registry.iter_all_client() {
+        let messages = messages
+            .get_mut_by_id(message.messages_id())
+            .expect("messages resource should be accessible");
 
-        // SAFETY: passed pointer was obtained using this event data.
-        unsafe { event.reset(events.into_inner()) };
+        // SAFETY: passed pointer was obtained using this message data.
+        unsafe { message.reset(messages.into_inner()) };
     }
 
-    for event in event_registry.iter_all_server() {
+    for messages in registry.iter_all_server() {
         let queue = queues
-            .get_mut_by_id(event.queue_id())
-            .expect("event queue resource should be accessible");
+            .get_mut_by_id(messages.queue_id())
+            .expect("queue resource should be accessible");
 
-        // SAFETY: passed pointer was obtained using this event data.
-        unsafe { event.reset(queue.into_inner()) };
+        // SAFETY: passed pointer was obtained using this message data.
+        unsafe { messages.reset(queue.into_inner()) };
     }
 }
diff --git a/src/client/server_mutate_ticks.rs b/src/client/server_mutate_ticks.rs
index 6accfc10..48b7cc04 100644
--- a/src/client/server_mutate_ticks.rs
+++ b/src/client/server_mutate_ticks.rs
@@ -189,10 +189,10 @@ impl TickMessages {
     }
 }
 
-/// Triggered when all mutate messages are received for a tick.
+/// A message that indicates that all mutate messages are received for a tick.
 ///
 /// See also [`ServerMutateTicks`].
-#[derive(Debug, Event, Clone, Copy)]
+#[derive(Message, Debug, Clone, Copy)]
 pub struct MutateTickReceived {
     /// Message(s) tick.
     pub tick: RepliconTick,
diff --git a/src/compact_entity.rs b/src/compact_entity.rs
index 823260ad..dd678ca4 100644
--- a/src/compact_entity.rs
+++ b/src/compact_entity.rs
@@ -17,7 +17,10 @@
 
 use core::fmt::{self, Formatter};
 
-use bevy::prelude::*;
+use bevy::{
+    ecs::entity::{EntityGeneration, EntityRow},
+    prelude::*,
+};
 use serde::{
     Deserializer, Serialize, Serializer,
     de::{self, SeqAccess, Visitor},
@@ -25,24 +28,23 @@ use serde::{
 
 /// Serializes an entity by writing its index and generation as separate numbers.
 ///
-/// This reduces the space used for serializers with varint encoding.
+/// This reduces the space required when using serializers with varint encoding.
 ///
-/// The index is first prepended with a bit flag to indicate if the generation
-/// is serialized or not. It is not serialized if <= 1; note that generations are [`NonZeroU32`](core::num::NonZeroU32)
-/// and a value of zero is used in [`Option<Entity>`] to signify [`None`], so generation 1 is the first
-/// generation.
+/// Since the index can never be [`u32::MAX`], we reuse that extra niche to indicate
+/// whether the generation isn't [`EntityGeneration::FIRST`]. If it doesn't,
+/// the generation is skipped during serialization.
 ///
 /// See also [`deserialize`] and [`postcard_utils::entity_to_extend_mut`](crate::postcard_utils::entity_to_extend_mut).
 pub fn serialize<S: Serializer>(entity: &Entity, serializer: S) -> Result<S::Ok, S::Error> {
-    let mut flagged_index = (entity.index() as u64) << 1;
-    let flag = entity.generation() > 1;
-    flagged_index |= flag as u64;
+    let mut index = entity.index() << 1;
+    let has_generation = entity.generation() != EntityGeneration::FIRST;
+    index |= has_generation as u32;
 
-    if flag {
-        let generation = entity.generation() - 1;
-        (flagged_index, generation).serialize(serializer)
+    if has_generation {
+        let generation = entity.generation().to_bits();
+        (index, generation).serialize(serializer)
     } else {
-        flagged_index.serialize(serializer)
+        index.serialize(serializer)
     }
 }
 
@@ -63,22 +65,23 @@ impl<'de> Visitor<'de> for EntityVisitor {
     }
 
     fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
-        let flagged_index: u64 = seq
+        let index: u32 = seq
             .next_element()?
             .ok_or_else(|| de::Error::invalid_length(0, &self))?;
 
-        let has_generation = (flagged_index & 1) != 0;
+        let has_generation = (index & 1) != 0;
 
         let generation = if has_generation {
-            let generation: u32 = seq
-                .next_element()?
-                .ok_or_else(|| de::Error::invalid_length(1, &self))?;
-            generation as u64 + 1
+            seq.next_element()?
+                .ok_or_else(|| de::Error::invalid_length(1, &self))?
         } else {
-            1
+            0
         };
 
-        let bits = (flagged_index >> 1) | (generation << 32);
-        Ok(Entity::from_bits(bits))
+        // SAFETY: `index` is non-max after shift.
+        let row = unsafe { EntityRow::from_raw_u32(index >> 1).unwrap_unchecked() };
+        let generation = EntityGeneration::from_bits(generation);
+
+        Ok(Entity::from_row_and_generation(row, generation))
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 69a0268c..ae7b83ff 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -43,10 +43,10 @@ Their data represented as components, such as [`ClientStats`]. Users can also at
 own metadata to them or even replicate these entiteis back to clients.
 
 These entities are automatically spawned and despawned by the messaging backend. You can
-also despawn them yourself to trigger a disconnect or use the [`DisconnectRequest`] event
+also despawn them yourself to trigger a disconnect or use the [`DisconnectRequest`] message
 to disconnect after sending messages.
 
-You can use [`Trigger<OnAdd, ConnectedClient>`] to react to new connections,
+You can use [`On<Add, ConnectedClient>`] to react to new connections,
 or use backend-provided events if you need the disconnect reason.
 
 ## States
@@ -107,7 +107,7 @@ provides a high-level API to automate server-authoritative replication.
 
 Replication happens only from server to clients. It's necessary to prevent cheating.
 If you need to send information from clients to the server, use
-[events](#network-events-and-triggers).
+[messages](#network-messages-and-events).
 
 For implementation details see [`ServerChannel`](shared::backend::channels::ServerChannel).
 
@@ -203,11 +203,11 @@ app.replicate::<Transform>()
     .add_observer(init_player_mesh);
 
 fn init_player_mesh(
-    trigger: Trigger<OnAdd, Mesh2d>,
+    add: On<Add, Mesh2d>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut players: Query<&mut Mesh2d>,
 ) {
-    let mut mesh = players.get_mut(trigger.target()).unwrap();
+    let mut mesh = players.get_mut(add.entity).unwrap();
     **mesh = meshes.add(Capsule2d::default());
 }
 
@@ -275,9 +275,9 @@ network traffic.
 Use [`AppRuleExt::replicate_once`] to replicate only the initial value of a component.
 You can configure this per-component within a replication rule using [`AppRuleExt::replicate_with`].
 
-See also [server events](#from-server-to-client), which are also useful for DR.
+See also [server messages](#from-server-to-client), which are also useful for DR.
 
-## Network events and triggers
+## Network messages and events
 
 This replaces RPCs (remote procedure calls) in other engines and,
 unlike replication, can be sent both from server to clients and from clients to
@@ -285,14 +285,14 @@ server.
 
 ### From client to server
 
-To send specific events from client to server, you need to register the event
-with [`ClientEventAppExt::add_client_event`] instead of [`App::add_event`].
+To send a message from client to server, you need to register the message
+with [`ClientMessageAppExt::add_client_message`] instead of [`App::add_message`].
 
-Events include [`Channel`] to configure delivery guarantees (reliability and
+Messages include [`Channel`] to configure delivery guarantees (reliability and
 ordering).
 
-These events will appear on server as [`FromClient`] wrapper event that
-contains sender ID and the sent event.
+These messages will appear on server as [`FromClient`] wrapper message that
+contains sender ID and the message.
 
 ```
 # use bevy::{prelude::*, state::app::StatesPlugin};
@@ -300,43 +300,43 @@ contains sender ID and the sent event.
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins((StatesPlugin, RepliconPlugins));
-app.add_client_event::<ExampleEvent>(Channel::Ordered)
+app.add_client_message::<Ping>(Channel::Ordered)
     .add_systems(
         PreUpdate,
-        receive_events
+        receive
             .after(ServerSystems::Receive)
             .run_if(in_state(ServerState::Running)),
     )
     .add_systems(
         PostUpdate,
-        send_events.before(ClientSystems::Send).run_if(in_state(ClientState::Connected)),
+        send.before(ClientSystems::Send).run_if(in_state(ClientState::Connected)),
     );
 
-fn send_events(mut events: EventWriter<ExampleEvent>) {
-    events.write_default();
+fn send(mut ping: MessageWriter<Ping>) {
+    ping.write(Ping);
 }
 
-fn receive_events(mut events: EventReader<FromClient<ExampleEvent>>) {
-    for FromClient { client_id, event } in events.read() {
-        info!("received event `{event:?}` from client `{client_id}`");
+fn receive(mut pings: MessageReader<FromClient<Ping>>) {
+    for ping in pings.read() {
+        info!("received ping from client `{}`", ping.client_id);
     }
 }
 
-#[derive(Debug, Default, Deserialize, Event, Serialize)]
-struct ExampleEvent;
+#[derive(Message, Deserialize, Serialize)]
+struct Ping;
 ```
 
-If an event contains an entity, implement
+If a message contains an entity, implement
 [`MapEntities`](bevy::ecs::entity::MapEntities) for it and use use
-[`ClientEventAppExt::add_mapped_client_event`] instead.
+[`ClientMessageAppExt::add_mapped_client_message`] instead.
 
-There is also [`ClientEventAppExt::add_client_event_with`] to register an event with special serialization and
-deserialization functions. This could be used for sending events that contain [`Box<dyn PartialReflect>`], which
+There is also [`ClientMessageAppExt::add_client_message_with`] to register a message with special serialization and
+deserialization functions. This could be used for sending messages that contain [`Box<dyn PartialReflect>`], which
 require access to the [`AppTypeRegistry`] resource. Don't forget to validate the contents of every
 [`Box<dyn PartialReflect>`] from a client, it could be anything!
 
-Alternatively, you can use triggers with a similar API. First, you need to register the event
-using [`ClientTriggerAppExt::add_client_trigger`], and then use [`ClientTriggerExt::client_trigger`].
+Alternatively, you can use events with a similar API. First, you need to register the event
+using [`ClientEventAppExt::add_client_event`], and then use [`ClientTriggerExt::client_trigger`].
 
 ```
 # use bevy::{prelude::*, state::app::StatesPlugin};
@@ -344,33 +344,30 @@ using [`ClientTriggerAppExt::add_client_trigger`], and then use [`ClientTriggerE
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins((StatesPlugin, RepliconPlugins));
-app.add_client_trigger::<ExampleEvent>(Channel::Ordered)
-    .add_observer(receive_events)
-    .add_systems(Update, send_events.run_if(in_state(ClientState::Connected)));
+app.add_client_event::<Ping>(Channel::Ordered)
+    .add_observer(receive)
+    .add_systems(Update, send.run_if(in_state(ClientState::Connected)));
 
-fn send_events(mut commands: Commands) {
-    commands.client_trigger(ExampleEvent);
+fn send(mut commands: Commands) {
+    commands.client_trigger(Ping);
 }
 
-fn receive_events(trigger: Trigger<FromClient<ExampleEvent>>) {
-    info!("received event `{:?}` from client `{}`", **trigger, trigger.client_id);
+fn receive(ping: On<FromClient<Ping>>) {
+    info!("received ping from client `{}`", ping.client_id);
 }
-# #[derive(Event, Debug, Deserialize, Serialize)]
-# struct ExampleEvent;
+# #[derive(Event, Deserialize, Serialize)]
+# struct Ping;
 ```
 
-Trigger targets are also supported via [`ClientTriggerExt::client_trigger_targets`], no change
-in registration needed. Target entities will be automatically mapped to server entities before sending.
-
-For event triggers with entities inside use [`ClientTriggerAppExt::add_mapped_client_trigger`].
-Similar to events, serialization can also be customized with [`ClientTriggerAppExt::add_client_trigger_with`].
+For events with entities inside use [`ClientEventAppExt::add_mapped_client_event`].
+Similar to messages, serialization can also be customized with [`ClientEventAppExt::add_client_event_with`].
 
 ### From server to client
 
-A similar technique is used to send events from server to clients. To do this,
-register the event with [`ServerEventAppExt::add_server_event`]
+A similar technique is used to send messages from server to clients. To do this,
+register a message with [`ServerMessageAppExt::add_server_message`]
 and send it from server using [`ToClients`]. This wrapper contains send parameters
-and the event itself.
+and the message itself.
 
 ```
 # use bevy::{prelude::*, state::app::StatesPlugin};
@@ -378,40 +375,40 @@ and the event itself.
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins((StatesPlugin, RepliconPlugins));
-app.add_server_event::<ExampleEvent>(Channel::Ordered)
+app.add_server_message::<Pong>(Channel::Ordered)
     .add_systems(
         PreUpdate,
-        receive_events
+        receive
             .after(ClientSystems::Receive)
             .run_if(in_state(ClientState::Connected)),
     )
     .add_systems(
         PostUpdate,
-        send_events.before(ServerSystems::Send).run_if(in_state(ServerState::Running)),
+        send.before(ServerSystems::Send).run_if(in_state(ServerState::Running)),
     );
 
-fn send_events(mut events: EventWriter<ToClients<ExampleEvent>>) {
-    events.write(ToClients {
+fn send(mut pongs: MessageWriter<ToClients<Pong>>) {
+    pongs.write(ToClients {
         mode: SendMode::Broadcast,
-        event: ExampleEvent,
+        message: Pong,
     });
 }
 
-fn receive_events(mut events: EventReader<ExampleEvent>) {
-    for event in events.read() {
-        info!("received event {event:?} from server");
+fn receive(mut pongs: MessageReader<Pong>) {
+    for pong in pongs.read() {
+        info!("received pong from the server");
     }
 }
 
-#[derive(Clone, Copy, Debug, Default, Deserialize, Event, Serialize)]
-struct ExampleEvent;
+#[derive(Message, Deserialize, Serialize)]
+struct Pong;
 ```
 
-Just like for client events, we provide [`ServerEventAppExt::add_mapped_server_event`]
-and [`ServerEventAppExt::add_server_event_with`].
+Just like for client messages, we provide [`ServerMessageAppExt::add_mapped_server_message`]
+and [`ServerMessageAppExt::add_server_message_with`].
 
-Trigger-based API available for server events as well. First, you need to register the event
-with [`ServerTriggerAppExt::add_server_trigger`] and then use [`ServerTriggerExt::server_trigger`]:
+Event API is available. First, you need to register an event with [`ServerEventAppExt::add_server_event`]
+and then use [`ServerTriggerExt::server_trigger`]:
 
 ```
 # use bevy::{prelude::*, state::app::StatesPlugin};
@@ -419,30 +416,30 @@ with [`ServerTriggerAppExt::add_server_trigger`] and then use [`ServerTriggerExt
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins((StatesPlugin, RepliconPlugins));
-app.add_server_trigger::<ExampleEvent>(Channel::Ordered)
-    .add_observer(receive_events)
-    .add_systems(Update, send_events.run_if(in_state(ServerState::Running)));
+app.add_server_event::<Pong>(Channel::Ordered)
+    .add_observer(receive)
+    .add_systems(Update, send.run_if(in_state(ServerState::Running)));
 
-fn send_events(mut commands: Commands) {
+fn send(mut commands: Commands) {
     commands.server_trigger(ToClients {
         mode: SendMode::Broadcast,
-        event: ExampleEvent,
+        message: Pong,
     });
 }
 
-fn receive_events(trigger: Trigger<ExampleEvent>) {
-    info!("received event {:?} from server", *trigger);
+fn receive(_on: On<Pong>) {
+    info!("received pong from the server");
 }
-# #[derive(Event, Debug, Deserialize, Serialize)]
-# struct ExampleEvent;
+# #[derive(Event, Deserialize, Serialize)]
+# struct Pong;
 ```
 
-And just like for client trigger, we provide [`ServerTriggerAppExt::add_mapped_server_trigger`]
-and [`ServerTriggerAppExt::add_server_trigger_with`].
+And just like for client events, we provide [`ServerEventAppExt::add_mapped_server_event`]
+and [`ServerEventAppExt::add_server_event_with`].
 
-We guarantee that clients will never receive events that point to an entity or require specific
+We guarantee that clients will never receive events or messages that point to an entity or require specific
 component to be presentt which client haven't received yet. For more details see the documentation on
-[`ServerEventAppExt::make_event_independent`].
+[`ServerMessageAppExt::make_message_independent`].
 
 ## Abstracting over configurations
 
@@ -498,11 +495,11 @@ Internally we run replication sending system only in [`ServerState::Running`] an
 only in [`ClientState::Connected`]. This way for singleplayer replication systems won't run at all and
 for listen server replication will only be sending (server world is already in the correct state).
 
-For events, it's a bit trickier. For all client events, we internally drain events as `E` and re-emit
+For messages, it's a bit trickier. For all client messages, we internally drain messages as `E` and send
 them as [`FromClient<E>`] locally with [`ClientId::Server`] in [`ClientState::Disconnected`].
-For server events we drain [`ToClients<E>`] and, if the [`ClientId::Server`] is the recipient of the event,
-re-emit it as `E` locally. This emulates event receiving for both server and singleplayer without actually
-transmitting data over the network.
+For server messages we drain [`ToClients<E>`] and, if the [`ClientId::Server`] is the recipient of the message,
+re-emit it as `E` locally. The same applies to the event API. This emulates message receiving for both server
+and singleplayer without actually transmitting data over the network.
 
 We also provide [`ClientSystems`] and [`ServerSystems`] to schedule your system at specific time in the frame.
 For example, you can run your systems right after receive using [`ClientSystems::Receive`] or [`ServerSystems::Receive`].
@@ -519,7 +516,7 @@ You will need to disable similar features on your messaing backend crate too.
 
 <div class="warning">
 
-Make sure that the component and event registration order is the same on the client and server. Simply put all
+Make sure that the component, event and message registration order is the same on the client and server. Simply put all
 registration code in your "shared" crate.
 
 </div>
@@ -533,8 +530,8 @@ basis.
 ### Authorization
 
 Connected clients are considered authorized when they have the [`AuthorizedClient`] component. Without this
-component, clients can only receive events marked as independent via [`ServerEventAppExt::make_event_independent`]
-or [`ServerTriggerAppExt::make_trigger_independent`]. Additionally, some components on connected clients are only present
+component, clients can only receive events and messages marked as independent via [`ServerMessageAppExt::make_message_independent`]
+or [`ServerEventAppExt::make_event_independent`]. Additionally, some components on connected clients are only present
 after replication starts. See the required components for [`AuthorizedClient`] for details.
 
 By default, this component is automatically inserted when the client and server [`ProtocolHash`] matches.
@@ -645,7 +642,7 @@ See the [`compact_entity`] module if you want to apply this optimization to enti
 
 # Eventual consistency
 
-All events, inserts, removals and despawns will be applied to clients in the same order as on the server.
+All events, messages, inserts, removals and despawns will be applied to clients in the same order as on the server.
 
 However, if you insert/mutate a component and immediately remove it, the client will only receive the removal because the component value
 won't exist in the [`World`] during the replication process. But removal followed by insertion will work as expected since we buffer removals.
@@ -657,7 +654,7 @@ then the client is guaranteed to see the spawns at the same tick, but the compon
 If a component is dependent on other data, mutations to the component will only be applied to the client when that data has arrived.
 So if your component references another entity, mutations to that component will only be applied when the referenced entity has been spawned on the client.
 
-Mutations for despawned entities will be discarded automatically, but events or components may reference despawned entities and should be handled with that in mind.
+Mutations for despawned entities will be discarded automatically, but events, messages or components may reference despawned entities and should be handled with that in mind.
 
 Clients should never assume their world state is the same as the server's on any given tick value-wise.
 World state on the client is only "eventually consistent" with the server's.
@@ -715,11 +712,11 @@ pub mod prelude {
                 server_messages::ServerMessages,
             },
             client_id::ClientId,
-            event::{
-                client_event::{ClientEventAppExt, FromClient},
-                client_trigger::{ClientTriggerAppExt, ClientTriggerExt},
-                server_event::{SendMode, ServerEventAppExt, ToClients},
-                server_trigger::{ServerTriggerAppExt, ServerTriggerExt},
+            message::{
+                client_event::{ClientEventAppExt, ClientTriggerExt},
+                client_message::{ClientMessageAppExt, FromClient},
+                server_event::{ServerEventAppExt, ServerTriggerExt},
+                server_message::{SendMode, ServerMessageAppExt, ToClients},
             },
             protocol::{ProtocolHash, ProtocolHasher, ProtocolMismatch},
             replication::{
@@ -735,13 +732,13 @@ pub mod prelude {
 
     #[cfg(feature = "client")]
     pub use super::client::{
-        ClientPlugin, ClientReplicationStats, ClientSystems, event::ClientEventPlugin,
+        ClientPlugin, ClientReplicationStats, ClientSystems, message::ClientMessagePlugin,
     };
 
     #[cfg(feature = "server")]
     pub use super::server::{
         AuthorizedClient, PriorityMap, ServerPlugin, ServerSystems, VisibilityPolicy,
-        client_visibility::ClientVisibility, event::ServerEventPlugin,
+        client_visibility::ClientVisibility, message::ServerMessagePlugin,
         related_entities::SyncRelatedAppExt,
     };
 
@@ -760,9 +757,9 @@ use prelude::*;
 /// Contains the following:
 /// * [`RepliconSharedPlugin`].
 /// * [`ServerPlugin`] - with feature `server`.
-/// * [`ServerEventPlugin`] - with feature `server`.
+/// * [`ServerMessagePlugin`] - with feature `server`.
 /// * [`ClientPlugin`] - with feature `client`.
-/// * [`ClientEventPlugin`] - with feature `client`.
+/// * [`ClientMessagePlugin`] - with feature `client`.
 /// * [`ClientDiagnosticsPlugin`] - with feature `client_diagnostics`.
 pub struct RepliconPlugins;
 
@@ -773,12 +770,12 @@ impl PluginGroup for RepliconPlugins {
 
         #[cfg(feature = "server")]
         {
-            group = group.add(ServerPlugin::default()).add(ServerEventPlugin);
+            group = group.add(ServerPlugin::default()).add(ServerMessagePlugin);
         }
 
         #[cfg(feature = "client")]
         {
-            group = group.add(ClientPlugin).add(ClientEventPlugin);
+            group = group.add(ClientPlugin).add(ClientMessagePlugin);
         }
 
         #[cfg(feature = "client_diagnostics")]
diff --git a/src/postcard_utils.rs b/src/postcard_utils.rs
index e9fa6bec..7184e6e1 100644
--- a/src/postcard_utils.rs
+++ b/src/postcard_utils.rs
@@ -212,11 +212,13 @@ impl<'a, T: Buf> DeFlavor<'a> for BufFlavor<'a, T> {
 
 #[cfg(test)]
 mod tests {
+    use bevy::ecs::entity::{EntityGeneration, EntityRow};
+
     use super::*;
 
     #[test]
     fn entity_without_generation() {
-        let expected_entity = Entity::from_raw(1);
+        let expected_entity = Entity::from_raw_u32(1).unwrap();
         let mut buffer = Vec::new();
         entity_to_extend_mut(&expected_entity, &mut buffer).unwrap();
         assert_eq!(buffer.len(), 1);
@@ -227,7 +229,10 @@ mod tests {
 
     #[test]
     fn entity_with_generation() {
-        let expected_entity = Entity::from_bits(1 | (2 << 32));
+        let expected_entity = Entity::from_row_and_generation(
+            EntityRow::from_raw_u32(1).unwrap(),
+            EntityGeneration::from_bits(1),
+        );
         let mut buffer = Vec::new();
         entity_to_extend_mut(&expected_entity, &mut buffer).unwrap();
         assert_eq!(buffer.len(), 2);
diff --git a/src/server.rs b/src/server.rs
index 6d52f9d6..23952db8 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,5 +1,5 @@
 pub mod client_visibility;
-pub mod event;
+pub mod message;
 pub mod related_entities;
 pub(super) mod removal_buffer;
 pub(super) mod replication_messages;
@@ -29,7 +29,7 @@ use crate::{
     prelude::*,
     shared::{
         backend::channels::ClientChannel,
-        event::server_event::event_buffer::EventBuffer,
+        message::server_message::message_buffer::MessageBuffer,
         replication::{
             client_ticks::{ClientTicks, EntityBuffer},
             registry::{
@@ -114,7 +114,7 @@ impl Plugin for ServerPlugin {
             .init_resource::<ServerMessages>()
             .init_resource::<ServerTick>()
             .init_resource::<EntityBuffer>()
-            .init_resource::<EventBuffer>()
+            .init_resource::<MessageBuffer>()
             .init_resource::<RelatedEntities>()
             .configure_sets(
                 PreUpdate,
@@ -204,46 +204,40 @@ fn increment_tick(mut server_tick: ResMut<ServerTick>) {
     trace!("incremented {server_tick:?}");
 }
 
-fn handle_connects(
-    trigger: Trigger<OnAdd, ConnectedClient>,
-    mut event_buffer: ResMut<EventBuffer>,
-) {
-    debug!("client `{}` connected", trigger.target());
-    event_buffer.exclude_client(trigger.target());
+fn handle_connects(add: On<Add, ConnectedClient>, mut message_buffer: ResMut<MessageBuffer>) {
+    debug!("client `{}` connected", add.entity);
+    message_buffer.exclude_client(add.entity);
 }
 
-fn handle_disconnects(
-    trigger: Trigger<OnRemove, ConnectedClient>,
-    mut messages: ResMut<ServerMessages>,
-) {
-    debug!("client `{}` disconnected", trigger.target());
-    messages.remove_client(trigger.target());
+fn handle_disconnects(remove: On<Remove, ConnectedClient>, mut messages: ResMut<ServerMessages>) {
+    debug!("client `{}` disconnected", remove.entity);
+    messages.remove_client(remove.entity);
 }
 
 fn check_protocol(
-    trigger: Trigger<FromClient<ProtocolHash>>,
+    client_protocol: On<FromClient<ProtocolHash>>,
     mut commands: Commands,
-    mut events: EventWriter<DisconnectRequest>,
+    mut disconnects: MessageWriter<DisconnectRequest>,
     protocol: Res<ProtocolHash>,
 ) {
-    let client = trigger
+    let client = client_protocol
         .client_id
         .entity()
         .expect("protocol hash sent only from clients");
 
-    if **trigger == *protocol {
+    if **client_protocol == *protocol {
         debug!("marking client `{client}` as authorized");
         commands.entity(client).insert(AuthorizedClient);
     } else {
         debug!(
             "disconnecting client `{client}` due to protocol mismatch (client: `{:?}`, server: `{:?}`)",
-            **trigger, *protocol
+            **client_protocol, *protocol
         );
         commands.server_trigger(ToClients {
-            mode: SendMode::Direct(trigger.client_id),
-            event: ProtocolMismatch,
+            mode: SendMode::Direct(client_protocol.client_id),
+            message: ProtocolMismatch,
         });
-        events.write(DisconnectRequest { client });
+        disconnects.write(DisconnectRequest { client });
     }
 }
 
@@ -290,12 +284,12 @@ fn receive_acks(
 }
 
 fn buffer_despawns(
-    trigger: Trigger<OnRemove, Replicated>,
+    remove: On<Remove, Replicated>,
     mut despawn_buffer: ResMut<DespawnBuffer>,
     state: Res<State<ServerState>>,
 ) {
     if *state == ServerState::Running {
-        despawn_buffer.push(trigger.target());
+        despawn_buffer.push(remove.entity);
     }
 }
 
@@ -388,11 +382,11 @@ fn reset(
     mut server_tick: ResMut<ServerTick>,
     mut related_entities: ResMut<RelatedEntities>,
     clients: Query<Entity, With<ConnectedClient>>,
-    mut event_buffer: ResMut<EventBuffer>,
+    mut message_buffer: ResMut<MessageBuffer>,
 ) {
     messages.clear();
     *server_tick = Default::default();
-    event_buffer.clear();
+    message_buffer.clear();
     related_entities.clear();
     for entity in &clients {
         commands.entity(entity).despawn();
@@ -915,7 +909,7 @@ struct DespawnBuffer(Vec<Entity>);
 /// Marker that enables replication and all events for a client.
 ///
 /// Until authorization happened, the client and server can still exchange network events that are marked as
-/// independent via [`ServerEventAppExt::make_event_independent`] or [`ServerTriggerAppExt::make_trigger_independent`].
+/// independent via [`ServerMessageAppExt::make_message_independent`] or [`ServerEventAppExt::make_event_independent`].
 /// **All other events will be ignored**.
 ///
 /// See also [`ConnectedClient`] and [`RepliconSharedPlugin::auth_method`].
diff --git a/src/server/event.rs b/src/server/event.rs
deleted file mode 100644
index 5a048c57..00000000
--- a/src/server/event.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-use bevy::{
-    ecs::system::{FilteredResourcesMutParamBuilder, FilteredResourcesParamBuilder, ParamBuilder},
-    prelude::*,
-};
-
-use super::server_tick::ServerTick;
-use crate::{
-    prelude::*,
-    shared::{
-        event::{
-            ctx::{ServerReceiveCtx, ServerSendCtx},
-            registry::RemoteEventRegistry,
-            server_event::event_buffer::EventBuffer,
-        },
-        replication::client_ticks::ClientTicks,
-    },
-};
-
-/// Sending events from the server to clients.
-///
-/// Requires [`ServerPlugin`].
-/// Can be disabled for apps that act only as clients.
-pub struct ServerEventPlugin;
-
-impl Plugin for ServerEventPlugin {
-    fn build(&self, _app: &mut App) {}
-
-    fn finish(&self, app: &mut App) {
-        // Construct systems dynamically after all plugins initialization
-        // because we need to access resources by registered IDs.
-        let event_registry = app
-            .world_mut()
-            .remove_resource::<RemoteEventRegistry>()
-            .expect("event registry should be initialized on app build");
-
-        let send_or_buffer_fn = (
-            FilteredResourcesParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_server() {
-                    builder.add_read_by_id(event.server_events_id());
-                }
-            }),
-            ParamBuilder,
-            ParamBuilder,
-            ParamBuilder,
-            ParamBuilder,
-            ParamBuilder,
-        )
-            .build_state(app.world_mut())
-            .build_system(send_or_buffer);
-
-        let receive_fn = (
-            FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_client() {
-                    builder.add_write_by_id(event.client_events_id());
-                }
-            }),
-            ParamBuilder,
-            ParamBuilder,
-            ParamBuilder,
-        )
-            .build_state(app.world_mut())
-            .build_system(receive);
-
-        let trigger_fn = (
-            FilteredResourcesMutParamBuilder::new(|builder| {
-                for trigger in event_registry.iter_client_triggers() {
-                    builder.add_write_by_id(trigger.event().client_events_id());
-                }
-            }),
-            ParamBuilder,
-            ParamBuilder,
-        )
-            .build_state(app.world_mut())
-            .build_system(trigger);
-
-        let resend_locally_fn = (
-            FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_server() {
-                    builder.add_write_by_id(event.server_events_id());
-                }
-            }),
-            FilteredResourcesMutParamBuilder::new(|builder| {
-                for event in event_registry.iter_all_server() {
-                    builder.add_write_by_id(event.events_id());
-                }
-            }),
-            ParamBuilder,
-        )
-            .build_state(app.world_mut())
-            .build_system(resend_locally);
-
-        app.insert_resource(event_registry)
-            .add_systems(
-                PreUpdate,
-                (
-                    receive_fn.run_if(in_state(ServerState::Running)),
-                    trigger_fn.run_if(in_state(ClientState::Disconnected)),
-                )
-                    .chain()
-                    .in_set(ServerSystems::Receive),
-            )
-            .add_systems(
-                PostUpdate,
-                (
-                    send_or_buffer_fn.run_if(in_state(ServerState::Running)),
-                    send_buffered
-                        .run_if(in_state(ServerState::Running))
-                        .run_if(resource_changed::<ServerTick>),
-                    resend_locally_fn.run_if(in_state(ClientState::Disconnected)),
-                )
-                    .chain()
-                    .after(super::send_replication)
-                    .in_set(ServerSystems::Send),
-            );
-    }
-}
-
-fn send_or_buffer(
-    server_events: FilteredResources,
-    mut messages: ResMut<ServerMessages>,
-    mut event_buffer: ResMut<EventBuffer>,
-    type_registry: Res<AppTypeRegistry>,
-    event_registry: Res<RemoteEventRegistry>,
-    clients: Query<Entity, With<ConnectedClient>>,
-) {
-    event_buffer.start_tick();
-    let mut ctx = ServerSendCtx {
-        type_registry: &type_registry,
-    };
-
-    for event in event_registry.iter_all_server() {
-        let server_events = server_events
-            .get_by_id(event.server_events_id())
-            .expect("server events resource should be accessible");
-
-        // SAFETY: passed pointer was obtained using this event data.
-        unsafe {
-            event.send_or_buffer(
-                &mut ctx,
-                &server_events,
-                &mut messages,
-                &clients,
-                &mut event_buffer,
-            );
-        }
-    }
-}
-
-fn send_buffered(
-    mut messages: ResMut<ServerMessages>,
-    mut event_buffer: ResMut<EventBuffer>,
-    clients: Query<(Entity, Option<&ClientTicks>), With<ConnectedClient>>,
-) {
-    event_buffer
-        .send_all(&mut messages, &clients)
-        .expect("buffered server events should send");
-}
-
-fn receive(
-    mut client_events: FilteredResourcesMut,
-    mut messages: ResMut<ServerMessages>,
-    type_registry: Res<AppTypeRegistry>,
-    event_registry: Res<RemoteEventRegistry>,
-) {
-    let mut ctx = ServerReceiveCtx {
-        type_registry: &type_registry,
-    };
-
-    for event in event_registry.iter_all_client() {
-        let client_events = client_events
-            .get_mut_by_id(event.client_events_id())
-            .expect("client events resource should be accessible");
-
-        // SAFETY: passed pointer was obtained using this event data.
-        unsafe { event.receive(&mut ctx, client_events.into_inner(), &mut messages) };
-    }
-}
-
-fn trigger(
-    mut client_events: FilteredResourcesMut,
-    mut commands: Commands,
-    event_registry: Res<RemoteEventRegistry>,
-) {
-    for trigger in event_registry.iter_client_triggers() {
-        let client_events = client_events
-            .get_mut_by_id(trigger.event().client_events_id())
-            .expect("client events resource should be accessible");
-        trigger.trigger(&mut commands, client_events.into_inner());
-    }
-}
-
-fn resend_locally(
-    mut server_events: FilteredResourcesMut,
-    mut events: FilteredResourcesMut,
-    event_registry: Res<RemoteEventRegistry>,
-) {
-    for event in event_registry.iter_all_server() {
-        let server_events = server_events
-            .get_mut_by_id(event.server_events_id())
-            .expect("server events resource should be accessible");
-        let events = events
-            .get_mut_by_id(event.events_id())
-            .expect("events resource should be accessible");
-
-        // SAFETY: passed pointers were obtained using this event data.
-        unsafe { event.resend_locally(server_events.into_inner(), events.into_inner()) };
-    }
-}
diff --git a/src/server/message.rs b/src/server/message.rs
new file mode 100644
index 00000000..c20ecaa2
--- /dev/null
+++ b/src/server/message.rs
@@ -0,0 +1,209 @@
+use bevy::{
+    ecs::system::{FilteredResourcesMutParamBuilder, FilteredResourcesParamBuilder, ParamBuilder},
+    prelude::*,
+};
+
+use super::server_tick::ServerTick;
+use crate::{
+    prelude::*,
+    shared::{
+        message::{
+            ctx::{ServerReceiveCtx, ServerSendCtx},
+            registry::RemoteMessageRegistry,
+            server_message::message_buffer::MessageBuffer,
+        },
+        replication::client_ticks::ClientTicks,
+    },
+};
+
+/// Sending messages and events from the server to clients.
+///
+/// Requires [`ServerPlugin`].
+/// Can be disabled for apps that act only as clients.
+pub struct ServerMessagePlugin;
+
+impl Plugin for ServerMessagePlugin {
+    fn build(&self, _app: &mut App) {}
+
+    fn finish(&self, app: &mut App) {
+        // Construct systems dynamically after all plugins initialization
+        // because we need to access resources by registered IDs.
+        let registry = app
+            .world_mut()
+            .remove_resource::<RemoteMessageRegistry>()
+            .expect("message registry should be initialized on app build");
+
+        let send_or_buffer_fn = (
+            FilteredResourcesParamBuilder::new(|builder| {
+                for message in registry.iter_all_server() {
+                    builder.add_read_by_id(message.to_messages_id());
+                }
+            }),
+            ParamBuilder,
+            ParamBuilder,
+            ParamBuilder,
+            ParamBuilder,
+            ParamBuilder,
+        )
+            .build_state(app.world_mut())
+            .build_system(send_or_buffer);
+
+        let receive_fn = (
+            FilteredResourcesMutParamBuilder::new(|builder| {
+                for message in registry.iter_all_client() {
+                    builder.add_write_by_id(message.from_messages_id());
+                }
+            }),
+            ParamBuilder,
+            ParamBuilder,
+            ParamBuilder,
+        )
+            .build_state(app.world_mut())
+            .build_system(receive);
+
+        let trigger_fn = (
+            FilteredResourcesMutParamBuilder::new(|builder| {
+                for event in registry.iter_client_events() {
+                    builder.add_write_by_id(event.message().from_messages_id());
+                }
+            }),
+            ParamBuilder,
+            ParamBuilder,
+        )
+            .build_state(app.world_mut())
+            .build_system(trigger);
+
+        let send_locally_fn = (
+            FilteredResourcesMutParamBuilder::new(|builder| {
+                for message in registry.iter_all_server() {
+                    builder.add_write_by_id(message.to_messages_id());
+                }
+            }),
+            FilteredResourcesMutParamBuilder::new(|builder| {
+                for message in registry.iter_all_server() {
+                    builder.add_write_by_id(message.messages_id());
+                }
+            }),
+            ParamBuilder,
+        )
+            .build_state(app.world_mut())
+            .build_system(send_locally);
+
+        app.insert_resource(registry)
+            .add_systems(
+                PreUpdate,
+                (
+                    receive_fn.run_if(in_state(ServerState::Running)),
+                    trigger_fn.run_if(in_state(ClientState::Disconnected)),
+                )
+                    .chain()
+                    .in_set(ServerSystems::Receive),
+            )
+            .add_systems(
+                PostUpdate,
+                (
+                    send_or_buffer_fn.run_if(in_state(ServerState::Running)),
+                    send_buffered
+                        .run_if(in_state(ServerState::Running))
+                        .run_if(resource_changed::<ServerTick>),
+                    send_locally_fn.run_if(in_state(ClientState::Disconnected)),
+                )
+                    .chain()
+                    .after(super::send_replication)
+                    .in_set(ServerSystems::Send),
+            );
+    }
+}
+
+fn send_or_buffer(
+    to_messages: FilteredResources,
+    mut server_messages: ResMut<ServerMessages>,
+    mut message_buffer: ResMut<MessageBuffer>,
+    type_registry: Res<AppTypeRegistry>,
+    message_registry: Res<RemoteMessageRegistry>,
+    clients: Query<Entity, With<ConnectedClient>>,
+) {
+    message_buffer.start_tick();
+    let mut ctx = ServerSendCtx {
+        type_registry: &type_registry,
+    };
+
+    for message in message_registry.iter_all_server() {
+        let to_messages = to_messages
+            .get_by_id(message.to_messages_id())
+            .expect("to messages resource should be accessible");
+
+        // SAFETY: passed pointer was obtained using this message data.
+        unsafe {
+            message.send_or_buffer(
+                &mut ctx,
+                &to_messages,
+                &mut server_messages,
+                &clients,
+                &mut message_buffer,
+            );
+        }
+    }
+}
+
+fn send_buffered(
+    mut messages: ResMut<ServerMessages>,
+    mut message_buffer: ResMut<MessageBuffer>,
+    clients: Query<(Entity, Option<&ClientTicks>), With<ConnectedClient>>,
+) {
+    message_buffer
+        .send_all(&mut messages, &clients)
+        .expect("buffered server events should send");
+}
+
+fn receive(
+    mut from_messages: FilteredResourcesMut,
+    mut server_messages: ResMut<ServerMessages>,
+    type_registry: Res<AppTypeRegistry>,
+    message_registry: Res<RemoteMessageRegistry>,
+) {
+    let mut ctx = ServerReceiveCtx {
+        type_registry: &type_registry,
+    };
+
+    for message in message_registry.iter_all_client() {
+        let from_messages = from_messages
+            .get_mut_by_id(message.from_messages_id())
+            .expect("from messages resource should be accessible");
+
+        // SAFETY: passed pointer was obtained using this message data.
+        unsafe { message.receive(&mut ctx, from_messages.into_inner(), &mut server_messages) };
+    }
+}
+
+fn trigger(
+    mut from_messages: FilteredResourcesMut,
+    mut commands: Commands,
+    registry: Res<RemoteMessageRegistry>,
+) {
+    for event in registry.iter_client_events() {
+        let from_messages = from_messages
+            .get_mut_by_id(event.message().from_messages_id())
+            .expect("client messages resource should be accessible");
+        // SAFETY: passed pointer was obtained using this message data.
+        unsafe { event.trigger(&mut commands, from_messages.into_inner()) };
+    }
+}
+
+fn send_locally(
+    mut to_messages: FilteredResourcesMut,
+    mut messages: FilteredResourcesMut,
+    registry: Res<RemoteMessageRegistry>,
+) {
+    for message in registry.iter_all_server() {
+        let to_messages = to_messages
+            .get_mut_by_id(message.to_messages_id())
+            .expect("to messages resource should be accessible");
+        let messages = messages
+            .get_mut_by_id(message.messages_id())
+            .expect("messages resource should be accessible");
+
+        // SAFETY: passed pointers were obtained using this message data.
+        unsafe { message.send_locally(to_messages.into_inner(), messages.into_inner()) };
+    }
+}
diff --git a/src/server/related_entities.rs b/src/server/related_entities.rs
index 9d2c73ca..9873f273 100644
--- a/src/server/related_entities.rs
+++ b/src/server/related_entities.rs
@@ -247,54 +247,54 @@ fn read_relations<C: Relationship>(
 }
 
 fn add_relation<C: Relationship>(
-    trigger: Trigger<OnInsert, C>,
+    insert: On<Insert, C>,
     mut related_entities: ResMut<RelatedEntities>,
     state: Res<State<ServerState>>,
     components: Query<&C, With<Replicated>>,
 ) {
     if *state == ServerState::Running
-        && let Ok(relationship) = components.get(trigger.target())
+        && let Ok(relationship) = components.get(insert.entity)
     {
-        related_entities.add_relation::<C>(trigger.target(), relationship.get());
+        related_entities.add_relation::<C>(insert.entity, relationship.get());
     }
 }
 
 fn remove_relation<C: Relationship>(
-    trigger: Trigger<OnReplace, C>,
+    replace: On<Replace, C>,
     mut related_entities: ResMut<RelatedEntities>,
     state: Res<State<ServerState>>,
     relationships: Query<&C, With<Replicated>>,
 ) {
     if *state == ServerState::Running
-        && let Ok(relationship) = relationships.get(trigger.target())
+        && let Ok(relationship) = relationships.get(replace.entity)
     {
-        related_entities.remove_relation::<C>(trigger.target(), relationship.get());
+        related_entities.remove_relation::<C>(replace.entity, relationship.get());
     }
 }
 
 fn start_replication<C: Relationship>(
-    trigger: Trigger<OnInsert, Replicated>,
+    insert: On<Insert, Replicated>,
     mut related_entities: ResMut<RelatedEntities>,
     state: Res<State<ServerState>>,
     components: Query<&C, With<Replicated>>,
 ) {
     if *state == ServerState::Running
-        && let Ok(relationship) = components.get(trigger.target())
+        && let Ok(relationship) = components.get(insert.entity)
     {
-        related_entities.add_relation::<C>(trigger.target(), relationship.get());
+        related_entities.add_relation::<C>(insert.entity, relationship.get());
     }
 }
 
 fn stop_replication<C: Relationship>(
-    trigger: Trigger<OnReplace, Replicated>,
+    replace: On<Replace, Replicated>,
     mut related_entities: ResMut<RelatedEntities>,
     state: Res<State<ServerState>>,
     relationships: Query<&C, With<Replicated>>,
 ) {
     if *state == ServerState::Running
-        && let Ok(relationship) = relationships.get(trigger.target())
+        && let Ok(relationship) = relationships.get(replace.entity)
     {
-        related_entities.remove_relation::<C>(trigger.target(), relationship.get());
+        related_entities.remove_relation::<C>(replace.entity, relationship.get());
     }
 }
 
diff --git a/src/server/removal_buffer.rs b/src/server/removal_buffer.rs
index 9ad30037..24e3f2e9 100644
--- a/src/server/removal_buffer.rs
+++ b/src/server/removal_buffer.rs
@@ -3,8 +3,8 @@ use bevy::{
         archetype::Archetype,
         component::ComponentId,
         entity::hash_map::EntityHashMap,
-        event::EventCursor,
-        removal_detection::{RemovedComponentEntity, RemovedComponentEvents},
+        lifecycle::{RemovedComponentEntity, RemovedComponentMessages},
+        message::MessageCursor,
         system::SystemParam,
     },
     platform::collections::{HashMap, HashSet},
@@ -18,14 +18,14 @@ use crate::{
 
 /// Reader for removed components.
 ///
-/// Like [`RemovedComponentEvents`], but reads them in per-entity format.
+/// Like [`RemovedComponentMessages`], but reads them in per-entity format.
 #[derive(SystemParam)]
 pub(super) struct RemovalReader<'w, 's> {
     /// Cached components list from [`ReplicationRules`].
     components: Local<'s, ReplicatedComponents>,
 
     /// Individual readers for each component.
-    readers: Local<'s, HashMap<ComponentId, EventCursor<RemovedComponentEntity>>>,
+    readers: Local<'s, HashMap<ComponentId, MessageCursor<RemovedComponentEntity>>>,
 
     /// Component removals grouped by entity.
     removals: Local<'s, EntityHashMap<HashSet<ComponentId>>>,
@@ -37,7 +37,7 @@ pub(super) struct RemovalReader<'w, 's> {
     ids_buffer: Local<'s, Vec<HashSet<ComponentId>>>,
 
     /// Component removals grouped by [`ComponentId`].
-    remove_events: &'w RemovedComponentEvents,
+    remove_messages: &'w RemovedComponentMessages,
 
     /// Filter for replicated and valid entities.
     replicated: Query<'w, 's, (), With<Replicated>>,
@@ -50,15 +50,15 @@ impl RemovalReader<'_, '_> {
     pub(super) fn read(&mut self) -> impl Iterator<Item = (&Entity, &HashSet<ComponentId>)> {
         self.clear();
 
-        for (&component_id, component_events) in self
-            .remove_events
+        for (&component_id, component_messages) in self
+            .remove_messages
             .iter()
             .filter(|(component_id, _)| self.components.contains(*component_id))
         {
             // Removed components are grouped by type, not by entity, so we need an intermediate container.
             let reader = self.readers.entry(component_id).or_default();
             for entity in reader
-                .read(component_events)
+                .read(component_messages)
                 .cloned()
                 .map(Into::into)
                 .filter(|&entity| self.replicated.get(entity).is_ok())
@@ -103,7 +103,7 @@ impl FromWorld for ReplicatedComponents {
 
 /// Buffer with removed components.
 ///
-/// Used to avoid missing events.
+/// Used to avoid missing messages.
 #[derive(Default, Resource, Deref)]
 pub(super) struct RemovalBuffer {
     /// Component removals grouped by entity.
diff --git a/src/server/server_world.rs b/src/server/server_world.rs
index 53e50dec..1d605875 100644
--- a/src/server/server_world.rs
+++ b/src/server/server_world.rs
@@ -1,8 +1,10 @@
+use core::mem;
+
 use bevy::{
     ecs::{
-        archetype::{Archetype, ArchetypeEntity, ArchetypeId},
+        archetype::{Archetype, ArchetypeEntity, ArchetypeGeneration, ArchetypeId},
         component::{ComponentId, ComponentTicks, StorageType, Tick},
-        query::{Access, FilteredAccess},
+        query::{FilteredAccess, FilteredAccessSet},
         storage::TableId,
         system::{ReadOnlySystemParam, SystemMeta, SystemParam},
         world::unsafe_world_cell::UnsafeWorldCell,
@@ -39,7 +41,12 @@ impl<'w> ServerWorld<'w, '_> {
         storage: StorageType,
         component_id: ComponentId,
     ) -> (Ptr<'w>, ComponentTicks) {
-        debug_assert!(self.state.access.has_component_read(component_id));
+        debug_assert!(
+            self.state
+                .component_access
+                .access()
+                .has_component_read(component_id)
+        );
 
         let storages = unsafe { self.world.storages() };
         match storage {
@@ -90,90 +97,45 @@ impl<'w> ServerWorld<'w, '_> {
 
 unsafe impl SystemParam for ServerWorld<'_, '_> {
     type State = ReplicationReadState;
-    type Item<'world, 'state> = ServerWorld<'world, 'state>;
+    type Item<'w, 's> = ServerWorld<'w, 's>;
 
-    fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
-        let mut filtered_access = FilteredAccess::default();
+    fn init_state(world: &mut World) -> Self::State {
+        let mut component_access = FilteredAccess::default();
 
         let marker_id = world.register_component::<Replicated>();
-        filtered_access.add_component_read(marker_id);
+        component_access.add_component_read(marker_id);
 
         let rules = world.resource::<ReplicationRules>();
         debug!("initializing with {} replication rules", rules.len());
-        let combined_access = system_meta.component_access_set().combined_access();
         for rule in rules.iter() {
             for component in &rule.components {
-                filtered_access.add_component_read(component.id);
-                assert!(
-                    !combined_access.has_component_write(component.id),
-                    "replicated component `{}` in system `{}` shouldn't be in conflict with other system parameters",
-                    world.components().get_name(component.id).unwrap(),
-                    system_meta.name(),
-                );
+                component_access.add_component_read(component.id);
             }
         }
 
-        let access = filtered_access.access().clone();
-
-        // SAFETY: used only to extend access.
-        unsafe {
-            system_meta.component_access_set_mut().add(filtered_access);
-        }
-
-        ReplicationReadState {
-            access,
+        Self::State {
+            component_access,
             marker_id,
             archetypes: Default::default(),
-            // Needs to be cloned because `new_archetype` only accepts the state.
-            rules: world.resource::<ReplicationRules>().clone(),
+            generation: ArchetypeGeneration::initial(),
         }
     }
 
-    unsafe fn new_archetype(
-        state: &mut Self::State,
-        archetype: &Archetype,
+    fn init_access(
+        state: &Self::State,
         system_meta: &mut SystemMeta,
+        component_access_set: &mut FilteredAccessSet,
+        _world: &mut World,
     ) {
-        if !archetype.contains(state.marker_id) {
-            return;
+        let conflicts = component_access_set.get_conflicts_single(&state.component_access);
+        if !conflicts.is_empty() {
+            panic!(
+                "replicated components in system `{}` shouldn't be in conflict with other system parameters",
+                system_meta.name(),
+            );
         }
 
-        trace!("marking `{:?}` as replicated", archetype.id());
-        let mut replicated_archetype = ReplicatedArchetype::new(archetype.id());
-        for rule in state.rules.iter().filter(|rule| rule.matches(archetype)) {
-            for &component in &rule.components {
-                // Since rules are sorted by priority,
-                // we are inserting only new components that aren't present.
-                if replicated_archetype
-                    .components
-                    .iter()
-                    .any(|(existing, _)| existing.id == component.id)
-                {
-                    continue;
-                }
-
-                // SAFETY: archetype matches the rule, so the component is present.
-                let storage =
-                    unsafe { archetype.get_storage_type(component.id).unwrap_unchecked() };
-                replicated_archetype.components.push((component, storage));
-            }
-        }
-
-        // Update system access for proper parallelization.
-        for (component, _) in &replicated_archetype.components {
-            // SAFETY: archetype contains this component and we don't remove access from system meta.
-            unsafe {
-                let archetype_id = archetype
-                    .get_archetype_component_id(component.id)
-                    .unwrap_unchecked();
-                system_meta
-                    .archetype_component_access_mut()
-                    .add_component_read(archetype_id)
-            }
-        }
-
-        // Store for future iteration.
-        state.archetypes.push(replicated_archetype);
+        component_access_set.add(state.component_access.clone());
     }
 
     unsafe fn get_param<'world, 'state>(
@@ -182,6 +144,43 @@ unsafe impl SystemParam for ServerWorld<'_, '_> {
         world: UnsafeWorldCell<'world>,
         _change_tick: Tick,
     ) -> Self::Item<'world, 'state> {
+        let archetypes = world.archetypes();
+        let old_generation = mem::replace(&mut state.generation, archetypes.generation());
+
+        // SAFETY: Has access to this resource and the access is unique.
+        let rules = unsafe {
+            world
+                .get_resource::<ReplicationRules>()
+                .expect("replication rules should've been initialized in the plugin")
+        };
+        for archetype in archetypes[old_generation..]
+            .iter()
+            .filter(|archetype| archetype.contains(state.marker_id))
+        {
+            trace!("marking `{:?}` as replicated", archetype.id());
+            let mut replicated_archetype = ReplicatedArchetype::new(archetype.id());
+            for rule in rules.iter().filter(|rule| rule.matches(archetype)) {
+                for &component in &rule.components {
+                    // Since rules are sorted by priority,
+                    // we are inserting only new components that aren't present.
+                    if replicated_archetype
+                        .components
+                        .iter()
+                        .any(|(existing, _)| existing.id == component.id)
+                    {
+                        continue;
+                    }
+
+                    // SAFETY: archetype matches the rule, so the component is present.
+                    let storage =
+                        unsafe { archetype.get_storage_type(component.id).unwrap_unchecked() };
+                    replicated_archetype.components.push((component, storage));
+                }
+            }
+
+            state.archetypes.push(replicated_archetype);
+        }
+
         ServerWorld { world, state }
     }
 }
@@ -192,15 +191,16 @@ pub(crate) struct ReplicationReadState {
     /// All replicated components.
     ///
     /// Used only in debug to check component access.
-    access: Access<ComponentId>,
+    component_access: FilteredAccess,
 
     /// ID of [`Replicated`] component.
     marker_id: ComponentId,
 
+    /// Highest processed archetype ID.
+    generation: ArchetypeGeneration,
+
     /// Archetypes marked as replicated.
     archetypes: Vec<ReplicatedArchetype>,
-
-    rules: ReplicationRules,
 }
 
 /// An archetype that can be stored in [`ReplicatedArchetypes`].
@@ -268,20 +268,6 @@ mod tests {
         app.update();
     }
 
-    #[test]
-    fn replicate_after_system() {
-        let mut app = App::new();
-        app.init_resource::<ProtocolHasher>()
-            .init_resource::<ReplicationRules>()
-            .init_resource::<ReplicationRegistry>()
-            .add_systems(Update, |world: ServerWorld| {
-                assert_eq!(world.state.rules.len(), 1);
-            })
-            .replicate::<Transform>();
-
-        app.update();
-    }
-
     #[test]
     fn empty() {
         let mut app = App::new();
diff --git a/src/shared.rs b/src/shared.rs
index 85eaa8e6..a283522f 100644
--- a/src/shared.rs
+++ b/src/shared.rs
@@ -1,6 +1,6 @@
 pub mod backend;
 pub mod client_id;
-pub mod event;
+pub mod message;
 pub mod protocol;
 pub mod replication;
 pub mod replicon_tick;
@@ -10,7 +10,7 @@ use bevy::prelude::*;
 
 use crate::prelude::*;
 use backend::connected_client::NetworkIdMap;
-use event::registry::RemoteEventRegistry;
+use message::registry::RemoteMessageRegistry;
 use replication::signature::SignatureMap;
 use replication::{
     command_markers::CommandMarkers, registry::ReplicationRegistry, rules::ReplicationRules,
@@ -42,9 +42,9 @@ pub struct RepliconSharedPlugin {
             auth_method: AuthMethod::Custom,
         }),
     ))
-    .add_client_trigger::<ClientInfo>(Channel::Ordered)
-    .add_server_trigger::<ProtocolMismatch>(Channel::Unreliable)
-    .make_trigger_independent::<ProtocolMismatch>() // Let the client receive it without replication.
+    .add_client_event::<ClientInfo>(Channel::Ordered)
+    .add_server_event::<ProtocolMismatch>(Channel::Unreliable)
+    .make_event_independent::<ProtocolMismatch>() // Let the client receive it without replication.
     .add_observer(start_game)
     .add_systems(OnEnter(ClientState::Connected), send_info);
 
@@ -59,26 +59,26 @@ pub struct RepliconSharedPlugin {
     }
 
     fn start_game(
-        trigger: Trigger<FromClient<ClientInfo>>,
+        client_info: On<FromClient<ClientInfo>>,
         mut commands: Commands,
-        mut events: EventWriter<DisconnectRequest>,
+        mut disconnects: MessageWriter<DisconnectRequest>,
         protocol: Res<ProtocolHash>,
     ) {
-        let client = trigger
+        let client = client_info
             .client_id
             .entity()
             .expect("protocol hash sent only from clients");
 
         // Since we are using custom authorization,
         // we need to verify the protocol manually.
-        if trigger.protocol != *protocol {
+        if client_info.protocol != *protocol {
             // Notify the client about the problem. No delivery
             // guarantee, since we disconnect after sending.
             commands.server_trigger(ToClients {
-                mode: SendMode::Direct(trigger.client_id),
-                event: ProtocolMismatch,
+                mode: SendMode::Direct(client_info.client_id),
+                message: ProtocolMismatch,
             });
-            events.write(DisconnectRequest { client });
+            disconnects.write(DisconnectRequest { client });
         }
 
         // Validate player name, run the necessary game logic...
@@ -87,7 +87,7 @@ pub struct RepliconSharedPlugin {
         commands.entity(client).insert(AuthorizedClient);
     }
 
-    /// A client trigger for custom authorization.
+    /// A client event for custom authorization.
     #[derive(Event, Serialize, Deserialize)]
     struct ClientInfo {
         protocol: ProtocolHash,
@@ -114,14 +114,14 @@ impl Plugin for RepliconSharedPlugin {
             .init_resource::<ReplicationRules>()
             .init_resource::<SignatureMap>()
             .init_resource::<CommandMarkers>()
-            .init_resource::<RemoteEventRegistry>()
+            .init_resource::<RemoteMessageRegistry>()
             .insert_resource(self.auth_method)
-            .add_event::<DisconnectRequest>();
+            .add_message::<DisconnectRequest>();
 
         if self.auth_method == AuthMethod::ProtocolCheck {
-            app.add_client_trigger::<ProtocolHash>(Channel::Ordered)
-                .add_server_trigger::<ProtocolMismatch>(Channel::Unreliable)
-                .make_trigger_independent::<ProtocolMismatch>();
+            app.add_client_event::<ProtocolHash>(Channel::Ordered)
+                .add_server_event::<ProtocolMismatch>(Channel::Unreliable)
+                .make_event_independent::<ProtocolMismatch>();
         }
     }
 
diff --git a/src/shared/backend.rs b/src/shared/backend.rs
index c169a7d9..b09f6365 100644
--- a/src/shared/backend.rs
+++ b/src/shared/backend.rs
@@ -7,7 +7,7 @@
 //! - Manage the [`ClientState`] and [`ServerState`] states.
 //! - Update the [`ServerMessages`](server_messages::ServerMessages) and [`ClientMessages`](client_messages::ClientMessages) resources.
 //! - Spawn and despawn entities with [`ConnectedClient`](connected_client::ConnectedClient) component.
-//! - React on [`DisconnectRequest`] event.
+//! - React on [`DisconnectRequest`] message.
 //! - Optionally update statistic in [`ClientStats`] resource and components.
 //!
 //! This way, integrations can be provided as separate crates without requiring us or crate authors to maintain them under a feature.
@@ -65,13 +65,13 @@ pub enum ServerState {
     Running,
 }
 
-/// An event for the messaging backend to queue a disconnection
+/// A request for the messaging backend to queue a disconnection
 /// for a specific client on the server.
 ///
 /// The disconnection should occur **after** all pending messages
 /// for this client have been sent. The actual delivery of these
 /// messages is not guaranteed.
-#[derive(Event, Clone, Copy, Debug)]
+#[derive(Message, Clone, Copy, Debug)]
 pub struct DisconnectRequest {
     pub client: Entity,
 }
diff --git a/src/shared/backend/channels.rs b/src/shared/backend/channels.rs
index cd577679..019245f7 100644
--- a/src/shared/backend/channels.rs
+++ b/src/shared/backend/channels.rs
@@ -21,7 +21,7 @@ use log::debug;
 /// Channel IDs are represented by [`usize`], but backends may limit the number of channels.
 /// See [`ServerChannel`] and [`ClientChannel`] for channels that are always reserved.
 /// Other channels are used for events, with one channel per event. For more details, see
-/// [`RemoteEventRegistry`](crate::shared::event::registry::RemoteEventRegistry).
+/// [`RemoteMessageRegistry`](crate::shared::message::registry::RemoteMessageRegistry).
 ///
 /// The backend needs to provide an API for creating its own channels. This can be done
 /// by writing an extension trait for this struct. Created channels should have the defined
@@ -123,7 +123,7 @@ impl RepliconChannels {
 /// [`SyncRelatedAppExt::sync_related_entities`](crate::server::related_entities::SyncRelatedAppExt::sync_related_entities).
 ///
 /// Server events also have minimum required tick. For details, see the documentation on
-/// [`ServerEventAppExt::make_event_independent`](crate::shared::event::server_event::ServerEventAppExt::make_event_independent).
+/// [`ServerMessageAppExt::make_message_independent`](crate::shared::message::server_message::ServerMessageAppExt::make_message_independent).
 ///
 /// See also [`RepliconChannels`], [`Channel`] and [corresponding section](../index.html#eventual-consistency)
 /// from the quick start guide.
diff --git a/src/shared/backend/connected_client.rs b/src/shared/backend/connected_client.rs
index b6a789de..96a4d0ad 100644
--- a/src/shared/backend/connected_client.rs
+++ b/src/shared/backend/connected_client.rs
@@ -1,5 +1,5 @@
 use bevy::{
-    ecs::{component::HookContext, world::DeferredWorld},
+    ecs::{lifecycle::HookContext, world::DeferredWorld},
     platform::collections::HashMap,
     prelude::*,
 };
diff --git a/src/shared/client_id.rs b/src/shared/client_id.rs
index 296ad02c..8503dd20 100644
--- a/src/shared/client_id.rs
+++ b/src/shared/client_id.rs
@@ -4,7 +4,8 @@ use bevy::prelude::*;
 
 /// Unique client ID for the current session.
 ///
-/// Used for [`ToClients`](super::event::server_event::ToClients) and [`FromClient`](super::event::client_event::FromClient) events.
+/// Used for [`ToClients`](super::message::server_message::ToClients) and
+/// [`FromClient`](super::message::client_message::FromClient).
 ///
 /// See also [`NetworkId`](super::backend::connected_client::NetworkId) for a persistent identifier.
 #[derive(Reflect, Debug, Hash, PartialEq, Eq, Ord, PartialOrd, Clone, Copy)]
diff --git a/src/shared/event.rs b/src/shared/event.rs
deleted file mode 100644
index 2e85df52..00000000
--- a/src/shared/event.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-pub mod client_event;
-pub mod client_trigger;
-pub mod ctx;
-pub mod event_fns;
-pub mod registry;
-pub mod remote_targets;
-pub mod server_event;
-pub mod server_trigger;
diff --git a/src/shared/event/client_event.rs b/src/shared/event/client_event.rs
deleted file mode 100644
index 27056a73..00000000
--- a/src/shared/event/client_event.rs
+++ /dev/null
@@ -1,491 +0,0 @@
-use core::any::{self, TypeId};
-
-use bevy::{
-    ecs::{component::ComponentId, entity::MapEntities, event::EventCursor},
-    prelude::*,
-    ptr::{Ptr, PtrMut},
-};
-use bytes::Bytes;
-use log::{debug, error, warn};
-use serde::{Serialize, de::DeserializeOwned};
-
-use super::{
-    ctx::{ClientSendCtx, ServerReceiveCtx},
-    event_fns::{EventDeserializeFn, EventFns, EventSerializeFn, UntypedEventFns},
-    registry::RemoteEventRegistry,
-};
-use crate::{postcard_utils, prelude::*};
-
-/// An extension trait for [`App`] for creating client events.
-///
-/// See also [`ServerEventAppExt`] for server events and [`ClientTriggerAppExt`] for triggers.
-pub trait ClientEventAppExt {
-    /// Registers a remote client event.
-    ///
-    /// After emitting `E` event on the client, [`FromClient<E>`] event will be emitted on the server.
-    ///
-    /// If [`ServerEventPlugin`] is enabled and the client state is [`ClientState::Disconnected`], the event will be drained
-    /// right after sending and re-emitted locally as [`FromClient<E>`] event with [`FromClient::client_id`]
-    /// equal to [`ClientId::Server`].
-    ///
-    /// Calling [`App::add_event`] is not necessary. Can used for regular events that were
-    /// previously registered. But be careful, since on listen servers all events `E` are drained,
-    /// which could break other Bevy or third-party plugin systems that listen for `E`.
-    ///
-    /// See also the [corresponding section](../index.html#from-client-to-server) from the quick start guide.
-    fn add_client_event<E: Event + Serialize + DeserializeOwned>(
-        &mut self,
-        channel: Channel,
-    ) -> &mut Self {
-        self.add_client_event_with(channel, default_serialize::<E>, default_deserialize::<E>)
-    }
-
-    /// Same as [`Self::add_client_event`], but additionally maps client entities to server inside the event before sending.
-    ///
-    /// Always use it for events that contain entities. Entities must be annotated with `#[entities]`.
-    /// For details, see [`Component::map_entities`].
-    ///
-    /// [`Clone`] is required because, before sending, we need to map entities from the client to the server without
-    /// modifying the original component.
-    fn add_mapped_client_event<E: Event + Serialize + DeserializeOwned + MapEntities + Clone>(
-        &mut self,
-        channel: Channel,
-    ) -> &mut Self {
-        self.add_client_event_with(
-            channel,
-            default_serialize_mapped::<E>,
-            default_deserialize::<E>,
-        )
-    }
-
-    /**
-    Same as [`Self::add_client_event`], but uses the specified functions for serialization and deserialization.
-
-    See also [`postcard_utils`] and [`ClientTriggerAppExt::add_client_trigger_with`].
-
-    # Examples
-
-    Register an event with [`Box<dyn PartialReflect>`]:
-
-    ```
-    use bevy::{
-        prelude::*,
-        reflect::serde::{ReflectDeserializer, ReflectSerializer},
-        state::app::StatesPlugin,
-    };
-    use bevy_replicon::{
-        bytes::Bytes,
-        postcard_utils::{BufFlavor, ExtendMutFlavor},
-        shared::event::ctx::{ClientSendCtx, ServerReceiveCtx},
-        prelude::*,
-    };
-    use postcard::{Deserializer, Serializer};
-    use serde::{de::DeserializeSeed, Serialize};
-
-    let mut app = App::new();
-    app.add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins));
-    app.add_client_event_with(Channel::Ordered, serialize_reflect, deserialize_reflect);
-
-    fn serialize_reflect(
-        ctx: &mut ClientSendCtx,
-        event: &ReflectEvent,
-        message: &mut Vec<u8>,
-    ) -> Result<()> {
-        let mut serializer = Serializer { output: ExtendMutFlavor::new(message) };
-        let registry = ctx.type_registry.read();
-        ReflectSerializer::new(&*event.0, &registry).serialize(&mut serializer)?;
-        Ok(())
-    }
-
-    fn deserialize_reflect(
-        ctx: &mut ServerReceiveCtx,
-        message: &mut Bytes,
-    ) -> Result<ReflectEvent> {
-        let mut deserializer = Deserializer::from_flavor(BufFlavor::new(message));
-        let registry = ctx.type_registry.read();
-        let reflect = ReflectDeserializer::new(&registry).deserialize(&mut deserializer)?;
-        Ok(ReflectEvent(reflect))
-    }
-
-    #[derive(Event)]
-    struct ReflectEvent(Box<dyn PartialReflect>);
-    ```
-
-    See also [`AppRuleExt::replicate_with`] for more examples with custom ser/de.
-    */
-    fn add_client_event_with<E: Event>(
-        &mut self,
-        channel: Channel,
-        serialize: EventSerializeFn<ClientSendCtx, E>,
-        deserialize: EventDeserializeFn<ServerReceiveCtx, E>,
-    ) -> &mut Self;
-}
-
-impl ClientEventAppExt for App {
-    fn add_client_event_with<E: Event>(
-        &mut self,
-        channel: Channel,
-        serialize: EventSerializeFn<ClientSendCtx, E>,
-        deserialize: EventDeserializeFn<ServerReceiveCtx, E>,
-    ) -> &mut Self {
-        self.world_mut()
-            .resource_mut::<ProtocolHasher>()
-            .add_client_event::<E>();
-
-        let event_fns = EventFns::new(serialize, deserialize);
-        let event = ClientEvent::new(self, channel, event_fns);
-        let mut event_registry = self.world_mut().resource_mut::<RemoteEventRegistry>();
-        event_registry.register_client_event(event);
-
-        self
-    }
-}
-
-/// Type-erased functions and metadata for a registered client event.
-///
-/// Needed so events of different types can be processed together.
-pub(crate) struct ClientEvent {
-    /// ID of [`Events<E>`] resource.
-    events_id: ComponentId,
-
-    /// ID of [`ClientEventReader<E>`] resource.
-    reader_id: ComponentId,
-
-    /// ID of [`Events<FromClient<E>>`] resource.
-    client_events_id: ComponentId,
-
-    /// Used channel.
-    channel_id: usize,
-
-    /// ID of `E`.
-    type_id: TypeId,
-
-    send: SendFn,
-    receive: ReceiveFn,
-    resend_locally: ResendLocallyFn,
-    reset: ResetFn,
-    event_fns: UntypedEventFns,
-}
-
-impl ClientEvent {
-    pub(super) fn new<E: Event, I: 'static>(
-        app: &mut App,
-        channel: Channel,
-        event_fns: EventFns<ClientSendCtx, ServerReceiveCtx, E, I>,
-    ) -> Self {
-        let channel_id = app
-            .world_mut()
-            .resource_mut::<RepliconChannels>()
-            .create_client_channel(channel);
-
-        app.add_event::<E>()
-            .add_event::<FromClient<E>>()
-            .init_resource::<ClientEventReader<E>>();
-
-        let events_id = app.world().resource_id::<Events<E>>().unwrap();
-        let client_events_id = app.world().resource_id::<Events<FromClient<E>>>().unwrap();
-        let reader_id = app.world().resource_id::<ClientEventReader<E>>().unwrap();
-
-        Self {
-            events_id,
-            reader_id,
-            client_events_id,
-            channel_id,
-            type_id: TypeId::of::<E>(),
-            send: Self::send_typed::<E, I>,
-            receive: Self::receive_typed::<E, I>,
-            resend_locally: Self::resend_locally_typed::<E>,
-            reset: Self::reset_typed::<E>,
-            event_fns: event_fns.into(),
-        }
-    }
-
-    pub(crate) fn events_id(&self) -> ComponentId {
-        self.events_id
-    }
-
-    pub(crate) fn reader_id(&self) -> ComponentId {
-        self.reader_id
-    }
-
-    pub(crate) fn client_events_id(&self) -> ComponentId {
-        self.client_events_id
-    }
-
-    pub(super) fn channel_id(&self) -> usize {
-        self.channel_id
-    }
-
-    pub(super) fn type_id(&self) -> TypeId {
-        self.type_id
-    }
-
-    /// Sends an event to the server.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`], `reader` is [`ClientEventReader<E>`]
-    /// and this instance was created for `E`.
-    pub(crate) unsafe fn send(
-        &self,
-        ctx: &mut ClientSendCtx,
-        events: &Ptr,
-        reader: PtrMut,
-        messages: &mut ClientMessages,
-    ) {
-        unsafe { (self.send)(self, ctx, events, reader, messages) };
-    }
-
-    /// Typed version of [`Self::send`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`], `reader` is [`ClientEventReader<E>`],
-    /// and this instance was created for `E` and `I`.
-    unsafe fn send_typed<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ClientSendCtx,
-        events: &Ptr,
-        reader: PtrMut,
-        messages: &mut ClientMessages,
-    ) {
-        let reader: &mut ClientEventReader<E> = unsafe { reader.deref_mut() };
-        let events = unsafe { events.deref() };
-        for event in reader.read(events) {
-            let mut message = Vec::new();
-            if let Err(e) = unsafe { self.serialize::<E, I>(ctx, event, &mut message) } {
-                error!(
-                    "ignoring event `{}` that failed to serialize: {e}",
-                    any::type_name::<E>()
-                );
-                continue;
-            }
-
-            debug!("sending event `{}`", any::type_name::<E>());
-            messages.send(self.channel_id, message);
-        }
-    }
-
-    /// Receives events from a client.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `client_events` is [`Events<FromClient<E>>`]
-    /// and this instance was created for `E`.
-    pub(crate) unsafe fn receive(
-        &self,
-        ctx: &mut ServerReceiveCtx,
-        client_events: PtrMut,
-        messages: &mut ServerMessages,
-    ) {
-        unsafe { (self.receive)(self, ctx, client_events, messages) }
-    }
-
-    /// Typed version of [`Self::receive`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `client_events` is [`Events<FromClient<E>>`]
-    /// and this instance was created for `E` and `I`.
-    unsafe fn receive_typed<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ServerReceiveCtx,
-        client_events: PtrMut,
-        messages: &mut ServerMessages,
-    ) {
-        let client_events: &mut Events<FromClient<E>> = unsafe { client_events.deref_mut() };
-        for (client, mut message) in messages.receive(self.channel_id) {
-            match unsafe { self.deserialize::<E, I>(ctx, &mut message) } {
-                Ok(event) => {
-                    debug!(
-                        "applying event `{}` from client `{client}`",
-                        any::type_name::<E>()
-                    );
-                    client_events.send(FromClient {
-                        client_id: client.into(),
-                        event,
-                    });
-                }
-                Err(e) => debug!(
-                    "ignoring event `{}` from client `{client}` that failed to deserialize: {e}",
-                    any::type_name::<E>()
-                ),
-            }
-        }
-    }
-
-    /// Drains events `E` and re-emits them as [`FromClient<E>`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`], `client_events` is [`Events<FromClient<E>>`]
-    /// and this instance was created for `E`.
-    pub(crate) unsafe fn resend_locally(&self, client_events: PtrMut, events: PtrMut) {
-        unsafe { (self.resend_locally)(client_events, events) }
-    }
-
-    /// Typed version of [`ClientEvent::resend_locally`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`] and `server_events` is [`Events<ToClients<E>>`].
-    unsafe fn resend_locally_typed<E: Event>(server_events: PtrMut, events: PtrMut) {
-        let client_events: &mut Events<FromClient<E>> = unsafe { server_events.deref_mut() };
-        let events: &mut Events<E> = unsafe { events.deref_mut() };
-        if !events.is_empty() {
-            debug!(
-                "resending {} event(s) `{}` locally",
-                events.len(),
-                any::type_name::<E>()
-            );
-            client_events.send_batch(events.drain().map(|event| FromClient {
-                client_id: ClientId::Server,
-                event,
-            }));
-        }
-    }
-
-    /// Drains all events.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`]
-    /// and this instance was created for `E`.
-    pub(crate) unsafe fn reset(&self, events: PtrMut) {
-        unsafe { (self.reset)(events) }
-    }
-
-    /// Typed version of [`ClientEvent::reset`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`].
-    unsafe fn reset_typed<E: Event>(events: PtrMut) {
-        let events: &mut Events<E> = unsafe { events.deref_mut() };
-        let drained_count = events.drain().count();
-        if drained_count > 0 {
-            warn!(
-                "discarded {drained_count} events of type `{}` that were buffered before the connection",
-                any::type_name::<E>()
-            );
-        }
-    }
-
-    /// Serializes an event into a message.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that this instance was created for `E` and `I`.
-    unsafe fn serialize<E: 'static, I: 'static>(
-        &self,
-        ctx: &mut ClientSendCtx,
-        event: &E,
-        message: &mut Vec<u8>,
-    ) -> Result<()> {
-        unsafe {
-            self.event_fns
-                .typed::<ClientSendCtx, ServerReceiveCtx, E, I>()
-                .serialize(ctx, event, message)?;
-        }
-
-        if ctx.invalid_entities.is_empty() {
-            Ok(())
-        } else {
-            let msg = format!(
-                "unable to map entities `{:?}` for the server, \
-                make sure that the event references entities visible to the server",
-                ctx.invalid_entities,
-            );
-            ctx.invalid_entities.clear();
-            Err(msg.into())
-        }
-    }
-
-    /// Deserializes an event from a message.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that this instance was created for `E` and `I`.
-    unsafe fn deserialize<E: 'static, I: 'static>(
-        &self,
-        ctx: &mut ServerReceiveCtx,
-        message: &mut Bytes,
-    ) -> Result<E> {
-        unsafe {
-            self.event_fns
-                .typed::<ClientSendCtx, ServerReceiveCtx, E, I>()
-                .deserialize(ctx, message)
-        }
-    }
-}
-
-/// Signature of client event sending functions.
-type SendFn = unsafe fn(&ClientEvent, &mut ClientSendCtx, &Ptr, PtrMut, &mut ClientMessages);
-
-/// Signature of client event receiving functions.
-type ReceiveFn = unsafe fn(&ClientEvent, &mut ServerReceiveCtx, PtrMut, &mut ServerMessages);
-
-/// Signature of client event resending functions.
-type ResendLocallyFn = unsafe fn(PtrMut, PtrMut);
-
-/// Signature of client event reset functions.
-type ResetFn = unsafe fn(PtrMut);
-
-/// Tracks read events for [`ClientEventPlugin::send`].
-///
-/// Unlike with server events, we don't always drain all events in [`ClientEventPlugin::resend_locally`].
-#[derive(Resource, Deref, DerefMut)]
-struct ClientEventReader<E: Event>(EventCursor<E>);
-
-impl<E: Event> FromWorld for ClientEventReader<E> {
-    fn from_world(world: &mut World) -> Self {
-        let events = world.resource::<Events<E>>();
-        Self(events.get_cursor())
-    }
-}
-
-/// An event indicating that a message from client was received.
-///
-/// Emitted only on server.
-#[derive(Clone, Copy, Event, Debug, Deref, DerefMut)]
-pub struct FromClient<T> {
-    /// Sender of the event.
-    ///
-    /// See also [`ConnectedClient`].
-    pub client_id: ClientId,
-
-    /// Transmitted event.
-    #[deref]
-    pub event: T,
-}
-
-/// Default event serialization function.
-pub fn default_serialize<E: Event + Serialize>(
-    _ctx: &mut ClientSendCtx,
-    event: &E,
-    message: &mut Vec<u8>,
-) -> Result<()> {
-    postcard_utils::to_extend_mut(event, message)?;
-    Ok(())
-}
-
-/// Like [`default_serialize`], but also maps entities.
-pub fn default_serialize_mapped<E: Event + MapEntities + Clone + Serialize>(
-    ctx: &mut ClientSendCtx,
-    event: &E,
-    message: &mut Vec<u8>,
-) -> Result<()> {
-    let mut event = event.clone();
-    event.map_entities(ctx);
-    postcard_utils::to_extend_mut(&event, message)?;
-    Ok(())
-}
-
-/// Default event deserialization function.
-pub fn default_deserialize<E: Event + DeserializeOwned>(
-    _ctx: &mut ServerReceiveCtx,
-    message: &mut Bytes,
-) -> Result<E> {
-    let event = postcard_utils::from_buf(message)?;
-    Ok(event)
-}
diff --git a/src/shared/event/client_trigger.rs b/src/shared/event/client_trigger.rs
deleted file mode 100644
index 456d4d04..00000000
--- a/src/shared/event/client_trigger.rs
+++ /dev/null
@@ -1,231 +0,0 @@
-use core::any;
-
-use bevy::{ecs::entity::MapEntities, prelude::*, ptr::PtrMut};
-use bytes::Bytes;
-use log::debug;
-use serde::{Serialize, de::DeserializeOwned};
-
-use super::{
-    client_event::{self, ClientEvent},
-    ctx::{ClientSendCtx, ServerReceiveCtx},
-    event_fns::{EventDeserializeFn, EventFns, EventSerializeFn},
-    registry::RemoteEventRegistry,
-    remote_targets::RemoteTargets,
-};
-use crate::{postcard_utils, prelude::*};
-
-/// An extension trait for [`App`] for creating client triggers.
-///
-/// See also [`ClientTriggerExt`] for triggering, [`ServerTriggerAppExt`] for server triggers
-/// and [`ClientEventAppExt`] for events.
-pub trait ClientTriggerAppExt {
-    /// Registers a remote event that can be triggered using [`ClientTriggerExt::client_trigger`].
-    ///
-    /// After triggering `E` event on the client, [`FromClient<E>`] event will be triggered on the server.
-    ///
-    /// If [`ServerEventPlugin`] is enabled and the client state is [`ClientState::Disconnected`], the event will also be triggered
-    /// locally as [`FromClient<E>`] event with [`FromClient::client_id`] equal to [`ClientId::Server`].
-    ///
-    /// See also the [corresponding section](../index.html#from-client-to-server) from the quick start guide.
-    fn add_client_trigger<E: Event + Serialize + DeserializeOwned>(
-        &mut self,
-        channel: Channel,
-    ) -> &mut Self {
-        self.add_client_trigger_with(
-            channel,
-            client_event::default_serialize::<E>,
-            client_event::default_deserialize::<E>,
-        )
-    }
-
-    /// Same as [`Self::add_client_trigger`], but additionally maps client entities to server inside the event before sending.
-    ///
-    /// Always use it for events that contain entities. Entities must be annotated with `#[entities]`.
-    /// For details, see [`Component::map_entities`].
-    fn add_mapped_client_trigger<E: Event + Serialize + DeserializeOwned + MapEntities + Clone>(
-        &mut self,
-        channel: Channel,
-    ) -> &mut Self {
-        self.add_client_trigger_with(
-            channel,
-            client_event::default_serialize_mapped::<E>,
-            client_event::default_deserialize::<E>,
-        )
-    }
-
-    /// Same as [`Self::add_client_trigger`], but uses the specified functions for serialization and deserialization.
-    ///
-    /// See also [`ClientEventAppExt::add_client_event_with`].
-    fn add_client_trigger_with<E: Event>(
-        &mut self,
-        channel: Channel,
-        serialize: EventSerializeFn<ClientSendCtx, E>,
-        deserialize: EventDeserializeFn<ServerReceiveCtx, E>,
-    ) -> &mut Self;
-}
-
-impl ClientTriggerAppExt for App {
-    fn add_client_trigger_with<E: Event>(
-        &mut self,
-        channel: Channel,
-        serialize: EventSerializeFn<ClientSendCtx, E>,
-        deserialize: EventDeserializeFn<ServerReceiveCtx, E>,
-    ) -> &mut Self {
-        self.world_mut()
-            .resource_mut::<ProtocolHasher>()
-            .add_client_trigger::<E>();
-
-        let event_fns = EventFns::new(serialize, deserialize)
-            .with_outer(trigger_serialize, trigger_deserialize);
-
-        let trigger = ClientTrigger::new(self, channel, event_fns);
-        let mut event_registry = self.world_mut().resource_mut::<RemoteEventRegistry>();
-        event_registry.register_client_trigger(trigger);
-
-        self
-    }
-}
-
-/// Small abstraction on top of [`ClientEvent`] that stores a function to trigger them.
-pub(crate) struct ClientTrigger {
-    event: ClientEvent,
-    trigger: TriggerFn,
-}
-
-impl ClientTrigger {
-    fn new<E: Event>(
-        app: &mut App,
-        channel: Channel,
-        event_fns: EventFns<ClientSendCtx, ServerReceiveCtx, ClientTriggerEvent<E>, E>,
-    ) -> Self {
-        Self {
-            event: ClientEvent::new(app, channel, event_fns),
-            trigger: Self::trigger_typed::<E>,
-        }
-    }
-
-    pub(crate) fn trigger(&self, commands: &mut Commands, events: PtrMut) {
-        unsafe {
-            (self.trigger)(commands, events);
-        }
-    }
-
-    /// Drains received [`FromClient<TriggerEvent<E>>`] events and triggers them as [`FromClient<E>`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `client_events` is [`Events<FromClient<TriggerEvent<E>>>`]
-    /// 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<ClientTriggerEvent<E>>> =
-            unsafe { client_events.deref_mut() };
-        for FromClient { client_id, event } in client_events.drain() {
-            debug!(
-                "triggering `{}` from `{client_id}`",
-                any::type_name::<FromClient<E>>()
-            );
-            commands.trigger_targets(
-                FromClient {
-                    client_id,
-                    event: event.event,
-                },
-                event.targets,
-            );
-        }
-    }
-
-    pub(crate) fn event(&self) -> &ClientEvent {
-        &self.event
-    }
-}
-
-/// Signature of client trigger functions.
-type TriggerFn = unsafe fn(&mut Commands, PtrMut);
-
-/// Serializes targets for [`TriggerEvent`], maps them and delegates the event
-/// serialiaztion to `serialize`.
-///
-/// Used as outer function for [`EventFns`].
-fn trigger_serialize<'a, E>(
-    ctx: &mut ClientSendCtx<'a>,
-    trigger: &ClientTriggerEvent<E>,
-    message: &mut Vec<u8>,
-    serialize: EventSerializeFn<ClientSendCtx<'a>, E>,
-) -> Result<()> {
-    postcard_utils::to_extend_mut(&trigger.targets.len(), message)?;
-    for &entity in &trigger.targets {
-        let entity = ctx.get_mapped(entity);
-        postcard_utils::entity_to_extend_mut(&entity, message)?;
-    }
-
-    (serialize)(ctx, &trigger.event, message)
-}
-
-/// Deserializes targets for [`TriggerEvent`], maps them and delegates the event
-/// deserialiaztion to `deserialize`.
-///
-/// Used as outer function for [`EventFns`].
-fn trigger_deserialize<'a, E>(
-    ctx: &mut ServerReceiveCtx<'a>,
-    message: &mut Bytes,
-    deserialize: EventDeserializeFn<ServerReceiveCtx<'a>, E>,
-) -> Result<ClientTriggerEvent<E>> {
-    let len = postcard_utils::from_buf(message)?;
-    let mut targets = Vec::with_capacity(len);
-    for _ in 0..len {
-        let entity = postcard_utils::entity_from_buf(message)?;
-        targets.push(entity);
-    }
-
-    let event = (deserialize)(ctx, message)?;
-
-    Ok(ClientTriggerEvent { event, targets })
-}
-
-/// Extension trait for triggering client events.
-///
-/// See also [`ClientTriggerAppExt`].
-pub trait ClientTriggerExt {
-    /// Like [`Commands::trigger`], but triggers [`FromClient`] on server and locally if the client state is [`ClientState::Disconnected`].
-    fn client_trigger(&mut self, event: impl Event);
-
-    /// Like [`Self::client_trigger`], but allows you to specify target entities, similar to [`Commands::trigger_targets`].
-    fn client_trigger_targets(&mut self, event: impl Event, targets: impl RemoteTargets);
-}
-
-impl ClientTriggerExt for Commands<'_, '_> {
-    fn client_trigger(&mut self, event: impl Event) {
-        self.client_trigger_targets(event, []);
-    }
-
-    fn client_trigger_targets(&mut self, event: impl Event, targets: impl RemoteTargets) {
-        self.send_event(ClientTriggerEvent {
-            event,
-            targets: targets.into_entities(),
-        });
-    }
-}
-
-impl ClientTriggerExt for World {
-    fn client_trigger(&mut self, event: impl Event) {
-        self.client_trigger_targets(event, []);
-    }
-
-    fn client_trigger_targets(&mut self, event: impl Event, targets: impl RemoteTargets) {
-        self.send_event(ClientTriggerEvent {
-            event,
-            targets: targets.into_entities(),
-        });
-    }
-}
-
-/// An event that used under the hood for client triggers.
-///
-/// We can't just observe for triggers like we do for events since we need access to all its targets
-/// and we need to buffer them. This is why we just emit this event instead and after receive drain it
-/// to trigger regular events.
-#[derive(Event)]
-struct ClientTriggerEvent<E> {
-    event: E,
-    targets: Vec<Entity>,
-}
diff --git a/src/shared/event/event_fns.rs b/src/shared/event/event_fns.rs
deleted file mode 100644
index d49b816b..00000000
--- a/src/shared/event/event_fns.rs
+++ /dev/null
@@ -1,196 +0,0 @@
-use alloc::vec::Vec;
-use core::{
-    any::{self, TypeId},
-    mem,
-};
-
-use bevy::prelude::*;
-use bytes::Bytes;
-
-/// Type-erased version of [`EventFns`].
-///
-/// Stored inside events after their creation.
-#[derive(Clone, Copy)]
-pub(super) struct UntypedEventFns {
-    serialize_ctx_id: TypeId,
-    serialize_ctx_name: &'static str,
-    deserialize_ctx_id: TypeId,
-    deserialize_ctx_name: &'static str,
-    event_id: TypeId,
-    event_name: &'static str,
-    inner_id: TypeId,
-    inner_name: &'static str,
-
-    outer_serialize: unsafe fn(),
-    outer_deserialize: unsafe fn(),
-    serialize: unsafe fn(),
-    deserialize: unsafe fn(),
-}
-
-impl UntypedEventFns {
-    /// Restores the original [`EventFns`] from which this type was created.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that the function is called with the same generics with which this instance was created.
-    pub(super) unsafe fn typed<S, D, E: 'static, I: 'static>(self) -> EventFns<S, D, E, I> {
-        // `TypeId` can only be obtained for `'static` types, but we can't impose this requirement because our context has a lifetime.
-        // So, we use the `typeid` crate for non-static `TypeId`, as we don't care about the lifetime and only need to check the type.
-        // This crate is already used by `erased_serde`, so we don't add an extra dependency.
-        debug_assert_eq!(
-            self.serialize_ctx_id,
-            typeid::of::<S>(),
-            "trying to call event functions with serialize context `{}`, but they were created with `{}`",
-            any::type_name::<S>(),
-            self.serialize_ctx_name,
-        );
-        debug_assert_eq!(
-            self.deserialize_ctx_id,
-            typeid::of::<D>(),
-            "trying to call event functions with deserialize context `{}`, but they were created with `{}`",
-            any::type_name::<D>(),
-            self.deserialize_ctx_name,
-        );
-        debug_assert_eq!(
-            self.event_id,
-            TypeId::of::<E>(),
-            "trying to call event functions with event `{}`, but they were created with `{}`",
-            any::type_name::<E>(),
-            self.event_name,
-        );
-        debug_assert_eq!(
-            self.inner_id,
-            TypeId::of::<I>(),
-            "trying to call event functions with inner type `{}`, but they were created with `{}`",
-            any::type_name::<I>(),
-            self.inner_name,
-        );
-
-        EventFns {
-            outer_serialize: unsafe {
-                mem::transmute::<unsafe fn(), OuterSerializeFn<S, E, I>>(self.outer_serialize)
-            },
-            outer_deserialize: unsafe {
-                mem::transmute::<unsafe fn(), OuterDeserializeFn<D, E, I>>(self.outer_deserialize)
-            },
-            serialize: unsafe {
-                mem::transmute::<unsafe fn(), EventSerializeFn<S, I>>(self.serialize)
-            },
-            deserialize: unsafe {
-                mem::transmute::<unsafe fn(), EventDeserializeFn<D, I>>(self.deserialize)
-            },
-        }
-    }
-}
-
-impl<S, D, E: 'static, I: 'static> From<EventFns<S, D, E, I>> for UntypedEventFns {
-    fn from(value: EventFns<S, D, E, I>) -> Self {
-        // SAFETY: these functions won't be called until the type is restored.
-        Self {
-            serialize_ctx_id: typeid::of::<S>(),
-            serialize_ctx_name: any::type_name::<S>(),
-            deserialize_ctx_id: typeid::of::<D>(),
-            deserialize_ctx_name: any::type_name::<D>(),
-            event_id: TypeId::of::<E>(),
-            event_name: any::type_name::<E>(),
-            inner_id: TypeId::of::<I>(),
-            inner_name: any::type_name::<I>(),
-            outer_serialize: unsafe {
-                mem::transmute::<OuterSerializeFn<S, E, I>, unsafe fn()>(value.outer_serialize)
-            },
-            outer_deserialize: unsafe {
-                mem::transmute::<OuterDeserializeFn<D, E, I>, unsafe fn()>(value.outer_deserialize)
-            },
-            serialize: unsafe {
-                mem::transmute::<EventSerializeFn<S, I>, unsafe fn()>(value.serialize)
-            },
-            deserialize: unsafe {
-                mem::transmute::<EventDeserializeFn<D, I>, unsafe fn()>(value.deserialize)
-            },
-        }
-    }
-}
-
-/// Serialization and deserialization functions for an event.
-///
-/// For triggers, we want to allow users to customize these functions, but it would be inconvenient
-/// to write serialization and deserialization logic for trigger target entities every time.
-/// Since closures can't be used, we provide outer functions that accept regular serialization functions.
-/// By default, these outer functions simply call the inner function, but they can be overridden
-/// to write common serde logic.
-pub(super) struct EventFns<S, D, E, I = E> {
-    outer_serialize: OuterSerializeFn<S, E, I>,
-    outer_deserialize: OuterDeserializeFn<D, E, I>,
-    serialize: EventSerializeFn<S, I>,
-    deserialize: EventDeserializeFn<D, I>,
-}
-
-impl<S, D, E> EventFns<S, D, E, E> {
-    /// Creates a new instance with default outer functions.
-    pub(super) fn new(
-        serialize: EventSerializeFn<S, E>,
-        deserialize: EventDeserializeFn<D, E>,
-    ) -> Self {
-        Self {
-            outer_serialize: default_outer_serialize::<S, E>,
-            outer_deserialize: default_outer_deserialize::<D, E>,
-            serialize,
-            deserialize,
-        }
-    }
-}
-
-impl<S, D, E, I> EventFns<S, D, E, I> {
-    /// Overrides current outer functions.
-    pub(super) fn with_outer<T>(
-        self,
-        outer_serialize: OuterSerializeFn<S, T, I>,
-        outer_deserialize: OuterDeserializeFn<D, T, I>,
-    ) -> EventFns<S, D, T, I> {
-        EventFns {
-            outer_serialize,
-            outer_deserialize,
-            serialize: self.serialize,
-            deserialize: self.deserialize,
-        }
-    }
-
-    pub(super) fn serialize(self, ctx: &mut S, event: &E, message: &mut Vec<u8>) -> Result<()> {
-        (self.outer_serialize)(ctx, event, message, self.serialize)
-    }
-
-    pub(super) fn deserialize(self, ctx: &mut D, message: &mut Bytes) -> Result<E> {
-        (self.outer_deserialize)(ctx, message, self.deserialize)
-    }
-}
-
-fn default_outer_serialize<C, E>(
-    ctx: &mut C,
-    event: &E,
-    message: &mut Vec<u8>,
-    serialize: EventSerializeFn<C, E>,
-) -> Result<()> {
-    (serialize)(ctx, event, message)
-}
-
-fn default_outer_deserialize<C, E>(
-    ctx: &mut C,
-    message: &mut Bytes,
-    deserialize: EventDeserializeFn<C, E>,
-) -> Result<E> {
-    (deserialize)(ctx, message)
-}
-
-/// Signature of event serialization functions.
-pub type EventSerializeFn<C, E> = fn(&mut C, &E, &mut Vec<u8>) -> Result<()>;
-
-/// Signature of event deserialization functions.
-pub type EventDeserializeFn<C, E> = fn(&mut C, &mut Bytes) -> Result<E>;
-
-/// Signature of outer serialization functions.
-pub(super) type OuterSerializeFn<C, E, I> =
-    fn(&mut C, &E, &mut Vec<u8>, EventSerializeFn<C, I>) -> Result<()>;
-
-/// Signature of outer deserialization functions.
-pub(super) type OuterDeserializeFn<C, E, I> =
-    fn(&mut C, &mut Bytes, EventDeserializeFn<C, I>) -> Result<E>;
diff --git a/src/shared/event/registry.rs b/src/shared/event/registry.rs
deleted file mode 100644
index b43b0f6c..00000000
--- a/src/shared/event/registry.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use core::any::TypeId;
-
-use bevy::prelude::*;
-
-use super::{
-    client_event::ClientEvent, client_trigger::ClientTrigger, server_event::ServerEvent,
-    server_trigger::ServerTrigger,
-};
-
-/// Registered server and client events.
-#[derive(Resource, Default)]
-pub struct RemoteEventRegistry {
-    // We use store triggers separately for quick iteration over them,
-    // but they are events under the hood.
-    server_events: Vec<ServerEvent>,
-    client_events: Vec<ClientEvent>,
-    server_triggers: Vec<ServerTrigger>,
-    client_triggers: Vec<ClientTrigger>,
-}
-
-impl RemoteEventRegistry {
-    pub(super) fn register_server_event(&mut self, event: ServerEvent) {
-        self.server_events.push(event);
-    }
-
-    pub(super) fn register_client_event(&mut self, event: ClientEvent) {
-        self.client_events.push(event);
-    }
-
-    pub(super) fn register_server_trigger(&mut self, trigger: ServerTrigger) {
-        self.server_triggers.push(trigger);
-    }
-
-    pub(super) fn register_client_trigger(&mut self, trigger: ClientTrigger) {
-        self.client_triggers.push(trigger);
-    }
-
-    pub(super) fn iter_server_events_mut(&mut self) -> impl Iterator<Item = &mut ServerEvent> {
-        self.server_events.iter_mut()
-    }
-
-    pub(super) fn iter_server_triggers_mut(&mut self) -> impl Iterator<Item = &mut ServerTrigger> {
-        self.server_triggers.iter_mut()
-    }
-
-    pub(crate) fn iter_all_server(&self) -> impl Iterator<Item = &ServerEvent> {
-        self.server_events
-            .iter()
-            .chain(self.server_triggers.iter().map(|trigger| trigger.event()))
-    }
-
-    pub(crate) fn iter_all_client(&self) -> impl Iterator<Item = &ClientEvent> {
-        self.client_events
-            .iter()
-            .chain(self.client_triggers.iter().map(|trigger| trigger.event()))
-    }
-
-    pub(crate) fn iter_server_triggers(&self) -> impl Iterator<Item = &ServerTrigger> {
-        self.server_triggers.iter()
-    }
-
-    pub(crate) fn iter_client_triggers(&self) -> impl Iterator<Item = &ClientTrigger> {
-        self.client_triggers.iter()
-    }
-
-    /// Returns registered channel ID for server event or trigger `E`.
-    ///
-    /// See also [`ServerEventAppExt::add_server_event`](super::server_event::ServerEventAppExt::add_server_event)
-    /// and [`ServerTriggerAppExt::add_server_trigger`](super::server_trigger::ServerTriggerAppExt::add_server_trigger).
-    pub fn server_channel<E: Event>(&self) -> Option<usize> {
-        self.iter_all_server()
-            .find(|event| event.type_id() == TypeId::of::<E>())
-            .map(|event| event.channel_id())
-    }
-
-    /// Returns registered channel ID for client event or trigger `E`.
-    ///
-    /// See also [`ClientEventAppExt::add_client_event`](super::client_event::ClientEventAppExt::add_client_event)
-    /// and [`ClientTriggerAppExt::add_client_trigger`](super::client_trigger::ClientTriggerAppExt::add_client_trigger).
-    pub fn client_channel<E: Event>(&self) -> Option<usize> {
-        self.iter_all_client()
-            .find(|event| event.type_id() == TypeId::of::<E>())
-            .map(|event| event.channel_id())
-    }
-}
diff --git a/src/shared/event/remote_targets.rs b/src/shared/event/remote_targets.rs
deleted file mode 100644
index dd7a5fe0..00000000
--- a/src/shared/event/remote_targets.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use bevy::prelude::*;
-
-/// Like [`TriggerTargets`](bevy::ecs::observer::TriggerTargets), but for remote triggers
-/// where targets can only be entities.
-pub trait RemoteTargets {
-    /// Entities the trigger should target.
-    fn into_entities(self) -> Vec<Entity>;
-}
-
-impl RemoteTargets for Entity {
-    fn into_entities(self) -> Vec<Entity> {
-        vec![self]
-    }
-}
-
-impl RemoteTargets for Vec<Entity> {
-    fn into_entities(self) -> Vec<Entity> {
-        self
-    }
-}
-
-impl<const N: usize> RemoteTargets for [Entity; N] {
-    fn into_entities(self) -> Vec<Entity> {
-        self.to_vec()
-    }
-}
-
-impl RemoteTargets for &[Entity] {
-    fn into_entities(self) -> Vec<Entity> {
-        self.to_vec()
-    }
-}
diff --git a/src/shared/event/server_event.rs b/src/shared/event/server_event.rs
deleted file mode 100644
index 86b2b20a..00000000
--- a/src/shared/event/server_event.rs
+++ /dev/null
@@ -1,704 +0,0 @@
-pub(crate) mod event_buffer;
-mod event_queue;
-
-use core::any::{self, TypeId};
-
-use bevy::{
-    ecs::{component::ComponentId, entity::MapEntities},
-    prelude::*,
-    ptr::{Ptr, PtrMut},
-};
-use bytes::Bytes;
-use log::{debug, error, warn};
-use postcard::experimental::max_size::MaxSize;
-use serde::{Serialize, de::DeserializeOwned};
-
-use super::{
-    ctx::{ClientReceiveCtx, ServerSendCtx},
-    event_fns::{EventDeserializeFn, EventFns, EventSerializeFn, UntypedEventFns},
-    registry::RemoteEventRegistry,
-};
-use crate::{postcard_utils, prelude::*};
-use event_buffer::{EventBuffer, SerializedMessage};
-use event_queue::EventQueue;
-
-/// An extension trait for [`App`] for creating server events.
-///
-/// See also [`ClientEventAppExt`] for client events and [`ServerTriggerAppExt`] for triggers.
-pub trait ServerEventAppExt {
-    /// Registers a remote server event.
-    ///
-    /// After emitting [`ToClients<E>`] event on the server, `E` event  will be emitted on clients.
-    ///
-    /// If [`ClientEventPlugin`] is enabled and [`ClientId::Server`] is a recipient of the event, then
-    /// [`ToClients<E>`] event will be drained after sending to clients and `E` event will be emitted
-    /// on the server as well.
-    ///
-    /// Calling [`App::add_event`] is not necessary. Can used for regular events that were
-    /// previously registered.
-    ///
-    /// Unlike client events, server events are tied to replication. See [`Self::make_event_independent`]
-    /// for more details.
-    ///
-    /// See also the [corresponding section](../index.html#from-client-to-server) from the quick start guide.
-    fn add_server_event<E: Event + Serialize + DeserializeOwned>(
-        &mut self,
-        channel: Channel,
-    ) -> &mut Self {
-        self.add_server_event_with(channel, default_serialize::<E>, default_deserialize::<E>)
-    }
-
-    /// Same as [`Self::add_server_event`], but additionally maps server entities to client inside the event after receiving.
-    ///
-    /// Always use it for events that contain entities. Entities must be annotated with `#[entities]`.
-    /// For details, see [`Component::map_entities`].
-    fn add_mapped_server_event<E: Event + Serialize + DeserializeOwned + MapEntities>(
-        &mut self,
-        channel: Channel,
-    ) -> &mut Self {
-        self.add_server_event_with(
-            channel,
-            default_serialize::<E>,
-            default_deserialize_mapped::<E>,
-        )
-    }
-
-    /**
-    Same as [`Self::add_server_event`], but uses the specified functions for serialization and deserialization.
-
-    See also [`postcard_utils`] and [`ServerTriggerAppExt::add_server_trigger_with`].
-
-    # Examples
-
-    Register an event with [`Box<dyn PartialReflect>`]:
-
-    ```
-    use bevy::{
-        prelude::*,
-        reflect::serde::{ReflectDeserializer, ReflectSerializer},
-        state::app::StatesPlugin,
-    };
-    use bevy_replicon::{
-        bytes::Bytes,
-        postcard_utils::{BufFlavor, ExtendMutFlavor},
-        shared::event::ctx::{ClientReceiveCtx, ServerSendCtx},
-        prelude::*,
-    };
-    use postcard::{Deserializer, Serializer};
-    use serde::{de::DeserializeSeed, Serialize};
-
-    let mut app = App::new();
-    app.add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins));
-    app.add_server_event_with(Channel::Ordered, serialize_reflect, deserialize_reflect);
-
-    fn serialize_reflect(
-        ctx: &mut ServerSendCtx,
-        event: &ReflectEvent,
-        message: &mut Vec<u8>,
-    ) -> Result<()> {
-        let mut serializer = Serializer { output: ExtendMutFlavor::new(message) };
-        let registry = ctx.type_registry.read();
-        ReflectSerializer::new(&*event.0, &registry).serialize(&mut serializer)?;
-        Ok(())
-    }
-
-    fn deserialize_reflect(
-        ctx: &mut ClientReceiveCtx,
-        message: &mut Bytes,
-    ) -> Result<ReflectEvent> {
-        let mut deserializer = Deserializer::from_flavor(BufFlavor::new(message));
-        let registry = ctx.type_registry.read();
-        let reflect = ReflectDeserializer::new(&registry).deserialize(&mut deserializer)?;
-        Ok(ReflectEvent(reflect))
-    }
-
-    #[derive(Event)]
-    struct ReflectEvent(Box<dyn PartialReflect>);
-    ```
-
-    See also [`AppRuleExt::replicate_with`] for more examples with custom ser/de.
-    */
-    fn add_server_event_with<E: Event>(
-        &mut self,
-        channel: Channel,
-        serialize: EventSerializeFn<ServerSendCtx, E>,
-        deserialize: EventDeserializeFn<ClientReceiveCtx, E>,
-    ) -> &mut Self;
-
-    /// Marks the event `E` as an independent event.
-    ///
-    /// By default, all server events are buffered on server until server tick
-    /// and queued on client until all insertions, removals and despawns
-    /// (value mutations doesn't count) are replicated for the tick on which the
-    /// event was triggered. This is necessary to ensure that the executed logic
-    /// during the event does not affect components or entities that the client
-    /// has not yet received.
-    ///
-    /// For more details about replication see the documentation on
-    /// [`ServerChannel`](crate::shared::backend::channels::ServerChannel).
-    ///
-    /// However, if you know your event doesn't rely on that, you can mark it
-    /// as independent to always emit it immediately. For example, a chat
-    /// message event - which does not hold references to any entities - may be
-    /// marked as independent.
-    ///
-    /// <div class="warning">
-    ///
-    /// Use this method very carefully; it can lead to logic errors that are
-    /// very difficult to debug!
-    ///
-    /// </div>
-    ///
-    /// See also [`ServerTriggerAppExt::make_event_independent`](crate::shared::event::server_trigger::ServerTriggerAppExt::make_trigger_independent).
-    fn make_event_independent<E: Event>(&mut self) -> &mut Self;
-}
-
-impl ServerEventAppExt for App {
-    fn add_server_event_with<E: Event>(
-        &mut self,
-        channel: Channel,
-        serialize: EventSerializeFn<ServerSendCtx, E>,
-        deserialize: EventDeserializeFn<ClientReceiveCtx, E>,
-    ) -> &mut Self {
-        self.world_mut()
-            .resource_mut::<ProtocolHasher>()
-            .add_server_event::<E>();
-
-        let event_fns = EventFns::new(serialize, deserialize);
-        let event = ServerEvent::new(self, channel, event_fns);
-        let mut event_registry = self.world_mut().resource_mut::<RemoteEventRegistry>();
-        event_registry.register_server_event(event);
-
-        self
-    }
-
-    fn make_event_independent<E: Event>(&mut self) -> &mut Self {
-        self.world_mut()
-            .resource_mut::<ProtocolHasher>()
-            .make_event_independent::<E>();
-
-        let events_id = self
-            .world()
-            .components()
-            .resource_id::<Events<E>>()
-            .unwrap_or_else(|| {
-                panic!(
-                    "event `{}` should be previously registered",
-                    any::type_name::<E>()
-                )
-            });
-
-        let mut event_registry = self.world_mut().resource_mut::<RemoteEventRegistry>();
-        let event = event_registry
-            .iter_server_events_mut()
-            .find(|event| event.events_id() == events_id)
-            .unwrap_or_else(|| {
-                panic!(
-                    "event `{}` should be previously registered as a server event",
-                    any::type_name::<E>()
-                )
-            });
-
-        event.independent = true;
-
-        self
-    }
-}
-
-/// Type-erased functions and metadata for a registered server event.
-///
-/// Needed so events of different types can be processed together.
-pub(crate) struct ServerEvent {
-    /// Whether this event depends on replication or not.
-    ///
-    /// Events like a chat message event do not have to wait for replication to
-    /// be synced. If set to `true`, the event will always be applied
-    /// immediately.
-    pub(super) independent: bool,
-
-    /// ID of [`Events<E>`].
-    events_id: ComponentId,
-
-    /// ID of [`Events<ToClients<E>>`].
-    server_events_id: ComponentId,
-
-    /// ID of [`EventQueue<T>`].
-    queue_id: ComponentId,
-
-    /// Used channel.
-    channel_id: usize,
-
-    /// ID of `E`.
-    type_id: TypeId,
-
-    send_or_buffer: SendOrBufferFn,
-    receive: ReceiveFn,
-    resend_locally: ResendLocallyFn,
-    reset: ResetFn,
-    event_fns: UntypedEventFns,
-}
-
-impl ServerEvent {
-    pub(super) fn new<E: Event, I: 'static>(
-        app: &mut App,
-        channel: Channel,
-        event_fns: EventFns<ServerSendCtx, ClientReceiveCtx, E, I>,
-    ) -> Self {
-        let channel_id = app
-            .world_mut()
-            .resource_mut::<RepliconChannels>()
-            .create_server_channel(channel);
-
-        app.add_event::<E>()
-            .add_event::<ToClients<E>>()
-            .init_resource::<EventQueue<E>>();
-
-        let events_id = app.world().resource_id::<Events<E>>().unwrap();
-        let server_events_id = app.world().resource_id::<Events<ToClients<E>>>().unwrap();
-        let queue_id = app.world().resource_id::<EventQueue<E>>().unwrap();
-
-        Self {
-            independent: false,
-            events_id,
-            server_events_id,
-            queue_id,
-            channel_id,
-            type_id: TypeId::of::<E>(),
-            send_or_buffer: Self::send_or_buffer_typed::<E, I>,
-            receive: Self::receive_typed::<E, I>,
-            resend_locally: Self::resend_locally_typed::<E>,
-            reset: Self::reset_typed::<E>,
-            event_fns: event_fns.into(),
-        }
-    }
-
-    pub(crate) fn events_id(&self) -> ComponentId {
-        self.events_id
-    }
-
-    pub(crate) fn server_events_id(&self) -> ComponentId {
-        self.server_events_id
-    }
-
-    pub(crate) fn queue_id(&self) -> ComponentId {
-        self.queue_id
-    }
-
-    pub(super) fn channel_id(&self) -> usize {
-        self.channel_id
-    }
-
-    pub(super) fn type_id(&self) -> TypeId {
-        self.type_id
-    }
-
-    /// Sends an event to client(s).
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `server_events` is [`Events<ToClients<E>>`]
-    /// and this instance was created for `E`.
-    pub(crate) unsafe fn send_or_buffer(
-        &self,
-        ctx: &mut ServerSendCtx,
-        server_events: &Ptr,
-        messages: &mut ServerMessages,
-        clients: &Query<Entity, With<ConnectedClient>>,
-        event_buffer: &mut EventBuffer,
-    ) {
-        unsafe { (self.send_or_buffer)(self, ctx, server_events, messages, clients, event_buffer) }
-    }
-
-    /// Typed version of [`Self::send_or_buffer`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `server_events` is [`Events<ToClients<E>>`]
-    /// and this instance was created for `E` and `I`.
-    unsafe fn send_or_buffer_typed<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ServerSendCtx,
-        server_events: &Ptr,
-        messages: &mut ServerMessages,
-        clients: &Query<Entity, With<ConnectedClient>>,
-        event_buffer: &mut EventBuffer,
-    ) {
-        let events: &Events<ToClients<E>> = unsafe { server_events.deref() };
-        // For server events we don't track read events because
-        // all of them will always be drained in the local resending system.
-        for ToClients { event, mode } in events.get_cursor().read(events) {
-            debug!("sending event `{}` with `{mode:?}`", any::type_name::<E>());
-
-            if self.independent {
-                unsafe {
-                    self.send_independent_event::<E, I>(ctx, event, mode, messages, clients)
-                        .expect("independent server event should be serializable");
-                }
-            } else {
-                unsafe {
-                    self.buffer_event::<E, I>(ctx, event, *mode, event_buffer)
-                        .expect("server event should be serializable");
-                }
-            }
-        }
-    }
-
-    /// Sends independent event `E` based on a mode.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that this instance was created for `E` and `I`.
-    ///
-    /// For regular events see [`Self::buffer_event`].
-    unsafe fn send_independent_event<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ServerSendCtx,
-        event: &E,
-        mode: &SendMode,
-        messages: &mut ServerMessages,
-        clients: &Query<Entity, With<ConnectedClient>>,
-    ) -> Result<()> {
-        let mut message = Vec::new();
-        unsafe { self.serialize::<E, I>(ctx, event, &mut message)? }
-        let message: Bytes = message.into();
-
-        match *mode {
-            SendMode::Broadcast => {
-                for client_entity in clients {
-                    messages.send(client_entity, self.channel_id, message.clone());
-                }
-            }
-            SendMode::BroadcastExcept(ignored_id) => {
-                for client in clients {
-                    if ignored_id != client.into() {
-                        messages.send(client, self.channel_id, message.clone());
-                    }
-                }
-            }
-            SendMode::Direct(client_id) => {
-                if let ClientId::Client(client) = client_id {
-                    messages.send(client, self.channel_id, message.clone());
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Buffers event `E` based on a mode.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that this instance was created for `E` and `I`.
-    ///
-    /// For independent events see [`Self::send_independent_event`].
-    unsafe fn buffer_event<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ServerSendCtx,
-        event: &E,
-        mode: SendMode,
-        event_buffer: &mut EventBuffer,
-    ) -> Result<()> {
-        let message = unsafe { self.serialize_with_padding::<E, I>(ctx, event)? };
-        event_buffer.insert(mode, self.channel_id, message);
-        Ok(())
-    }
-
-    /// Helper for serializing a server event.
-    ///
-    /// Will prepend padding bytes for where the update tick will be inserted to the injected message.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that this instance was created for `E` and `I`.
-    unsafe fn serialize_with_padding<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ServerSendCtx,
-        event: &E,
-    ) -> Result<SerializedMessage> {
-        let mut message = vec![0; RepliconTick::POSTCARD_MAX_SIZE]; // Padding for the tick.
-        unsafe { self.serialize::<E, I>(ctx, event, &mut message)? }
-        let message = SerializedMessage::Raw(message);
-
-        Ok(message)
-    }
-
-    /// Receives events from the server.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`], `queue` is [`EventQueue<E>`],
-    /// and this instance was created for `E`.
-    pub(crate) unsafe fn receive(
-        &self,
-        ctx: &mut ClientReceiveCtx,
-        events: PtrMut,
-        queue: PtrMut,
-        messages: &mut ClientMessages,
-        update_tick: RepliconTick,
-    ) {
-        unsafe { (self.receive)(self, ctx, events, queue, messages, update_tick) }
-    }
-
-    /// Typed version of [`ServerEvent::receive`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`], `queue` is [`EventQueue<E>`]
-    /// and this instance was created for `E` and `I`.
-    unsafe fn receive_typed<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ClientReceiveCtx,
-        events: PtrMut,
-        queue: PtrMut,
-        messages: &mut ClientMessages,
-        update_tick: RepliconTick,
-    ) {
-        let events: &mut Events<E> = unsafe { events.deref_mut() };
-        let queue: &mut EventQueue<E> = unsafe { queue.deref_mut() };
-
-        while let Some((tick, messages)) = queue.pop_if_le(update_tick) {
-            for mut message in messages {
-                match unsafe { self.deserialize::<E, I>(ctx, &mut message) } {
-                    Ok(event) => {
-                        debug!(
-                            "applying event `{}` from queue with `{tick:?}`",
-                            any::type_name::<E>()
-                        );
-                        events.send(event);
-                    }
-                    Err(e) => error!(
-                        "ignoring event `{}` from queue with `{tick:?}` that failed to deserialize: {e}",
-                        any::type_name::<E>()
-                    ),
-                }
-            }
-        }
-
-        for mut message in messages.receive(self.channel_id) {
-            if !self.independent {
-                let tick = match postcard_utils::from_buf(&mut message) {
-                    Ok(tick) => tick,
-                    Err(e) => {
-                        error!(
-                            "ignoring event `{}` because it's tick failed to deserialize: {e}",
-                            any::type_name::<E>()
-                        );
-                        continue;
-                    }
-                };
-                if tick > update_tick {
-                    debug!("queuing event `{}` with `{tick:?}`", any::type_name::<E>());
-                    queue.insert(tick, message);
-                    continue;
-                } else {
-                    debug!(
-                        "receiving event `{}` with `{tick:?}`",
-                        any::type_name::<E>()
-                    );
-                }
-            }
-
-            match unsafe { self.deserialize::<E, I>(ctx, &mut message) } {
-                Ok(event) => {
-                    debug!("applying event `{}`", any::type_name::<E>());
-                    events.send(event);
-                }
-                Err(e) => error!(
-                    "ignoring event `{}` that failed to deserialize: {e}",
-                    any::type_name::<E>()
-                ),
-            }
-        }
-    }
-
-    /// Drains events [`ToClients<E>`] and re-emits them as `E` if the server is in the list of the event recipients.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`], `server_events` is [`Events<ToClients<E>>`],
-    /// and this instance was created for `E`.
-    pub(crate) unsafe fn resend_locally(&self, server_events: PtrMut, events: PtrMut) {
-        unsafe { (self.resend_locally)(server_events, events) }
-    }
-
-    /// Typed version of [`Self::resend_locally`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<E>`] and `server_events` is [`Events<ToClients<E>>`].
-    unsafe fn resend_locally_typed<E: Event>(server_events: PtrMut, events: PtrMut) {
-        let server_events: &mut Events<ToClients<E>> = unsafe { server_events.deref_mut() };
-        let events: &mut Events<E> = unsafe { events.deref_mut() };
-        for ToClients { event, mode } in server_events.drain() {
-            debug!("resending event `{}` locally", any::type_name::<E>());
-            match mode {
-                SendMode::Broadcast => {
-                    events.send(event);
-                }
-                SendMode::BroadcastExcept(ignored_id) => {
-                    if ignored_id != ClientId::Server {
-                        events.send(event);
-                    }
-                }
-                SendMode::Direct(client_id) => {
-                    if client_id == ClientId::Server {
-                        events.send(event);
-                    }
-                }
-            }
-        }
-    }
-
-    /// Clears queued events.
-    ///
-    /// We clear events while waiting for a connection to ensure clean reconnects.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `queue` is [`Events<E>`]
-    /// and this instance was created for `E`.
-    pub(crate) unsafe fn reset(&self, queue: PtrMut) {
-        unsafe { (self.reset)(queue) }
-    }
-
-    /// Typed version of [`Self::reset`].
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `queue` is [`Events<E>`].
-    unsafe fn reset_typed<E: Event>(queue: PtrMut) {
-        let queue: &mut EventQueue<E> = unsafe { queue.deref_mut() };
-        if !queue.is_empty() {
-            warn!(
-                "discarding {} queued events due to a disconnect",
-                queue.len()
-            );
-        }
-        queue.clear();
-    }
-
-    /// Serializes an event into a message.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that this instance was created for `E` and `I`.
-    unsafe fn serialize<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ServerSendCtx,
-        event: &E,
-        message: &mut Vec<u8>,
-    ) -> Result<()> {
-        unsafe {
-            self.event_fns
-                .typed::<ServerSendCtx, ClientReceiveCtx, E, I>()
-                .serialize(ctx, event, message)
-        }
-    }
-
-    /// Deserializes an event from a message.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that this instance was created for `E` and `I`.
-    unsafe fn deserialize<E: Event, I: 'static>(
-        &self,
-        ctx: &mut ClientReceiveCtx,
-        message: &mut Bytes,
-    ) -> Result<E> {
-        let event = unsafe {
-            self.event_fns
-                .typed::<ServerSendCtx, ClientReceiveCtx, E, I>()
-                .deserialize(ctx, message)?
-        };
-
-        if ctx.invalid_entities.is_empty() {
-            Ok(event)
-        } else {
-            let msg = format!(
-                "unable to map entities `{:?}` from the server, \
-                make sure that the event references entities visible to the client",
-                ctx.invalid_entities
-            );
-            ctx.invalid_entities.clear();
-            Err(msg.into())
-        }
-    }
-}
-
-/// Signature of server event sending functions.
-type SendOrBufferFn = unsafe fn(
-    &ServerEvent,
-    &mut ServerSendCtx,
-    &Ptr,
-    &mut ServerMessages,
-    &Query<Entity, With<ConnectedClient>>,
-    &mut EventBuffer,
-);
-
-/// Signature of server event receiving functions.
-type ReceiveFn = unsafe fn(
-    &ServerEvent,
-    &mut ClientReceiveCtx,
-    PtrMut,
-    PtrMut,
-    &mut ClientMessages,
-    RepliconTick,
-);
-
-/// Signature of server event resending functions.
-type ResendLocallyFn = unsafe fn(PtrMut, PtrMut);
-
-/// Signature of server event reset functions.
-type ResetFn = unsafe fn(PtrMut);
-
-/// 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 event sending.
-#[derive(Clone, Copy, Debug)]
-pub enum SendMode {
-    /// Send to every client.
-    Broadcast,
-    /// Send to every client except the specified connected client.
-    BroadcastExcept(ClientId),
-    /// Send only to the specified client.
-    Direct(ClientId),
-}
-
-/// Default event serialization function.
-pub fn default_serialize<E: Event + Serialize>(
-    _ctx: &mut ServerSendCtx,
-    event: &E,
-    message: &mut Vec<u8>,
-) -> Result<()> {
-    postcard_utils::to_extend_mut(event, message)?;
-    Ok(())
-}
-
-/// Default event deserialization function.
-pub fn default_deserialize<E: Event + DeserializeOwned>(
-    _ctx: &mut ClientReceiveCtx,
-    message: &mut Bytes,
-) -> Result<E> {
-    let event = postcard_utils::from_buf(message)?;
-    Ok(event)
-}
-
-/// Default event deserialization function.
-pub fn default_deserialize_mapped<E: Event + DeserializeOwned + MapEntities>(
-    ctx: &mut ClientReceiveCtx,
-    bytes: &mut Bytes,
-) -> Result<E> {
-    let mut event: E = postcard_utils::from_buf(bytes)?;
-    event.map_entities(ctx);
-
-    Ok(event)
-}
diff --git a/src/shared/event/server_trigger.rs b/src/shared/event/server_trigger.rs
deleted file mode 100644
index a482704a..00000000
--- a/src/shared/event/server_trigger.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-use core::any;
-
-use bevy::{ecs::entity::MapEntities, prelude::*, ptr::PtrMut};
-use bytes::Bytes;
-use log::debug;
-use serde::{Serialize, de::DeserializeOwned};
-
-use super::{
-    ctx::{ClientReceiveCtx, ServerSendCtx},
-    event_fns::{EventDeserializeFn, EventFns, EventSerializeFn},
-    registry::RemoteEventRegistry,
-    remote_targets::RemoteTargets,
-    server_event::{self, ServerEvent},
-};
-use crate::{postcard_utils, prelude::*};
-
-/// An extension trait for [`App`] for creating server triggers.
-///
-/// See also [`ServerTriggerExt`] for triggering, [`ClientTriggerAppExt`] for client triggers
-/// and [`ServerEventAppExt`] for events.
-pub trait ServerTriggerAppExt {
-    /// Registers a remote event that can be triggered using [`ServerTriggerExt::server_trigger`].
-    ///
-    /// After triggering [`ToClients<E>`] event on the server, `E` event will be triggered on clients.
-    ///
-    /// If [`ClientEventPlugin`] is enabled and [`ClientId::Server`] is a recipient of the event
-    /// (not to be confused with trigger target), then `E` event will be emitted on the server as well.
-    ///
-    /// See also the [corresponding section](../index.html#from-client-to-server) from the quick start guide.
-    fn add_server_trigger<E: Event + Serialize + DeserializeOwned>(
-        &mut self,
-        channel: Channel,
-    ) -> &mut Self {
-        self.add_server_trigger_with(
-            channel,
-            server_event::default_serialize::<E>,
-            server_event::default_deserialize::<E>,
-        )
-    }
-
-    /// Same as [`Self::add_server_trigger`], but additionally maps client entities to server inside the event before receiving.
-    ///
-    /// Always use it for events that contain entities. Entities must be annotated with `#[entities]`.
-    /// For details, see [`Component::map_entities`].
-    fn add_mapped_server_trigger<E: Event + Serialize + DeserializeOwned + MapEntities>(
-        &mut self,
-        channel: Channel,
-    ) -> &mut Self {
-        self.add_server_trigger_with(
-            channel,
-            server_event::default_serialize::<E>,
-            server_event::default_deserialize_mapped::<E>,
-        )
-    }
-
-    /// Same as [`Self::add_server_trigger`], but uses the specified functions for serialization and deserialization.
-    ///
-    /// See also [`ServerEventAppExt::add_server_event_with`].
-    fn add_server_trigger_with<E: Event>(
-        &mut self,
-        channel: Channel,
-        serialize: EventSerializeFn<ServerSendCtx, E>,
-        deserialize: EventDeserializeFn<ClientReceiveCtx, E>,
-    ) -> &mut Self;
-
-    /// Like [`ServerEventAppExt::make_event_independent`], but for triggers.
-    fn make_trigger_independent<E: Event>(&mut self) -> &mut Self;
-}
-
-impl ServerTriggerAppExt for App {
-    fn add_server_trigger_with<E: Event>(
-        &mut self,
-        channel: Channel,
-        serialize: EventSerializeFn<ServerSendCtx, E>,
-        deserialize: EventDeserializeFn<ClientReceiveCtx, E>,
-    ) -> &mut Self {
-        self.world_mut()
-            .resource_mut::<ProtocolHasher>()
-            .add_server_trigger::<E>();
-
-        let event_fns = EventFns::new(serialize, deserialize)
-            .with_outer(trigger_serialize, trigger_deserialize);
-        let trigger = ServerTrigger::new(self, channel, event_fns);
-        let mut event_registry = self.world_mut().resource_mut::<RemoteEventRegistry>();
-        event_registry.register_server_trigger(trigger);
-
-        self
-    }
-
-    fn make_trigger_independent<E: Event>(&mut self) -> &mut Self {
-        self.world_mut()
-            .resource_mut::<ProtocolHasher>()
-            .make_trigger_independent::<E>();
-
-        let events_id = self
-            .world()
-            .components()
-            .resource_id::<Events<ServerTriggerEvent<E>>>()
-            .unwrap_or_else(|| {
-                panic!(
-                    "event `{}` should be previously registered",
-                    any::type_name::<E>()
-                )
-            });
-
-        let mut event_registry = self.world_mut().resource_mut::<RemoteEventRegistry>();
-        let trigger = event_registry
-            .iter_server_triggers_mut()
-            .find(|trigger| trigger.event().events_id() == events_id)
-            .unwrap_or_else(|| {
-                panic!(
-                    "event `{}` should be previously registered as a server trigger",
-                    any::type_name::<E>()
-                )
-            });
-
-        trigger.event_mut().independent = true;
-
-        self
-    }
-}
-
-/// Small abstraction on top of [`ServerEvent`] that stores a function to trigger them.
-pub(crate) struct ServerTrigger {
-    trigger: TriggerFn,
-    event: ServerEvent,
-}
-
-impl ServerTrigger {
-    fn new<E: Event>(
-        app: &mut App,
-        channel: Channel,
-        event_fns: EventFns<ServerSendCtx, ClientReceiveCtx, ServerTriggerEvent<E>, E>,
-    ) -> Self {
-        let event = ServerEvent::new(app, channel, event_fns);
-        Self {
-            trigger: Self::trigger_typed::<E>,
-            event,
-        }
-    }
-
-    pub(crate) fn trigger(&self, commands: &mut Commands, events: PtrMut) {
-        unsafe {
-            (self.trigger)(commands, events);
-        }
-    }
-
-    /// Drains received [`TriggerEvent<E>`] events and triggers them as `E`.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `events` is [`Events<TriggerEvent<E>>`]
-    /// and this instance was created for `E`.
-    unsafe fn trigger_typed<E: Event>(commands: &mut Commands, events: PtrMut) {
-        let events: &mut Events<ServerTriggerEvent<E>> = unsafe { events.deref_mut() };
-        for trigger in events.drain() {
-            debug!("triggering `{}`", any::type_name::<E>());
-            commands.trigger_targets(trigger.event, trigger.targets);
-        }
-    }
-
-    pub(crate) fn event(&self) -> &ServerEvent {
-        &self.event
-    }
-
-    pub(super) fn event_mut(&mut self) -> &mut ServerEvent {
-        &mut self.event
-    }
-}
-
-/// Signature of server trigger functions.
-type TriggerFn = unsafe fn(&mut Commands, PtrMut);
-
-/// Serializes targets for [`TriggerEvent`] and delegates the event
-/// serialiaztion to `serialize`.
-///
-/// Used as outer function for [`EventFns`].
-fn trigger_serialize<'a, E>(
-    ctx: &mut ServerSendCtx<'a>,
-    trigger: &ServerTriggerEvent<E>,
-    message: &mut Vec<u8>,
-    serialize: EventSerializeFn<ServerSendCtx<'a>, E>,
-) -> Result<()> {
-    postcard_utils::to_extend_mut(&trigger.targets.len(), message)?;
-    for entity in &trigger.targets {
-        postcard_utils::entity_to_extend_mut(entity, message)?;
-    }
-
-    (serialize)(ctx, &trigger.event, message)
-}
-
-/// Deserializes targets for [`TriggerEvent`] and delegates the event
-/// deserialiaztion to `deserialize`.
-///
-/// Used as outer function for [`EventFns`].
-fn trigger_deserialize<'a, E>(
-    ctx: &mut ClientReceiveCtx<'a>,
-    message: &mut Bytes,
-    deserialize: EventDeserializeFn<ClientReceiveCtx<'a>, E>,
-) -> Result<ServerTriggerEvent<E>> {
-    let len = postcard_utils::from_buf(message)?;
-    let mut targets = Vec::with_capacity(len);
-    for _ in 0..len {
-        let entity = postcard_utils::entity_from_buf(message)?;
-        targets.push(ctx.get_mapped(entity));
-    }
-
-    let event = (deserialize)(ctx, message)?;
-
-    Ok(ServerTriggerEvent { event, targets })
-}
-
-/// Extension trait for triggering server events.
-///
-/// See also [`ServerTriggerAppExt`].
-pub trait ServerTriggerExt {
-    /// Like [`Commands::trigger`], but triggers `E` on server and locally
-    /// if [`ClientId::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
-    /// [`Commands::trigger_targets`].
-    fn server_trigger_targets(&mut self, event: ToClients<impl Event>, targets: impl RemoteTargets);
-}
-
-impl ServerTriggerExt for Commands<'_, '_> {
-    fn server_trigger(&mut self, event: ToClients<impl Event>) {
-        self.server_trigger_targets(event, []);
-    }
-
-    fn server_trigger_targets(
-        &mut self,
-        event: ToClients<impl Event>,
-        targets: impl RemoteTargets,
-    ) {
-        self.send_event(ToClients {
-            mode: event.mode,
-            event: ServerTriggerEvent {
-                event: event.event,
-                targets: targets.into_entities(),
-            },
-        });
-    }
-}
-
-impl ServerTriggerExt for World {
-    fn server_trigger(&mut self, event: ToClients<impl Event>) {
-        self.server_trigger_targets(event, []);
-    }
-
-    fn server_trigger_targets(
-        &mut self,
-        event: ToClients<impl Event>,
-        targets: impl RemoteTargets,
-    ) {
-        self.send_event(ToClients {
-            mode: event.mode,
-            event: ServerTriggerEvent {
-                event: event.event,
-                targets: targets.into_entities(),
-            },
-        });
-    }
-}
-
-/// An event that used under the hood for server triggers.
-///
-/// We can't just observe for triggers like we do for events since we need access to all its targets
-/// and we need to buffer them. This is why we just emit this event instead and after receive drain it
-/// to trigger regular events.
-#[derive(Event)]
-struct ServerTriggerEvent<E> {
-    event: E,
-    targets: Vec<Entity>,
-}
diff --git a/src/shared/message.rs b/src/shared/message.rs
new file mode 100644
index 00000000..6e69747d
--- /dev/null
+++ b/src/shared/message.rs
@@ -0,0 +1,7 @@
+pub mod client_event;
+pub mod client_message;
+pub mod ctx;
+pub mod message_fns;
+pub mod registry;
+pub mod server_event;
+pub mod server_message;
diff --git a/src/shared/message/client_event.rs b/src/shared/message/client_event.rs
new file mode 100644
index 00000000..6bc0b0c4
--- /dev/null
+++ b/src/shared/message/client_event.rs
@@ -0,0 +1,187 @@
+use core::any::{self, TypeId};
+
+use bevy::{ecs::entity::MapEntities, prelude::*, ptr::PtrMut};
+use log::debug;
+use serde::{Serialize, de::DeserializeOwned};
+
+use super::{
+    client_message::{self, ClientMessage},
+    ctx::{ClientSendCtx, ServerReceiveCtx},
+    message_fns::{DeserializeFn, MessageFns, SerializeFn},
+    registry::RemoteMessageRegistry,
+};
+use crate::prelude::*;
+
+/// An extension trait for [`App`] for creating client events.
+///
+/// See also [`ClientTriggerExt`] for triggering, [`ServerEventAppExt`] for server events
+/// and [`ClientMessageAppExt`] for messages.
+pub trait ClientEventAppExt {
+    /// Registers a remote event that can be triggered using [`ClientTriggerExt::client_trigger`].
+    ///
+    /// After triggering `E` event on the client, [`FromClient<E>`] event will be triggered on the server.
+    ///
+    /// If [`ServerMessagePlugin`] is enabled and the client state is [`ClientState::Disconnected`], the event will also be triggered
+    /// locally as [`FromClient<E>`] event with [`FromClient::client_id`] equal to [`ClientId::Server`].
+    ///
+    /// See also the [corresponding section](../index.html#from-client-to-server) from the quick start guide.
+    fn add_client_event<E: Event + Serialize + DeserializeOwned>(
+        &mut self,
+        channel: Channel,
+    ) -> &mut Self {
+        self.add_client_event_with(
+            channel,
+            client_message::default_serialize::<E>,
+            client_message::default_deserialize::<E>,
+        )
+    }
+
+    /// Same as [`Self::add_client_event`], but additionally maps client entities to server inside the event before sending.
+    ///
+    /// Always use it for events that contain entities. Entities must be annotated with `#[entities]`.
+    /// For details, see [`Component::map_entities`].
+    fn add_mapped_client_event<E: Event + Serialize + DeserializeOwned + MapEntities + Clone>(
+        &mut self,
+        channel: Channel,
+    ) -> &mut Self {
+        self.add_client_event_with(
+            channel,
+            client_message::default_serialize_mapped::<E>,
+            client_message::default_deserialize::<E>,
+        )
+    }
+
+    /// Same as [`Self::add_client_event`], but uses the specified functions for serialization and deserialization.
+    ///
+    /// See also [`ClientMessageAppExt::add_client_message_with`].
+    fn add_client_event_with<E: Event>(
+        &mut self,
+        channel: Channel,
+        serialize: SerializeFn<ClientSendCtx, E>,
+        deserialize: DeserializeFn<ServerReceiveCtx, E>,
+    ) -> &mut Self;
+}
+
+impl ClientEventAppExt for App {
+    fn add_client_event_with<E: Event>(
+        &mut self,
+        channel: Channel,
+        serialize: SerializeFn<ClientSendCtx, E>,
+        deserialize: DeserializeFn<ServerReceiveCtx, E>,
+    ) -> &mut Self {
+        self.world_mut()
+            .resource_mut::<ProtocolHasher>()
+            .add_client_event::<E>();
+
+        let fns = MessageFns::new(serialize, deserialize).with_convert::<ClientMessageEvent<E>>();
+        let event = ClientEvent::new(self, channel, fns);
+        let mut registry = self.world_mut().resource_mut::<RemoteMessageRegistry>();
+        registry.register_client_event(event);
+
+        self
+    }
+}
+
+/// Small abstraction on top of [`ClientEvent`] that stores a function to trigger them.
+pub(crate) struct ClientEvent {
+    type_id: TypeId,
+    message: ClientMessage,
+    trigger: TriggerFn,
+}
+
+impl ClientEvent {
+    fn new<E: Event>(
+        app: &mut App,
+        channel: Channel,
+        fns: MessageFns<ClientSendCtx, ServerReceiveCtx, ClientMessageEvent<E>, E>,
+    ) -> Self {
+        Self {
+            type_id: TypeId::of::<E>(),
+            message: ClientMessage::new(app, channel, fns),
+            trigger: Self::trigger_typed::<E>,
+        }
+    }
+
+    /// Drains received [`FromClient<TriggerEvent<E>>`] messages and triggers them as [`FromClient<E>`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<FromClient<ClientMessageEvent<E>>>`]
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn trigger(&self, commands: &mut Commands, from_messages: PtrMut) {
+        unsafe { (self.trigger)(commands, from_messages) }
+    }
+
+    /// Typed version of [`Self::trigger`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<FromClient<ClientMessageEvent<E>>>`].
+    unsafe fn trigger_typed<E: Event>(commands: &mut Commands, from_messages: PtrMut) {
+        let from_messages: &mut Messages<FromClient<ClientMessageEvent<E>>> =
+            unsafe { from_messages.deref_mut() };
+        for FromClient { client_id, message } in from_messages.drain() {
+            debug!(
+                "triggering `{}` from `{client_id}`",
+                any::type_name::<FromClient<E>>()
+            );
+            commands.trigger(FromClient {
+                client_id,
+                message: message.event,
+            });
+        }
+    }
+
+    pub(super) fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    pub(crate) fn message(&self) -> &ClientMessage {
+        &self.message
+    }
+}
+
+/// Signature of client trigger functions.
+type TriggerFn = unsafe fn(&mut Commands, PtrMut);
+
+/// Extension trait for triggering client events.
+///
+/// See also [`ClientEventAppExt`].
+pub trait ClientTriggerExt {
+    /// Like [`Commands::trigger`], but triggers [`FromClient`] on server and locally if the client state is [`ClientState::Disconnected`].
+    fn client_trigger(&mut self, event: impl Event);
+}
+
+impl ClientTriggerExt for Commands<'_, '_> {
+    fn client_trigger(&mut self, event: impl Event) {
+        self.write_message(ClientMessageEvent { event });
+    }
+}
+
+impl ClientTriggerExt for World {
+    fn client_trigger(&mut self, event: impl Event) {
+        self.write_message(ClientMessageEvent { event });
+    }
+}
+
+/// A message that used under the hood for client events.
+///
+/// Events are implemented through messages in order to reuse their logic.
+/// So we send this message instead and, after receiving it, drain it to trigger regular events.
+/// This also allows us to avoid requiring [`Clone`] because events can't be drained.
+#[derive(Message)]
+struct ClientMessageEvent<E> {
+    event: E,
+}
+
+impl<E> From<E> for ClientMessageEvent<E> {
+    fn from(event: E) -> Self {
+        Self { event }
+    }
+}
+
+impl<E> AsRef<E> for ClientMessageEvent<E> {
+    fn as_ref(&self) -> &E {
+        &self.event
+    }
+}
diff --git a/src/shared/message/client_message.rs b/src/shared/message/client_message.rs
new file mode 100644
index 00000000..5c3a0f58
--- /dev/null
+++ b/src/shared/message/client_message.rs
@@ -0,0 +1,498 @@
+use core::any::{self, TypeId};
+
+use bevy::{
+    ecs::{component::ComponentId, entity::MapEntities, message::MessageCursor},
+    prelude::*,
+    ptr::{Ptr, PtrMut},
+};
+use bytes::Bytes;
+use log::{debug, error, warn};
+use serde::{Serialize, de::DeserializeOwned};
+
+use super::{
+    ctx::{ClientSendCtx, ServerReceiveCtx},
+    message_fns::{DeserializeFn, MessageFns, SerializeFn, UntypedMessageFns},
+    registry::RemoteMessageRegistry,
+};
+use crate::{postcard_utils, prelude::*};
+
+/// An extension trait for [`App`] for creating client messages.
+///
+/// See also [`ServerMessageAppExt`] for server messages and [`ClientMessageAppExt`] for events.
+pub trait ClientMessageAppExt {
+    /// Registers a remote client message.
+    ///
+    /// After writing `E` message on the client, [`FromClient<E>`] message will be written on the server.
+    ///
+    /// If [`ServerMessagePlugin`] is enabled and the client state is [`ClientState::Disconnected`], the message will be drained
+    /// right after sending and will be written locally as [`FromClient<E>`] message with [`FromClient::client_id`]
+    /// equal to [`ClientId::Server`].
+    ///
+    /// Calling [`App::add_message`] is not necessary. Can used for regular messages that were
+    /// previously registered. But be careful, since on listen servers all messages `E` are drained,
+    /// which could break Bevy or third-party plugin systems that read `E`.
+    ///
+    /// See also the [corresponding section](../index.html#from-client-to-server) from the quick start guide.
+    fn add_client_message<E: Message + Serialize + DeserializeOwned>(
+        &mut self,
+        channel: Channel,
+    ) -> &mut Self {
+        self.add_client_message_with(channel, default_serialize::<E>, default_deserialize::<E>)
+    }
+
+    /// Same as [`Self::add_client_message`], but additionally maps client entities to server inside the message before sending.
+    ///
+    /// Always use it for messages that contain entities. Entities must be annotated with `#[entities]`.
+    /// For details, see [`Component::map_entities`].
+    ///
+    /// [`Clone`] is required because, before sending, we need to map entities from the client to the server without
+    /// modifying the original component.
+    fn add_mapped_client_message<E>(&mut self, channel: Channel) -> &mut Self
+    where
+        E: Message + Serialize + DeserializeOwned + MapEntities + Clone,
+    {
+        self.add_client_message_with(
+            channel,
+            default_serialize_mapped::<E>,
+            default_deserialize::<E>,
+        )
+    }
+
+    /**
+    Same as [`Self::add_client_message`], but uses the specified functions for serialization and deserialization.
+
+    See also [`postcard_utils`] and [`ClientEventAppExt::add_client_event_with`].
+
+    # Examples
+
+    Register a message with [`Box<dyn PartialReflect>`]:
+
+    ```
+    use bevy::{
+        prelude::*,
+        reflect::serde::{ReflectDeserializer, ReflectSerializer},
+        state::app::StatesPlugin,
+    };
+    use bevy_replicon::{
+        bytes::Bytes,
+        postcard_utils::{BufFlavor, ExtendMutFlavor},
+        shared::message::ctx::{ClientSendCtx, ServerReceiveCtx},
+        prelude::*,
+    };
+    use postcard::{Deserializer, Serializer};
+    use serde::{de::DeserializeSeed, Serialize};
+
+    let mut app = App::new();
+    app.add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins));
+    app.add_client_message_with(Channel::Ordered, serialize_dynamic, deserialize_dynamic);
+
+    fn serialize_dynamic(
+        ctx: &mut ClientSendCtx,
+        dynamic: &Dynamic,
+        message: &mut Vec<u8>,
+    ) -> Result<()> {
+        let mut serializer = Serializer { output: ExtendMutFlavor::new(message) };
+        let registry = ctx.type_registry.read();
+        ReflectSerializer::new(&*dynamic.0, &registry).serialize(&mut serializer)?;
+        Ok(())
+    }
+
+    fn deserialize_dynamic(
+        ctx: &mut ServerReceiveCtx,
+        message: &mut Bytes,
+    ) -> Result<Dynamic> {
+        let mut deserializer = Deserializer::from_flavor(BufFlavor::new(message));
+        let registry = ctx.type_registry.read();
+        let reflect = ReflectDeserializer::new(&registry).deserialize(&mut deserializer)?;
+        Ok(Dynamic(reflect))
+    }
+
+    #[derive(Message)]
+    struct Dynamic(Box<dyn PartialReflect>);
+    ```
+
+    See also [`AppRuleExt::replicate_with`] for more examples with custom ser/de.
+    */
+    fn add_client_message_with<E: Message>(
+        &mut self,
+        channel: Channel,
+        serialize: SerializeFn<ClientSendCtx, E>,
+        deserialize: DeserializeFn<ServerReceiveCtx, E>,
+    ) -> &mut Self;
+}
+
+impl ClientMessageAppExt for App {
+    fn add_client_message_with<E: Message>(
+        &mut self,
+        channel: Channel,
+        serialize: SerializeFn<ClientSendCtx, E>,
+        deserialize: DeserializeFn<ServerReceiveCtx, E>,
+    ) -> &mut Self {
+        self.world_mut()
+            .resource_mut::<ProtocolHasher>()
+            .add_client_message::<E>();
+
+        let fns = MessageFns::new(serialize, deserialize);
+        let message = ClientMessage::new(self, channel, fns);
+        let mut registry = self.world_mut().resource_mut::<RemoteMessageRegistry>();
+        registry.register_client_message(message);
+
+        self
+    }
+}
+
+/// Type-erased functions and metadata for a registered client messages.
+///
+/// Needed to erase message types to process them in a single system.
+pub(crate) struct ClientMessage {
+    /// ID of [`Messages<E>`] resource.
+    messages_id: ComponentId,
+
+    /// ID of [`ClientMessageReader<E>`] resource.
+    reader_id: ComponentId,
+
+    /// ID of [`Messages<FromClient<E>>`] resource.
+    from_messages_id: ComponentId,
+
+    /// Used channel.
+    channel_id: usize,
+
+    /// ID of `E`.
+    type_id: TypeId,
+
+    send: SendFn,
+    receive: ReceiveFn,
+    send_locally: SendLocallyFn,
+    reset: ResetFn,
+    fns: UntypedMessageFns,
+}
+
+impl ClientMessage {
+    pub(super) fn new<E: Message, I: 'static>(
+        app: &mut App,
+        channel: Channel,
+        fns: MessageFns<ClientSendCtx, ServerReceiveCtx, E, I>,
+    ) -> Self {
+        let channel_id = app
+            .world_mut()
+            .resource_mut::<RepliconChannels>()
+            .create_client_channel(channel);
+
+        app.add_message::<E>()
+            .add_message::<FromClient<E>>()
+            .init_resource::<ClientMessageReader<E>>();
+
+        let messages_id = app.world().resource_id::<Messages<E>>().unwrap();
+        let from_messages_id = app
+            .world()
+            .resource_id::<Messages<FromClient<E>>>()
+            .unwrap();
+        let reader_id = app.world().resource_id::<ClientMessageReader<E>>().unwrap();
+
+        Self {
+            messages_id,
+            reader_id,
+            from_messages_id,
+            channel_id,
+            type_id: TypeId::of::<E>(),
+            send: Self::send_typed::<E, I>,
+            receive: Self::receive_typed::<E, I>,
+            send_locally: Self::send_locally_typed::<E>,
+            reset: Self::reset_typed::<E>,
+            fns: fns.into(),
+        }
+    }
+
+    pub(crate) fn messages_id(&self) -> ComponentId {
+        self.messages_id
+    }
+
+    pub(crate) fn reader_id(&self) -> ComponentId {
+        self.reader_id
+    }
+
+    #[allow(
+        clippy::wrong_self_convention,
+        reason = "`from` stands for `FromClients`"
+    )]
+    pub(crate) fn from_messages_id(&self) -> ComponentId {
+        self.from_messages_id
+    }
+
+    pub(super) fn channel_id(&self) -> usize {
+        self.channel_id
+    }
+
+    pub(super) fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    /// Sends a message to the server.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`], `reader` is [`ClientMessageReader<E>`]
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn send(
+        &self,
+        ctx: &mut ClientSendCtx,
+        messages: &Ptr,
+        reader: PtrMut,
+        client_messages: &mut ClientMessages,
+    ) {
+        unsafe { (self.send)(self, ctx, messages, reader, client_messages) };
+    }
+
+    /// Typed version of [`Self::send`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`], `reader` is [`ClientMessageReader<E>`],
+    /// and this instance was created for `E` and `I`.
+    unsafe fn send_typed<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ClientSendCtx,
+        messages: &Ptr,
+        reader: PtrMut,
+        client_messages: &mut ClientMessages,
+    ) {
+        let reader: &mut ClientMessageReader<E> = unsafe { reader.deref_mut() };
+        let messages = unsafe { messages.deref() };
+        for message in reader.read(messages) {
+            let mut message_bytes = Vec::new();
+            if let Err(e) = unsafe { self.serialize::<E, I>(ctx, message, &mut message_bytes) } {
+                error!(
+                    "ignoring message `{}` that failed to serialize: {e}",
+                    any::type_name::<E>()
+                );
+                continue;
+            }
+
+            debug!("sending message `{}`", any::type_name::<E>());
+            client_messages.send(self.channel_id, message_bytes);
+        }
+    }
+
+    /// Receives messages from a client.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `from_messages` is [`Messages<FromClient<E>>`]
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn receive(
+        &self,
+        ctx: &mut ServerReceiveCtx,
+        from_messages: PtrMut,
+        server_messages: &mut ServerMessages,
+    ) {
+        unsafe { (self.receive)(self, ctx, from_messages, server_messages) }
+    }
+
+    /// Typed version of [`Self::receive`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `from_messages` is [`Messages<FromClient<E>>`]
+    /// and this instance was created for `E` and `I`.
+    unsafe fn receive_typed<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerReceiveCtx,
+        from_messages: PtrMut,
+        server_messages: &mut ServerMessages,
+    ) {
+        let from_messages: &mut Messages<FromClient<E>> = unsafe { from_messages.deref_mut() };
+        for (client, mut message) in server_messages.receive(self.channel_id) {
+            match unsafe { self.deserialize::<E, I>(ctx, &mut message) } {
+                Ok(message) => {
+                    debug!(
+                        "writing message `{}` from client `{client}`",
+                        any::type_name::<E>()
+                    );
+                    from_messages.write(FromClient {
+                        client_id: client.into(),
+                        message,
+                    });
+                }
+                Err(e) => debug!(
+                    "ignoring message `{}` from client `{client}` that failed to deserialize: {e}",
+                    any::type_name::<E>()
+                ),
+            }
+        }
+    }
+
+    /// Drains messages `E` and writes them as [`FromClient<E>`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`], `from_messages` is [`Messages<FromClient<E>>`]
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn send_locally(&self, from_messages: PtrMut, messages: PtrMut) {
+        unsafe { (self.send_locally)(from_messages, messages) }
+    }
+
+    /// Typed version of [`ClientMessage::send_locally`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`] and `from_messages` is [`Messages<FromClient<E>>`].
+    unsafe fn send_locally_typed<E: Message>(from_messages: PtrMut, messages: PtrMut) {
+        let from_messages: &mut Messages<FromClient<E>> = unsafe { from_messages.deref_mut() };
+        let messages: &mut Messages<E> = unsafe { messages.deref_mut() };
+        if !messages.is_empty() {
+            debug!(
+                "writing {} message(s) `{}` locally",
+                messages.len(),
+                any::type_name::<E>()
+            );
+            from_messages.write_batch(messages.drain().map(|message| FromClient {
+                client_id: ClientId::Server,
+                message,
+            }));
+        }
+    }
+
+    /// Drains all messages.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`]
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn reset(&self, messages: PtrMut) {
+        unsafe { (self.reset)(messages) }
+    }
+
+    /// Typed version of [`ClientMessage::reset`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`].
+    unsafe fn reset_typed<E: Message>(messages: PtrMut) {
+        let messages: &mut Messages<E> = unsafe { messages.deref_mut() };
+        let drained_count = messages.drain().count();
+        if drained_count > 0 {
+            warn!(
+                "discarded {drained_count} messages of type `{}` that were buffered before the connection",
+                any::type_name::<E>()
+            );
+        }
+    }
+
+    /// Serializes a message.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `E` and `I`.
+    unsafe fn serialize<E: 'static, I: 'static>(
+        &self,
+        ctx: &mut ClientSendCtx,
+        message: &E,
+        message_bytes: &mut Vec<u8>,
+    ) -> Result<()> {
+        unsafe {
+            self.fns
+                .typed::<ClientSendCtx, ServerReceiveCtx, E, I>()
+                .serialize(ctx, message, message_bytes)?;
+        }
+
+        if ctx.invalid_entities.is_empty() {
+            Ok(())
+        } else {
+            let error_text = format!(
+                "unable to map entities `{:?}` for the server, \
+                make sure that the message references entities visible to the server",
+                ctx.invalid_entities,
+            );
+            ctx.invalid_entities.clear();
+            Err(error_text.into())
+        }
+    }
+
+    /// Deserializes a message.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `E` and `I`.
+    unsafe fn deserialize<E: 'static, I: 'static>(
+        &self,
+        ctx: &mut ServerReceiveCtx,
+        message: &mut Bytes,
+    ) -> Result<E> {
+        unsafe {
+            self.fns
+                .typed::<ClientSendCtx, ServerReceiveCtx, E, I>()
+                .deserialize(ctx, message)
+        }
+    }
+}
+
+/// Signature of client message sending functions.
+type SendFn = unsafe fn(&ClientMessage, &mut ClientSendCtx, &Ptr, PtrMut, &mut ClientMessages);
+
+/// Signature of client message receiving functions.
+type ReceiveFn = unsafe fn(&ClientMessage, &mut ServerReceiveCtx, PtrMut, &mut ServerMessages);
+
+/// Signature of client message sending functions.
+type SendLocallyFn = unsafe fn(PtrMut, PtrMut);
+
+/// Signature of client message reset functions.
+type ResetFn = unsafe fn(PtrMut);
+
+/// Tracks read messages for [`ClientMessagePlugin::send`].
+///
+/// Unlike with server messages, we don't always drain all messages in [`ClientMessagePlugin::send_locally`].
+#[derive(Resource, Deref, DerefMut)]
+struct ClientMessageReader<E: Message>(MessageCursor<E>);
+
+impl<E: Message> FromWorld for ClientMessageReader<E> {
+    fn from_world(world: &mut World) -> Self {
+        let messages = world.resource::<Messages<E>>();
+        Self(messages.get_cursor())
+    }
+}
+
+/// A remote message from a client.
+///
+/// Emitted only on server.
+#[derive(Message, Event, Deref, DerefMut, Debug, Clone, Copy)]
+pub struct FromClient<T> {
+    /// Sender of the message.
+    ///
+    /// See also [`ConnectedClient`].
+    pub client_id: ClientId,
+
+    /// Transmitted message.
+    #[deref]
+    pub message: T,
+}
+
+/// Default message serialization function.
+pub fn default_serialize<E: Serialize>(
+    _ctx: &mut ClientSendCtx,
+    message: &E,
+    message_bytes: &mut Vec<u8>,
+) -> Result<()> {
+    postcard_utils::to_extend_mut(message, message_bytes)?;
+    Ok(())
+}
+
+/// Like [`default_serialize`], but also maps entities.
+pub fn default_serialize_mapped<E: MapEntities + Clone + Serialize>(
+    ctx: &mut ClientSendCtx,
+    message: &E,
+    message_bytes: &mut Vec<u8>,
+) -> Result<()> {
+    let mut message = message.clone();
+    message.map_entities(ctx);
+    postcard_utils::to_extend_mut(&message, message_bytes)?;
+    Ok(())
+}
+
+/// Default message deserialization function.
+pub fn default_deserialize<E: DeserializeOwned>(
+    _ctx: &mut ServerReceiveCtx,
+    message: &mut Bytes,
+) -> Result<E> {
+    let message = postcard_utils::from_buf(message)?;
+    Ok(message)
+}
diff --git a/src/shared/event/ctx.rs b/src/shared/message/ctx.rs
similarity index 92%
rename from src/shared/event/ctx.rs
rename to src/shared/message/ctx.rs
index 721afdfa..bd7247c0 100644
--- a/src/shared/event/ctx.rs
+++ b/src/shared/message/ctx.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 use crate::shared::server_entity_map::ServerEntityMap;
 
-/// Event sending context for client.
+/// Message sending context for client.
 #[non_exhaustive]
 pub struct ClientSendCtx<'a> {
     /// Registry of reflected types.
@@ -32,21 +32,21 @@ impl EntityMapper for ClientSendCtx<'_> {
     }
 }
 
-/// Event receiving context for server.
+/// Message receiving context for server.
 #[non_exhaustive]
 pub struct ServerReceiveCtx<'a> {
     /// Registry of reflected types.
     pub type_registry: &'a AppTypeRegistry,
 }
 
-/// Event sending context for server.
+/// Message sending context for server.
 #[non_exhaustive]
 pub struct ServerSendCtx<'a> {
     /// Registry of reflected types.
     pub type_registry: &'a AppTypeRegistry,
 }
 
-/// Event receiving context for client.
+/// Message receiving context for client.
 #[non_exhaustive]
 pub struct ClientReceiveCtx<'a> {
     /// Registry of reflected types.
diff --git a/src/shared/message/message_fns.rs b/src/shared/message/message_fns.rs
new file mode 100644
index 00000000..efbd7af2
--- /dev/null
+++ b/src/shared/message/message_fns.rs
@@ -0,0 +1,212 @@
+use alloc::vec::Vec;
+use core::{
+    any::{self, TypeId},
+    mem,
+};
+
+use bevy::prelude::*;
+use bytes::Bytes;
+
+/// Type-erased version of [`MessageFns`].
+///
+/// Stored inside messages after their creation.
+#[derive(Clone, Copy)]
+pub(super) struct UntypedMessageFns {
+    serialize_ctx_id: TypeId,
+    serialize_ctx_name: &'static str,
+    deserialize_ctx_id: TypeId,
+    deserialize_ctx_name: &'static str,
+    message_id: TypeId,
+    message_name: &'static str,
+    inner_id: TypeId,
+    inner_name: &'static str,
+
+    serialize_adapter: unsafe fn(),
+    deserialize_adapter: unsafe fn(),
+    serialize: unsafe fn(),
+    deserialize: unsafe fn(),
+}
+
+impl UntypedMessageFns {
+    /// Restores the original [`MessageFns`] from which this type was created.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the function is called with the same generics with which this instance was created.
+    pub(super) unsafe fn typed<S, D, E: 'static, I: 'static>(self) -> MessageFns<S, D, E, I> {
+        // `TypeId` can only be obtained for `'static` types, but we can't impose this requirement because our context has a lifetime.
+        // So, we use the `typeid` crate for non-static `TypeId`, as we don't care about the lifetime and only need to check the type.
+        // This crate is already used by `erased_serde`, so we don't add an extra dependency.
+        debug_assert_eq!(
+            self.serialize_ctx_id,
+            typeid::of::<S>(),
+            "trying to call message functions with serialize context `{}`, but they were created with `{}`",
+            any::type_name::<S>(),
+            self.serialize_ctx_name,
+        );
+        debug_assert_eq!(
+            self.deserialize_ctx_id,
+            typeid::of::<D>(),
+            "trying to call message functions with deserialize context `{}`, but they were created with `{}`",
+            any::type_name::<D>(),
+            self.deserialize_ctx_name,
+        );
+        debug_assert_eq!(
+            self.message_id,
+            TypeId::of::<E>(),
+            "trying to call message functions with message `{}`, but they were created with `{}`",
+            any::type_name::<E>(),
+            self.message_name,
+        );
+        debug_assert_eq!(
+            self.inner_id,
+            TypeId::of::<I>(),
+            "trying to call message functions with inner type `{}`, but they were created with `{}`",
+            any::type_name::<I>(),
+            self.inner_name,
+        );
+
+        MessageFns {
+            serialize_adapter: unsafe {
+                mem::transmute::<unsafe fn(), AdapterSerializeFn<S, E, I>>(self.serialize_adapter)
+            },
+            deserialize_adapter: unsafe {
+                mem::transmute::<unsafe fn(), AdapterDeserializeFn<D, E, I>>(
+                    self.deserialize_adapter,
+                )
+            },
+            serialize: unsafe { mem::transmute::<unsafe fn(), SerializeFn<S, I>>(self.serialize) },
+            deserialize: unsafe {
+                mem::transmute::<unsafe fn(), DeserializeFn<D, I>>(self.deserialize)
+            },
+        }
+    }
+}
+
+impl<S, D, E: 'static, I: 'static> From<MessageFns<S, D, E, I>> for UntypedMessageFns {
+    fn from(value: MessageFns<S, D, E, I>) -> Self {
+        // SAFETY: these functions won't be called until the type is restored.
+        Self {
+            serialize_ctx_id: typeid::of::<S>(),
+            serialize_ctx_name: any::type_name::<S>(),
+            deserialize_ctx_id: typeid::of::<D>(),
+            deserialize_ctx_name: any::type_name::<D>(),
+            message_id: TypeId::of::<E>(),
+            message_name: any::type_name::<E>(),
+            inner_id: TypeId::of::<I>(),
+            inner_name: any::type_name::<I>(),
+            serialize_adapter: unsafe {
+                mem::transmute::<AdapterSerializeFn<S, E, I>, unsafe fn()>(value.serialize_adapter)
+            },
+            deserialize_adapter: unsafe {
+                mem::transmute::<AdapterDeserializeFn<D, E, I>, unsafe fn()>(
+                    value.deserialize_adapter,
+                )
+            },
+            serialize: unsafe { mem::transmute::<SerializeFn<S, I>, unsafe fn()>(value.serialize) },
+            deserialize: unsafe {
+                mem::transmute::<DeserializeFn<D, I>, unsafe fn()>(value.deserialize)
+            },
+        }
+    }
+}
+
+/// Serialization and deserialization functions for a message.
+///
+/// For events, we want to allow users to customize these functions, but it would be inconvenient
+/// to write serialization and deserialization logic for the event adapter instead of the actual type.
+/// Since closures can't be used, we provide adapter functions that accept regular serialization functions.
+/// By default, these adapter functions simply call the passed function, but they can be overridden
+/// to perform the type conversion.
+pub(super) struct MessageFns<S, D, E, I = E> {
+    serialize_adapter: AdapterSerializeFn<S, E, I>,
+    deserialize_adapter: AdapterDeserializeFn<D, E, I>,
+    serialize: SerializeFn<S, I>,
+    deserialize: DeserializeFn<D, I>,
+}
+
+impl<S, D, E> MessageFns<S, D, E, E> {
+    /// Creates a new instance with default adapter functions.
+    pub(super) fn new(serialize: SerializeFn<S, E>, deserialize: DeserializeFn<D, E>) -> Self {
+        Self {
+            serialize_adapter: default_serialize_adapter::<S, E>,
+            deserialize_adapter: default_deserialize_adapter::<D, E>,
+            serialize,
+            deserialize,
+        }
+    }
+}
+
+impl<S, D, E, I> MessageFns<S, D, E, I> {
+    /// Adds conversion to type `T` before serialization and after deserialiation.
+    pub(super) fn with_convert<T: AsRef<I> + From<I>>(self) -> MessageFns<S, D, T, I> {
+        MessageFns {
+            serialize_adapter: convert_serialize_adapter,
+            deserialize_adapter: convert_deserialize_adapter,
+            serialize: self.serialize,
+            deserialize: self.deserialize,
+        }
+    }
+
+    pub(super) fn serialize(
+        self,
+        ctx: &mut S,
+        message: &E,
+        message_bytes: &mut Vec<u8>,
+    ) -> Result<()> {
+        (self.serialize_adapter)(ctx, message, message_bytes, self.serialize)
+    }
+
+    pub(super) fn deserialize(self, ctx: &mut D, message: &mut Bytes) -> Result<E> {
+        (self.deserialize_adapter)(ctx, message, self.deserialize)
+    }
+}
+
+fn default_serialize_adapter<C, E>(
+    ctx: &mut C,
+    message: &E,
+    message_bytes: &mut Vec<u8>,
+    serialize: SerializeFn<C, E>,
+) -> Result<()> {
+    (serialize)(ctx, message, message_bytes)
+}
+
+fn default_deserialize_adapter<C, E>(
+    ctx: &mut C,
+    message: &mut Bytes,
+    deserialize: DeserializeFn<C, E>,
+) -> Result<E> {
+    (deserialize)(ctx, message)
+}
+
+fn convert_serialize_adapter<C, E: AsRef<I>, I>(
+    ctx: &mut C,
+    message: &E,
+    message_bytes: &mut Vec<u8>,
+    serialize: SerializeFn<C, I>,
+) -> Result<()> {
+    (serialize)(ctx, message.as_ref(), message_bytes)
+}
+
+fn convert_deserialize_adapter<C, E: From<I>, I>(
+    ctx: &mut C,
+    message: &mut Bytes,
+    deserialize: DeserializeFn<C, I>,
+) -> Result<E> {
+    let message = (deserialize)(ctx, message)?;
+    Ok(E::from(message))
+}
+
+/// Signature of message serialization functions.
+pub type SerializeFn<C, E> = fn(&mut C, &E, &mut Vec<u8>) -> Result<()>;
+
+/// Signature of message deserialization functions.
+pub type DeserializeFn<C, E> = fn(&mut C, &mut Bytes) -> Result<E>;
+
+/// Signature of message adapter serialization functions.
+pub(super) type AdapterSerializeFn<C, E, I> =
+    fn(&mut C, &E, &mut Vec<u8>, SerializeFn<C, I>) -> Result<()>;
+
+/// Signature of message adapter deserialization functions.
+pub(super) type AdapterDeserializeFn<C, E, I> =
+    fn(&mut C, &mut Bytes, DeserializeFn<C, I>) -> Result<E>;
diff --git a/src/shared/message/registry.rs b/src/shared/message/registry.rs
new file mode 100644
index 00000000..d1e9cc46
--- /dev/null
+++ b/src/shared/message/registry.rs
@@ -0,0 +1,105 @@
+use core::any::TypeId;
+
+use bevy::prelude::*;
+
+use super::{
+    client_event::ClientEvent, client_message::ClientMessage, server_event::ServerEvent,
+    server_message::ServerMessage,
+};
+
+/// Registered server and client messages and events.
+#[derive(Resource, Default)]
+pub struct RemoteMessageRegistry {
+    // We use store events separately for quick iteration over them,
+    // but they are messages under the hood.
+    server_messages: Vec<ServerMessage>,
+    client_messages: Vec<ClientMessage>,
+    server_events: Vec<ServerEvent>,
+    client_events: Vec<ClientEvent>,
+}
+
+impl RemoteMessageRegistry {
+    pub(super) fn register_server_message(&mut self, message: ServerMessage) {
+        self.server_messages.push(message);
+    }
+
+    pub(super) fn register_client_message(&mut self, message: ClientMessage) {
+        self.client_messages.push(message);
+    }
+
+    pub(super) fn register_server_event(&mut self, event: ServerEvent) {
+        self.server_events.push(event);
+    }
+
+    pub(super) fn register_client_event(&mut self, event: ClientEvent) {
+        self.client_events.push(event);
+    }
+
+    pub(super) fn iter_server_messages_mut(&mut self) -> impl Iterator<Item = &mut ServerMessage> {
+        self.server_messages.iter_mut()
+    }
+
+    pub(super) fn iter_server_events_mut(&mut self) -> impl Iterator<Item = &mut ServerEvent> {
+        self.server_events.iter_mut()
+    }
+
+    pub(crate) fn iter_all_server(&self) -> impl Iterator<Item = &ServerMessage> {
+        self.server_messages
+            .iter()
+            .chain(self.server_events.iter().map(|e| e.message()))
+    }
+
+    pub(crate) fn iter_all_client(&self) -> impl Iterator<Item = &ClientMessage> {
+        self.client_messages
+            .iter()
+            .chain(self.client_events.iter().map(|e| e.message()))
+    }
+
+    pub(crate) fn iter_server_events(&self) -> impl Iterator<Item = &ServerEvent> {
+        self.server_events.iter()
+    }
+
+    pub(crate) fn iter_client_events(&self) -> impl Iterator<Item = &ClientEvent> {
+        self.client_events.iter()
+    }
+
+    /// Returns registered channel ID for server message `M`.
+    ///
+    /// See also [`ServerMessageAppExt::add_server_message`](super::server_message::ServerMessageAppExt::add_server_message).
+    pub fn server_message_channel<M: Message>(&self) -> Option<usize> {
+        self.server_messages
+            .iter()
+            .find(|m| m.type_id() == TypeId::of::<M>())
+            .map(|m| m.channel_id())
+    }
+
+    /// Returns registered channel ID for server event `E`.
+    ///
+    /// See also [`ServerEventAppExt::add_server_event`](super::server_event::ServerEventAppExt::add_server_event).
+    pub fn server_event_channel<E: Event>(&self) -> Option<usize> {
+        self.server_events
+            .iter()
+            .find(|e| e.type_id() == TypeId::of::<E>())
+            .map(|e| e.message().channel_id())
+    }
+
+    /// Returns registered channel ID for client message `M`.
+    ///
+    /// See also [`ClientMessageAppExt::add_client_message`](super::client_message::ClientMessageAppExt::add_client_message).
+    pub fn client_message_channel<M: Message>(&self) -> Option<usize> {
+        self.client_messages
+            .iter()
+            .find(|m| m.type_id() == TypeId::of::<M>())
+            .map(|m| m.channel_id())
+    }
+
+    /// Returns registered channel ID for client event `E`.
+    ///
+    /// See also [`ClientEventAppExt::add_client_event`](super::client_event::ClientEventAppExt::add_client_event).
+    pub fn client_event_channel<E: Event>(&self) -> Option<usize> {
+        self.client_events
+            .iter()
+            .find(|e| e.type_id() == TypeId::of::<E>())
+            .map(|e| e.message().channel_id())
+    }
+}
diff --git a/src/shared/message/server_event.rs b/src/shared/message/server_event.rs
new file mode 100644
index 00000000..8a669c3f
--- /dev/null
+++ b/src/shared/message/server_event.rs
@@ -0,0 +1,233 @@
+use core::any::{self, TypeId};
+
+use bevy::{ecs::entity::MapEntities, prelude::*, ptr::PtrMut};
+use log::debug;
+use serde::{Serialize, de::DeserializeOwned};
+
+use super::{
+    ctx::{ClientReceiveCtx, ServerSendCtx},
+    message_fns::{DeserializeFn, MessageFns, SerializeFn},
+    registry::RemoteMessageRegistry,
+    server_message::{self, ServerMessage},
+};
+use crate::prelude::*;
+
+/// An extension trait for [`App`] for creating server events.
+///
+/// See also [`ServerTriggerExt`] for triggering, [`ClientEventAppExt`] for client events
+/// and [`ServerMessageAppExt`] for messages.
+pub trait ServerEventAppExt {
+    /// Registers a remote event that can be triggered using [`ServerTriggerExt::server_trigger`].
+    ///
+    /// After triggering [`ToClients<E>`] event on the server, `E` event will be triggered on clients.
+    ///
+    /// If [`ClientMessagePlugin`] is enabled and [`ClientId::Server`] is a recipient of the event,
+    /// then `E` event will be emitted on the server as well.
+    ///
+    /// See also the [corresponding section](../index.html#from-client-to-server) from the quick start guide.
+    fn add_server_event<'a, E>(&mut self, channel: Channel) -> &mut Self
+    where
+        E: Event<Trigger<'a>: Default> + Serialize + DeserializeOwned,
+    {
+        self.add_server_event_with(
+            channel,
+            server_message::default_serialize::<E>,
+            server_message::default_deserialize::<E>,
+        )
+    }
+
+    /// Same as [`Self::add_server_event`], but additionally maps client entities to server inside the event before receiving.
+    ///
+    /// Always use it for events that contain entities. Entities must be annotated with `#[entities]`.
+    /// For details, see [`Component::map_entities`].
+    fn add_mapped_server_event<'a, E>(&mut self, channel: Channel) -> &mut Self
+    where
+        E: Event<Trigger<'a>: Default> + Serialize + DeserializeOwned + MapEntities,
+    {
+        self.add_server_event_with(
+            channel,
+            server_message::default_serialize::<E>,
+            server_message::default_deserialize_mapped::<E>,
+        )
+    }
+
+    /// Same as [`Self::add_server_event`], but uses the specified functions for serialization and deserialization.
+    ///
+    /// See also [`ServerMessageAppExt::add_server_message_with`].
+    fn add_server_event_with<'a, E: Event<Trigger<'a>: Default>>(
+        &mut self,
+        channel: Channel,
+        serialize: SerializeFn<ServerSendCtx, E>,
+        deserialize: DeserializeFn<ClientReceiveCtx, E>,
+    ) -> &mut Self;
+
+    /// Like [`ServerMessageAppExt::make_message_independent`], but for triggers.
+    fn make_event_independent<E: Event>(&mut self) -> &mut Self;
+}
+
+impl ServerEventAppExt for App {
+    fn add_server_event_with<'a, E: Event<Trigger<'a>: Default>>(
+        &mut self,
+        channel: Channel,
+        serialize: SerializeFn<ServerSendCtx, E>,
+        deserialize: DeserializeFn<ClientReceiveCtx, E>,
+    ) -> &mut Self {
+        self.world_mut()
+            .resource_mut::<ProtocolHasher>()
+            .add_server_event::<E>();
+
+        let fns = MessageFns::new(serialize, deserialize).with_convert::<ServerTriggerEvent<E>>();
+        let event = ServerEvent::new(self, channel, fns);
+        let mut registry = self.world_mut().resource_mut::<RemoteMessageRegistry>();
+        registry.register_server_event(event);
+
+        self
+    }
+
+    fn make_event_independent<E: Event>(&mut self) -> &mut Self {
+        self.world_mut()
+            .resource_mut::<ProtocolHasher>()
+            .make_event_independent::<E>();
+
+        let messages_id = self
+            .world()
+            .components()
+            .resource_id::<Messages<ServerTriggerEvent<E>>>()
+            .unwrap_or_else(|| {
+                panic!(
+                    "event `{}` should be previously registered",
+                    any::type_name::<E>()
+                )
+            });
+
+        let mut registry = self.world_mut().resource_mut::<RemoteMessageRegistry>();
+        let event = registry
+            .iter_server_events_mut()
+            .find(|e| e.message().messages_id() == messages_id)
+            .unwrap_or_else(|| {
+                panic!(
+                    "message `{}` should be previously registered as a server message",
+                    any::type_name::<E>()
+                )
+            });
+
+        event.message_mut().independent = true;
+
+        self
+    }
+}
+
+/// Small abstraction on top of [`ServerEvent`] that stores a function to trigger them.
+pub(crate) struct ServerEvent {
+    type_id: TypeId,
+    message: ServerMessage,
+    trigger: TriggerFn,
+}
+
+impl ServerEvent {
+    fn new<'a, E: Event<Trigger<'a>: Default>>(
+        app: &mut App,
+        channel: Channel,
+        fns: MessageFns<ServerSendCtx, ClientReceiveCtx, ServerTriggerEvent<E>, E>,
+    ) -> Self {
+        Self {
+            type_id: TypeId::of::<E>(),
+            message: ServerMessage::new(app, channel, fns),
+            trigger: Self::trigger_typed::<E>,
+        }
+    }
+
+    /// Drains received [`ServerTriggerEvent<E>`] messages and triggers them as `E`.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<ServerTriggerEvent<E>>`]
+    /// and this instance was created for `E`.
+    pub(crate) fn trigger(&self, commands: &mut Commands, messages: PtrMut) {
+        unsafe { (self.trigger)(commands, messages) }
+    }
+
+    /// Typed version of [`Self::trigger`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<ServerTriggerEvent<E>>`].
+    unsafe fn trigger_typed<'a, E: Event<Trigger<'a>: Default>>(
+        commands: &mut Commands,
+        messages: PtrMut,
+    ) {
+        let messages: &mut Messages<ServerTriggerEvent<E>> = unsafe { messages.deref_mut() };
+        for message in messages.drain() {
+            debug!("triggering `{}`", any::type_name::<E>());
+            commands.trigger(message.event);
+        }
+    }
+
+    pub(super) fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    pub(crate) fn message(&self) -> &ServerMessage {
+        &self.message
+    }
+
+    pub(super) fn message_mut(&mut self) -> &mut ServerMessage {
+        &mut self.message
+    }
+}
+
+/// Signature of server trigger functions.
+type TriggerFn = unsafe fn(&mut Commands, PtrMut);
+
+/// Extension trait for triggering server events.
+///
+/// See also [`ServerEventAppExt`].
+pub trait ServerTriggerExt {
+    /// Like [`Commands::trigger`], but triggers `E` on server and locally
+    /// if [`ClientId::Server`] is a recipient of the event).
+    fn server_trigger(&mut self, event: ToClients<impl Event>);
+}
+
+impl ServerTriggerExt for Commands<'_, '_> {
+    fn server_trigger(&mut self, event: ToClients<impl Event>) {
+        self.write_message(ToClients {
+            mode: event.mode,
+            message: ServerTriggerEvent {
+                event: event.message,
+            },
+        });
+    }
+}
+
+impl ServerTriggerExt for World {
+    fn server_trigger(&mut self, event: ToClients<impl Event>) {
+        self.write_message(ToClients {
+            mode: event.mode,
+            message: ServerTriggerEvent {
+                event: event.message,
+            },
+        });
+    }
+}
+
+/// A message that used under the hood for server events.
+///
+/// Events are implemented through messages in order to reuse their logic.
+/// So we send this message instead and, after receiving it, drain it to trigger regular events.
+/// This also allows us to avoid requiring [`Clone`] because events can't be drained.
+#[derive(Message)]
+struct ServerTriggerEvent<E> {
+    event: E,
+}
+
+impl<E> From<E> for ServerTriggerEvent<E> {
+    fn from(event: E) -> Self {
+        Self { event }
+    }
+}
+
+impl<E> AsRef<E> for ServerTriggerEvent<E> {
+    fn as_ref(&self) -> &E {
+        &self.event
+    }
+}
diff --git a/src/shared/message/server_message.rs b/src/shared/message/server_message.rs
new file mode 100644
index 00000000..9acd6e9d
--- /dev/null
+++ b/src/shared/message/server_message.rs
@@ -0,0 +1,724 @@
+pub(crate) mod message_buffer;
+mod message_queue;
+
+use core::any::{self, TypeId};
+
+use bevy::{
+    ecs::{component::ComponentId, entity::MapEntities},
+    prelude::*,
+    ptr::{Ptr, PtrMut},
+};
+use bytes::Bytes;
+use log::{debug, error, warn};
+use postcard::experimental::max_size::MaxSize;
+use serde::{Serialize, de::DeserializeOwned};
+
+use super::{
+    ctx::{ClientReceiveCtx, ServerSendCtx},
+    message_fns::{DeserializeFn, MessageFns, SerializeFn, UntypedMessageFns},
+    registry::RemoteMessageRegistry,
+};
+use crate::{postcard_utils, prelude::*};
+use message_buffer::{MessageBuffer, SerializedMessage};
+use message_queue::MessageQueue;
+
+/// An extension trait for [`App`] for creating server messages.
+///
+/// See also [`ClientMessageAppExt`] for client messages and [`ServerMessageAppExt`] for events.
+pub trait ServerMessageAppExt {
+    /// Registers a remote server message.
+    ///
+    /// After writing [`ToClients<E>`] message on the server, `E` message will be written on clients.
+    ///
+    /// If [`ClientMessagePlugin`] is enabled and [`ClientId::Server`] is a recipient of the message, then
+    /// [`ToClients<E>`] message will be drained after sending to clients and `E` message will be written
+    /// on the server as well.
+    ///
+    /// Calling [`App::add_message`] is not necessary. Can used for regular messages that were
+    /// previously registered.
+    ///
+    /// Unlike client messages, server messages are tied to replication. See [`Self::make_message_independent`]
+    /// for more details.
+    ///
+    /// See also the [corresponding section](../index.html#from-client-to-server) from the quick start guide.
+    fn add_server_message<E: Message + Serialize + DeserializeOwned>(
+        &mut self,
+        channel: Channel,
+    ) -> &mut Self {
+        self.add_server_message_with(channel, default_serialize::<E>, default_deserialize::<E>)
+    }
+
+    /// Same as [`Self::add_server_message`], but additionally maps server entities to client inside the message after receiving.
+    ///
+    /// Always use it for messages that contain entities. Entities must be annotated with `#[entities]`.
+    /// For details, see [`Component::map_entities`].
+    fn add_mapped_server_message<E: Message + Serialize + DeserializeOwned + MapEntities>(
+        &mut self,
+        channel: Channel,
+    ) -> &mut Self {
+        self.add_server_message_with(
+            channel,
+            default_serialize::<E>,
+            default_deserialize_mapped::<E>,
+        )
+    }
+
+    /**
+    Same as [`Self::add_server_message`], but uses the specified functions for serialization and deserialization.
+
+    See also [`postcard_utils`] and [`ServerEventAppExt::add_server_event_with`].
+
+    # Examples
+
+    Register a message with [`Box<dyn PartialReflect>`]:
+
+    ```
+    use bevy::{
+        prelude::*,
+        reflect::serde::{ReflectDeserializer, ReflectSerializer},
+        state::app::StatesPlugin,
+    };
+    use bevy_replicon::{
+        bytes::Bytes,
+        postcard_utils::{BufFlavor, ExtendMutFlavor},
+        shared::message::ctx::{ClientReceiveCtx, ServerSendCtx},
+        prelude::*,
+    };
+    use postcard::{Deserializer, Serializer};
+    use serde::{de::DeserializeSeed, Serialize};
+
+    let mut app = App::new();
+    app.add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins));
+    app.add_server_message_with(Channel::Ordered, serialize_dynamic, deserialize_dynamic);
+
+    fn serialize_dynamic(
+        ctx: &mut ServerSendCtx,
+        dynamic: &Dynamic,
+        message: &mut Vec<u8>,
+    ) -> Result<()> {
+        let mut serializer = Serializer { output: ExtendMutFlavor::new(message) };
+        let registry = ctx.type_registry.read();
+        ReflectSerializer::new(&*dynamic.0, &registry).serialize(&mut serializer)?;
+        Ok(())
+    }
+
+    fn deserialize_dynamic(
+        ctx: &mut ClientReceiveCtx,
+        message: &mut Bytes,
+    ) -> Result<Dynamic> {
+        let mut deserializer = Deserializer::from_flavor(BufFlavor::new(message));
+        let registry = ctx.type_registry.read();
+        let reflect = ReflectDeserializer::new(&registry).deserialize(&mut deserializer)?;
+        Ok(Dynamic(reflect))
+    }
+
+    #[derive(Message)]
+    struct Dynamic(Box<dyn PartialReflect>);
+    ```
+
+    See also [`AppRuleExt::replicate_with`] for more examples with custom ser/de.
+    */
+    fn add_server_message_with<E: Message>(
+        &mut self,
+        channel: Channel,
+        serialize: SerializeFn<ServerSendCtx, E>,
+        deserialize: DeserializeFn<ClientReceiveCtx, E>,
+    ) -> &mut Self;
+
+    /// Marks the message `E` as an independent message.
+    ///
+    /// By default, all server messages are buffered on server until server tick
+    /// and queued on client until all insertions, removals and despawns
+    /// (value mutations doesn't count) are replicated for the tick on which the
+    /// message was written. This is necessary to ensure that the executed logic
+    /// during the message does not affect components or entities that the client
+    /// has not yet received.
+    ///
+    /// For more details about replication see the documentation on
+    /// [`ServerChannel`](crate::shared::backend::channels::ServerChannel).
+    ///
+    /// However, if you know your message doesn't rely on that, you can mark it
+    /// as independent to always emit it immediately. For example, a chat
+    /// message - which does not hold references to any entities - may be
+    /// marked as independent.
+    ///
+    /// <div class="warning">
+    ///
+    /// Use this method very carefully; it can lead to logic errors that are
+    /// very difficult to debug!
+    ///
+    /// </div>
+    ///
+    /// See also [`ServerEventAppExt::make_event_independent`].
+    fn make_message_independent<E: Message>(&mut self) -> &mut Self;
+}
+
+impl ServerMessageAppExt for App {
+    fn add_server_message_with<E: Message>(
+        &mut self,
+        channel: Channel,
+        serialize: SerializeFn<ServerSendCtx, E>,
+        deserialize: DeserializeFn<ClientReceiveCtx, E>,
+    ) -> &mut Self {
+        self.world_mut()
+            .resource_mut::<ProtocolHasher>()
+            .add_server_message::<E>();
+
+        let fns = MessageFns::new(serialize, deserialize);
+        let message = ServerMessage::new(self, channel, fns);
+        let mut registry = self.world_mut().resource_mut::<RemoteMessageRegistry>();
+        registry.register_server_message(message);
+
+        self
+    }
+
+    fn make_message_independent<E: Message>(&mut self) -> &mut Self {
+        self.world_mut()
+            .resource_mut::<ProtocolHasher>()
+            .make_message_independent::<E>();
+
+        let messages_id = self
+            .world()
+            .components()
+            .resource_id::<Messages<E>>()
+            .unwrap_or_else(|| {
+                panic!(
+                    "message `{}` should be previously registered",
+                    any::type_name::<E>()
+                )
+            });
+
+        let mut registry = self.world_mut().resource_mut::<RemoteMessageRegistry>();
+        let message = registry
+            .iter_server_messages_mut()
+            .find(|m| m.messages_id() == messages_id)
+            .unwrap_or_else(|| {
+                panic!(
+                    "message `{}` should be previously registered as a server message",
+                    any::type_name::<E>()
+                )
+            });
+
+        message.independent = true;
+
+        self
+    }
+}
+
+/// Type-erased functions and metadata for a registered server message.
+///
+/// Needed to erase message types to process them in a single system.
+pub(crate) struct ServerMessage {
+    /// Whether this message depends on replication or not.
+    ///
+    /// Things like a chat message do not have to wait for replication to
+    /// be synced. If set to `true`, the message will always be applied
+    /// immediately.
+    pub(super) independent: bool,
+
+    /// ID of [`Messages<E>`].
+    messages_id: ComponentId,
+
+    /// ID of [`Messages<ToClients<E>>`].
+    to_messages_id: ComponentId,
+
+    /// ID of [`MessageQueue<T>`].
+    queue_id: ComponentId,
+
+    /// Used channel.
+    channel_id: usize,
+
+    /// ID of `E`.
+    type_id: TypeId,
+
+    send_or_buffer: SendOrBufferFn,
+    receive: ReceiveFn,
+    send_locally: SendLocallyFn,
+    reset: ResetFn,
+    fns: UntypedMessageFns,
+}
+
+impl ServerMessage {
+    pub(super) fn new<E: Message, I: 'static>(
+        app: &mut App,
+        channel: Channel,
+        fns: MessageFns<ServerSendCtx, ClientReceiveCtx, E, I>,
+    ) -> Self {
+        let channel_id = app
+            .world_mut()
+            .resource_mut::<RepliconChannels>()
+            .create_server_channel(channel);
+
+        app.add_message::<E>()
+            .add_message::<ToClients<E>>()
+            .init_resource::<MessageQueue<E>>();
+
+        let messages_id = app.world().resource_id::<Messages<E>>().unwrap();
+        let to_messages_id = app.world().resource_id::<Messages<ToClients<E>>>().unwrap();
+        let queue_id = app.world().resource_id::<MessageQueue<E>>().unwrap();
+
+        Self {
+            independent: false,
+            messages_id,
+            to_messages_id,
+            queue_id,
+            channel_id,
+            type_id: TypeId::of::<E>(),
+            send_or_buffer: Self::send_or_buffer_typed::<E, I>,
+            receive: Self::receive_typed::<E, I>,
+            send_locally: Self::send_locally_typed::<E>,
+            reset: Self::reset_typed::<E>,
+            fns: fns.into(),
+        }
+    }
+
+    pub(crate) fn messages_id(&self) -> ComponentId {
+        self.messages_id
+    }
+
+    pub(crate) fn to_messages_id(&self) -> ComponentId {
+        self.to_messages_id
+    }
+
+    pub(crate) fn queue_id(&self) -> ComponentId {
+        self.queue_id
+    }
+
+    pub(super) fn channel_id(&self) -> usize {
+        self.channel_id
+    }
+
+    pub(super) fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    /// Sends a message to client(s).
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `to_messages` is [`Messages<ToClients<E>>`]
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn send_or_buffer(
+        &self,
+        ctx: &mut ServerSendCtx,
+        to_messages: &Ptr,
+        server_messages: &mut ServerMessages,
+        clients: &Query<Entity, With<ConnectedClient>>,
+        message_buffer: &mut MessageBuffer,
+    ) {
+        unsafe {
+            (self.send_or_buffer)(
+                self,
+                ctx,
+                to_messages,
+                server_messages,
+                clients,
+                message_buffer,
+            )
+        }
+    }
+
+    /// Typed version of [`Self::send_or_buffer`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `to_messages` is [`Messages<ToClients<E>>`]
+    /// and this instance was created for `E` and `I`.
+    unsafe fn send_or_buffer_typed<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        to_messages: &Ptr,
+        server_messages: &mut ServerMessages,
+        clients: &Query<Entity, With<ConnectedClient>>,
+        message_buffer: &mut MessageBuffer,
+    ) {
+        let to_messages: &Messages<ToClients<E>> = unsafe { to_messages.deref() };
+        // For server messages we don't track read message because
+        // all of them will always be drained in the local sending system.
+        for ToClients { message, mode } in to_messages.get_cursor().read(to_messages) {
+            debug!(
+                "sending message `{}` with `{mode:?}`",
+                any::type_name::<E>()
+            );
+
+            if self.independent {
+                unsafe {
+                    self.send_independent_message::<E, I>(
+                        ctx,
+                        message,
+                        mode,
+                        server_messages,
+                        clients,
+                    )
+                    .expect("independent server message should be serializable");
+                }
+            } else {
+                unsafe {
+                    self.buffer_message::<E, I>(ctx, message, *mode, message_buffer)
+                        .expect("server message should be serializable");
+                }
+            }
+        }
+    }
+
+    /// Sends independent remote message `E` based on a mode.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `E` and `I`.
+    ///
+    /// For regular messages see [`Self::buffer_message`].
+    unsafe fn send_independent_message<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        message: &E,
+        mode: &SendMode,
+        server_messages: &mut ServerMessages,
+        clients: &Query<Entity, With<ConnectedClient>>,
+    ) -> Result<()> {
+        let mut message_bytes = Vec::new();
+        unsafe { self.serialize::<E, I>(ctx, message, &mut message_bytes)? }
+        let message_bytes: Bytes = message_bytes.into();
+
+        match *mode {
+            SendMode::Broadcast => {
+                for client_entity in clients {
+                    server_messages.send(client_entity, self.channel_id, message_bytes.clone());
+                }
+            }
+            SendMode::BroadcastExcept(ignored_id) => {
+                for client in clients {
+                    if ignored_id != client.into() {
+                        server_messages.send(client, self.channel_id, message_bytes.clone());
+                    }
+                }
+            }
+            SendMode::Direct(client_id) => {
+                if let ClientId::Client(client) = client_id {
+                    server_messages.send(client, self.channel_id, message_bytes.clone());
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Buffers message `E` based on mode.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `E` and `I`.
+    ///
+    /// For independent messages see [`Self::send_independent_message`].
+    unsafe fn buffer_message<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        message: &E,
+        mode: SendMode,
+        message_buffer: &mut MessageBuffer,
+    ) -> Result<()> {
+        let message_bytes = unsafe { self.serialize_with_padding::<E, I>(ctx, message)? };
+        message_buffer.insert(mode, self.channel_id, message_bytes);
+        Ok(())
+    }
+
+    /// Helper for serializing a server message.
+    ///
+    /// Will prepend padding bytes for where the update tick will be inserted to the injected message.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `E` and `I`.
+    unsafe fn serialize_with_padding<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        message: &E,
+    ) -> Result<SerializedMessage> {
+        let mut message_bytes = vec![0; RepliconTick::POSTCARD_MAX_SIZE]; // Padding for the tick.
+        unsafe { self.serialize::<E, I>(ctx, message, &mut message_bytes)? }
+        let message = SerializedMessage::Raw(message_bytes);
+
+        Ok(message)
+    }
+
+    /// Receives messages from the server.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`], `queue` is [`MessageQueue<E>`],
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn receive(
+        &self,
+        ctx: &mut ClientReceiveCtx,
+        messages: PtrMut,
+        queue: PtrMut,
+        client_messages: &mut ClientMessages,
+        update_tick: RepliconTick,
+    ) {
+        unsafe { (self.receive)(self, ctx, messages, queue, client_messages, update_tick) }
+    }
+
+    /// Typed version of [`ServerMessage::receive`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`], `queue` is [`MessageQueue<E>`]
+    /// and this instance was created for `E` and `I`.
+    unsafe fn receive_typed<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ClientReceiveCtx,
+        messages: PtrMut,
+        queue: PtrMut,
+        client_messages: &mut ClientMessages,
+        update_tick: RepliconTick,
+    ) {
+        let messages: &mut Messages<E> = unsafe { messages.deref_mut() };
+        let queue: &mut MessageQueue<E> = unsafe { queue.deref_mut() };
+
+        while let Some((tick, serialized_messages)) = queue.pop_if_le(update_tick) {
+            for mut message in serialized_messages {
+                match unsafe { self.deserialize::<E, I>(ctx, &mut message) } {
+                    Ok(message) => {
+                        debug!(
+                            "writing message `{}` from queue with `{tick:?}`",
+                            any::type_name::<E>()
+                        );
+                        messages.write(message);
+                    }
+                    Err(e) => error!(
+                        "ignoring message `{}` from queue with `{tick:?}` that failed to deserialize: {e}",
+                        any::type_name::<E>()
+                    ),
+                }
+            }
+        }
+
+        for mut message in client_messages.receive(self.channel_id) {
+            if !self.independent {
+                let tick = match postcard_utils::from_buf(&mut message) {
+                    Ok(tick) => tick,
+                    Err(e) => {
+                        error!(
+                            "ignoring message `{}` because it's tick failed to deserialize: {e}",
+                            any::type_name::<E>()
+                        );
+                        continue;
+                    }
+                };
+                if tick > update_tick {
+                    debug!(
+                        "queuing message `{}` with `{tick:?}`",
+                        any::type_name::<E>()
+                    );
+                    queue.insert(tick, message);
+                    continue;
+                } else {
+                    debug!(
+                        "receiving message `{}` with `{tick:?}`",
+                        any::type_name::<E>()
+                    );
+                }
+            }
+
+            match unsafe { self.deserialize::<E, I>(ctx, &mut message) } {
+                Ok(message) => {
+                    debug!("writing message `{}`", any::type_name::<E>());
+                    messages.write(message);
+                }
+                Err(e) => error!(
+                    "ignoring message `{}` that failed to deserialize: {e}",
+                    any::type_name::<E>()
+                ),
+            }
+        }
+    }
+
+    /// Drains messages [`ToClients<E>`] and writes them as `E` if the server is in the list of the message recipients.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`], `to_messages` is [`Messages<ToClients<E>>`],
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn send_locally(&self, to_messages: PtrMut, messages: PtrMut) {
+        unsafe { (self.send_locally)(to_messages, messages) }
+    }
+
+    /// Typed version of [`Self::send_locally`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `messages` is [`Messages<E>`] and `to_messages` is [`Messages<ToClients<E>>`].
+    unsafe fn send_locally_typed<E: Message>(to_messages: PtrMut, messages: PtrMut) {
+        let to_messages: &mut Messages<ToClients<E>> = unsafe { to_messages.deref_mut() };
+        let messages: &mut Messages<E> = unsafe { messages.deref_mut() };
+        for ToClients { message, mode } in to_messages.drain() {
+            debug!("writing message `{}` locally", any::type_name::<E>());
+            match mode {
+                SendMode::Broadcast => {
+                    messages.write(message);
+                }
+                SendMode::BroadcastExcept(ignored_id) => {
+                    if ignored_id != ClientId::Server {
+                        messages.write(message);
+                    }
+                }
+                SendMode::Direct(client_id) => {
+                    if client_id == ClientId::Server {
+                        messages.write(message);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Clears queued messages.
+    ///
+    /// We clear messages while waiting for a connection to ensure clean reconnects.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `queue` is [`MessageQueue<E>`]
+    /// and this instance was created for `E`.
+    pub(crate) unsafe fn reset(&self, queue: PtrMut) {
+        unsafe { (self.reset)(queue) }
+    }
+
+    /// Typed version of [`Self::reset`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `queue` is [`MessageQueue<E>`].
+    unsafe fn reset_typed<E: Message>(queue: PtrMut) {
+        let queue: &mut MessageQueue<E> = unsafe { queue.deref_mut() };
+        if !queue.is_empty() {
+            warn!(
+                "discarding {} queued messages due to a disconnect",
+                queue.len()
+            );
+        }
+        queue.clear();
+    }
+
+    /// Serializes a messages.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `E` and `I`.
+    unsafe fn serialize<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        message: &E,
+        message_bytes: &mut Vec<u8>,
+    ) -> Result<()> {
+        unsafe {
+            self.fns
+                .typed::<ServerSendCtx, ClientReceiveCtx, E, I>()
+                .serialize(ctx, message, message_bytes)
+        }
+    }
+
+    /// Deserializes a message.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `E` and `I`.
+    unsafe fn deserialize<E: Message, I: 'static>(
+        &self,
+        ctx: &mut ClientReceiveCtx,
+        message: &mut Bytes,
+    ) -> Result<E> {
+        let message = unsafe {
+            self.fns
+                .typed::<ServerSendCtx, ClientReceiveCtx, E, I>()
+                .deserialize(ctx, message)?
+        };
+
+        if ctx.invalid_entities.is_empty() {
+            Ok(message)
+        } else {
+            let msg = format!(
+                "unable to map entities `{:?}` from the server, \
+                make sure that the message references entities visible to the client",
+                ctx.invalid_entities
+            );
+            ctx.invalid_entities.clear();
+            Err(msg.into())
+        }
+    }
+}
+
+/// Signature of server message sending functions.
+type SendOrBufferFn = unsafe fn(
+    &ServerMessage,
+    &mut ServerSendCtx,
+    &Ptr,
+    &mut ServerMessages,
+    &Query<Entity, With<ConnectedClient>>,
+    &mut MessageBuffer,
+);
+
+/// Signature of server message receiving functions.
+type ReceiveFn = unsafe fn(
+    &ServerMessage,
+    &mut ClientReceiveCtx,
+    PtrMut,
+    PtrMut,
+    &mut ClientMessages,
+    RepliconTick,
+);
+
+/// Signature of server message sending functions.
+type SendLocallyFn = unsafe fn(PtrMut, PtrMut);
+
+/// Signature of server message reset functions.
+type ResetFn = unsafe fn(PtrMut);
+
+/// A remote message that will be send to client(s).
+#[derive(Event, Message, Deref, DerefMut, Debug, Clone, Copy)]
+pub struct ToClients<T> {
+    /// Recipients.
+    pub mode: SendMode,
+    /// Transmitted message.
+    #[deref]
+    pub message: T,
+}
+
+/// Type of server message sending.
+#[derive(Clone, Copy, Debug)]
+pub enum SendMode {
+    /// Send to every client.
+    Broadcast,
+    /// Send to every client except the specified connected client.
+    BroadcastExcept(ClientId),
+    /// Send only to the specified client.
+    Direct(ClientId),
+}
+
+/// Default message serialization function.
+pub fn default_serialize<E: Serialize>(
+    _ctx: &mut ServerSendCtx,
+    message: &E,
+    message_bytes: &mut Vec<u8>,
+) -> Result<()> {
+    postcard_utils::to_extend_mut(message, message_bytes)?;
+    Ok(())
+}
+
+/// Default message deserialization function.
+pub fn default_deserialize<E: DeserializeOwned>(
+    _ctx: &mut ClientReceiveCtx,
+    message: &mut Bytes,
+) -> Result<E> {
+    let message = postcard_utils::from_buf(message)?;
+    Ok(message)
+}
+
+/// Like [`default_deserialize`], but also maps entities.
+pub fn default_deserialize_mapped<E: DeserializeOwned + MapEntities>(
+    ctx: &mut ClientReceiveCtx,
+    message: &mut Bytes,
+) -> Result<E> {
+    let mut message: E = postcard_utils::from_buf(message)?;
+    message.map_entities(ctx);
+    Ok(message)
+}
diff --git a/src/shared/event/server_event/event_buffer.rs b/src/shared/message/server_message/message_buffer.rs
similarity index 81%
rename from src/shared/event/server_event/event_buffer.rs
rename to src/shared/message/server_message/message_buffer.rs
index 4c99d9ad..9fa0942c 100644
--- a/src/shared/event/server_event/event_buffer.rs
+++ b/src/shared/message/server_message/message_buffer.rs
@@ -7,27 +7,27 @@ use postcard::experimental::{max_size::MaxSize, serialized_size};
 
 use crate::{postcard_utils, prelude::*, shared::replication::client_ticks::ClientTicks};
 
-/// Caches synchronization-dependent server events until they can be sent with an accurate update tick.
+/// Caches synchronization-dependent server messages until they can be sent with an accurate update tick.
 ///
-/// This exists because replication does not scan the world every tick. If a server event is sent in the same
-/// tick as a spawn and the event references that spawn, then the server event's update tick needs to be synchronized
-/// with that spawn on the client. We buffer the event until the spawn can be detected.
+/// This exists because replication does not scan the world every tick. If a server message is sent in the same
+/// tick as a spawn and the message references that spawn, then the server message's update tick needs to be synchronized
+/// with that spawn on the client. We buffer the message until the spawn can be detected.
 #[derive(Resource, Default)]
-pub(crate) struct EventBuffer {
-    ticks: Vec<TickEvents>,
+pub(crate) struct MessageBuffer {
+    ticks: Vec<TickMessages>,
 
     /// Cached unused sets to avoid reallocations when pushing into the buffer.
     ///
     /// These are cleared before insertion.
-    buffer: Vec<TickEvents>,
+    buffer: Vec<TickMessages>,
 }
 
-impl EventBuffer {
+impl MessageBuffer {
     pub(crate) fn start_tick(&mut self) {
         self.ticks.push(self.buffer.pop().unwrap_or_default());
     }
 
-    fn active_tick(&mut self) -> Option<&mut TickEvents> {
+    fn active_tick(&mut self) -> Option<&mut TickMessages> {
         self.ticks.last_mut()
     }
 
@@ -36,14 +36,14 @@ impl EventBuffer {
             .active_tick()
             .expect("`start_tick` should be called before buffering");
 
-        buffer.events.push(BufferedEvent {
+        buffer.messages.push(BufferedMessage {
             mode,
             channel_id,
             message,
         });
     }
 
-    /// Used to prevent newly-connected clients from receiving old events.
+    /// Used to prevent newly-connected clients from receiving old messages.
     pub(crate) fn exclude_client(&mut self, client: Entity) {
         for set in self.ticks.iter_mut() {
             set.excluded.insert(client);
@@ -56,18 +56,18 @@ impl EventBuffer {
         clients: &Query<(Entity, Option<&ClientTicks>), With<ConnectedClient>>,
     ) -> Result<()> {
         for mut tick in self.ticks.drain(..) {
-            for mut event in tick.events.drain(..) {
-                match event.mode {
+            for mut message in tick.messages.drain(..) {
+                match message.mode {
                     SendMode::Broadcast => {
                         for (client, ticks) in
                             clients.iter().filter(|(e, _)| !tick.excluded.contains(e))
                         {
                             if let Some(ticks) = ticks {
-                                event.send(messages, client, ticks)?;
+                                message.send(messages, client, ticks)?;
                             } else {
                                 debug!(
                                     "ignoring broadcast for channel {} for non-authorized client `{client}`",
-                                    event.channel_id
+                                    message.channel_id
                                 );
                             }
                         }
@@ -81,11 +81,11 @@ impl EventBuffer {
                             }
 
                             if let Some(ticks) = ticks {
-                                event.send(messages, client, ticks)?;
+                                message.send(messages, client, ticks)?;
                             } else {
                                 debug!(
                                     "ignoring broadcast except `{ignored_id}` for channel {} for non-authorized client `{client}`",
-                                    event.channel_id
+                                    message.channel_id
                                 );
                             }
                         }
@@ -96,10 +96,10 @@ impl EventBuffer {
                             && !tick.excluded.contains(&client)
                         {
                             if let Some(ticks) = ticks {
-                                event.send(messages, client, ticks)?;
+                                message.send(messages, client, ticks)?;
                             } else {
                                 error!(
-                                    "ignoring direct event for non-authorized client `{client}`, \
+                                    "ignoring direct message for non-authorized client `{client}`, \
                                          mark it as independent to allow this"
                                 );
                             }
@@ -122,26 +122,26 @@ impl EventBuffer {
 }
 
 #[derive(Default)]
-struct TickEvents {
-    events: Vec<BufferedEvent>,
-    /// Client entities excluded from receiving events in this set because they connected after the events were sent.
+struct TickMessages {
+    messages: Vec<BufferedMessage>,
+    /// Client entities excluded from receiving messages in this set because they connected after the messages were sent.
     excluded: EntityHashSet,
 }
 
-impl TickEvents {
+impl TickMessages {
     fn clear(&mut self) {
-        self.events.clear();
+        self.messages.clear();
         self.excluded.clear();
     }
 }
 
-struct BufferedEvent {
+struct BufferedMessage {
     mode: SendMode,
     channel_id: usize,
     message: SerializedMessage,
 }
 
-impl BufferedEvent {
+impl BufferedMessage {
     fn send(
         &mut self,
         messages: &mut ServerMessages,
@@ -154,7 +154,7 @@ impl BufferedEvent {
     }
 }
 
-/// Cached message for use in [`BufferedEvents`].
+/// Cached message for use in [`MessageBuffer`].
 pub(super) enum SerializedMessage {
     /// A message without serialized tick.
     ///
diff --git a/src/shared/event/server_event/event_queue.rs b/src/shared/message/server_message/message_queue.rs
similarity index 82%
rename from src/shared/event/server_event/event_queue.rs
rename to src/shared/message/server_message/message_queue.rs
index 64182478..493ee6b7 100644
--- a/src/shared/event/server_event/event_queue.rs
+++ b/src/shared/message/server_message/message_queue.rs
@@ -6,12 +6,12 @@ use bytes::Bytes;
 
 use crate::prelude::*;
 
-/// Stores all received events from server that arrived earlier then replication message with their tick.
+/// Stores all received messages from server that arrived earlier then replication message with their tick.
 ///
 /// Stores data sorted by ticks and maintains order of arrival.
-/// Needed to ensure that when an event is triggered, all the data that it affects or references already exists.
+/// Needed to ensure that when an message is triggered, all the data that it affects or references already exists.
 #[derive(Resource)]
-pub(super) struct EventQueue<E> {
+pub(super) struct MessageQueue<E> {
     map: BTreeMap<RepliconTick, Vec<Bytes>>,
     /// [`Vec`]s from removals.
     ///
@@ -21,7 +21,7 @@ pub(super) struct EventQueue<E> {
     marker: PhantomData<E>,
 }
 
-impl<E> EventQueue<E> {
+impl<E> MessageQueue<E> {
     pub(super) fn insert(&mut self, tick: RepliconTick, message: Bytes) {
         self.map
             .entry(tick)
@@ -29,7 +29,7 @@ impl<E> EventQueue<E> {
             .push(message);
     }
 
-    /// Pops the next event that is at least as old as the specified replicon tick.
+    /// Pops the next message that is at least as old as the specified replicon tick.
     pub(super) fn pop_if_le(
         &mut self,
         update_tick: RepliconTick,
@@ -60,7 +60,7 @@ impl<E> EventQueue<E> {
     }
 }
 
-impl<E> Default for EventQueue<E> {
+impl<E> Default for MessageQueue<E> {
     fn default() -> Self {
         Self {
             map: Default::default(),
@@ -76,7 +76,7 @@ mod tests {
 
     #[test]
     fn lower_tick() {
-        let mut queue = EventQueue::<TestEvent>::default();
+        let mut queue = MessageQueue::<Test>::default();
         queue.insert(RepliconTick::new(1), Default::default());
 
         assert_eq!(queue.len(), 1);
@@ -85,7 +85,7 @@ mod tests {
 
     #[test]
     fn bigger_tick() {
-        let mut queue = EventQueue::<TestEvent>::default();
+        let mut queue = MessageQueue::<Test>::default();
         queue.insert(RepliconTick::new(1), Default::default());
 
         assert!(queue.pop_if_le(RepliconTick::new(2)).is_some());
@@ -94,7 +94,7 @@ mod tests {
 
     #[test]
     fn ticks_ordering() {
-        let mut queue = EventQueue::<TestEvent>::default();
+        let mut queue = MessageQueue::<Test>::default();
         queue.insert(RepliconTick::new(0), Default::default());
         queue.insert(RepliconTick::new(1), Default::default());
         queue.insert(RepliconTick::new(2), Default::default());
@@ -111,7 +111,7 @@ mod tests {
 
     #[test]
     fn messages_ordering() {
-        let mut queue = EventQueue::<TestEvent>::default();
+        let mut queue = MessageQueue::<Test>::default();
         queue.insert(RepliconTick::new(0), Bytes::from_static(&[0]));
         queue.insert(RepliconTick::new(0), Bytes::from_static(&[1]));
 
@@ -121,5 +121,5 @@ mod tests {
         assert!(queue.is_empty());
     }
 
-    struct TestEvent;
+    struct Test;
 }
diff --git a/src/shared/protocol.rs b/src/shared/protocol.rs
index 1388723e..5459d58a 100644
--- a/src/shared/protocol.rs
+++ b/src/shared/protocol.rs
@@ -68,14 +68,19 @@ impl ProtocolHasher {
         self.hash::<B>(ProtocolPart::ReplicateBundle);
     }
 
+    pub(crate) fn add_client_message<E>(&mut self) {
+        debug!("adding client message `{}`", any::type_name::<E>());
+        self.hash::<E>(ProtocolPart::ClientMessage);
+    }
+
     pub(crate) fn add_client_event<E>(&mut self) {
         debug!("adding client event `{}`", any::type_name::<E>());
         self.hash::<E>(ProtocolPart::ClientEvent);
     }
 
-    pub(crate) fn add_client_trigger<E>(&mut self) {
-        debug!("adding client trigger `{}`", any::type_name::<E>());
-        self.hash::<E>(ProtocolPart::ClientTrigger);
+    pub(crate) fn add_server_message<E>(&mut self) {
+        debug!("adding server message `{}`", any::type_name::<E>());
+        self.hash::<E>(ProtocolPart::ServerMessage);
     }
 
     pub(crate) fn add_server_event<E>(&mut self) {
@@ -83,9 +88,9 @@ impl ProtocolHasher {
         self.hash::<E>(ProtocolPart::ServerEvent);
     }
 
-    pub(crate) fn add_server_trigger<E>(&mut self) {
-        debug!("adding server trigger `{}`", any::type_name::<E>());
-        self.hash::<E>(ProtocolPart::ServerTrigger);
+    pub(crate) fn make_message_independent<E>(&mut self) {
+        debug!("making message `{}` independent", any::type_name::<E>());
+        self.hash::<E>(ProtocolPart::IndependentMessage);
     }
 
     pub(crate) fn make_event_independent<E>(&mut self) {
@@ -93,11 +98,6 @@ impl ProtocolHasher {
         self.hash::<E>(ProtocolPart::IndependentEvent);
     }
 
-    pub(crate) fn make_trigger_independent<E>(&mut self) {
-        debug!("making trigger `{}` independent", any::type_name::<E>());
-        self.hash::<E>(ProtocolPart::IndependentTrigger);
-    }
-
     fn hash<T>(&mut self, part: ProtocolPart) {
         part.hash(&mut self.0);
         any::type_name::<T>().hash(&mut self.0);
@@ -121,12 +121,12 @@ impl ProtocolHasher {
 enum ProtocolPart {
     Replicate { priority: u64 },
     ReplicateBundle,
+    ClientMessage,
     ClientEvent,
-    ClientTrigger,
+    ServerMessage,
     ServerEvent,
-    ServerTrigger,
+    IndependentMessage,
     IndependentEvent,
-    IndependentTrigger,
 }
 
 /// Hash of all registered events and replication rules.
@@ -137,7 +137,7 @@ enum ProtocolPart {
 #[derive(Resource, Event, Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
 pub struct ProtocolHash(u64);
 
-/// A server trigger to notify client for the protocol mismatch.
+/// A server event to notify client for the protocol mismatch.
 ///
 /// Registered and sent only if [`RepliconSharedPlugin::auth_method`](super::RepliconSharedPlugin::auth_method)
 /// set to [`AuthMethod::ProtocolCheck`](super::AuthMethod::ProtocolCheck). The server will immediately
@@ -188,10 +188,10 @@ mod tests {
     #[test]
     fn different_parts() {
         let mut hasher1 = ProtocolHasher::default();
-        hasher1.add_server_event::<StructA>();
+        hasher1.add_server_message::<StructA>();
 
         let mut hasher2 = ProtocolHasher::default();
-        hasher2.add_client_event::<StructA>();
+        hasher2.add_client_message::<StructA>();
 
         assert_ne!(hasher1.finish(), hasher2.finish());
     }
@@ -203,10 +203,10 @@ mod tests {
 
         for hasher in [&mut hasher1, &mut hasher2] {
             hasher.replicate::<StructA>(1);
-            hasher.add_server_event::<StructB>();
-            hasher.add_server_trigger::<StructC>();
-            hasher.add_client_event::<StructB>();
-            hasher.add_client_trigger::<StructC>();
+            hasher.add_server_message::<StructB>();
+            hasher.add_server_event::<StructC>();
+            hasher.add_client_message::<StructB>();
+            hasher.add_client_event::<StructC>();
         }
         hasher1.add_custom(0);
         hasher2.add_custom(1);
@@ -221,10 +221,10 @@ mod tests {
 
         for hasher in [&mut hasher1, &mut hasher2] {
             hasher.replicate::<StructA>(1);
-            hasher.add_server_event::<StructB>();
-            hasher.add_server_trigger::<StructC>();
-            hasher.add_client_event::<StructB>();
-            hasher.add_client_trigger::<StructC>();
+            hasher.add_server_message::<StructB>();
+            hasher.add_server_event::<StructC>();
+            hasher.add_client_message::<StructB>();
+            hasher.add_client_event::<StructC>();
             hasher.add_custom(0usize);
         }
 
diff --git a/src/shared/replication/signature.rs b/src/shared/replication/signature.rs
index db669355..d3afa5bc 100644
--- a/src/shared/replication/signature.rs
+++ b/src/shared/replication/signature.rs
@@ -4,7 +4,7 @@ use core::{
 };
 
 use bevy::{
-    ecs::{component::HookContext, entity::EntityHashMap, world::DeferredWorld},
+    ecs::{entity::EntityHashMap, lifecycle::HookContext, world::DeferredWorld},
     platform::{collections::HashMap, hash::NoOpHash},
     prelude::*,
 };
@@ -154,7 +154,7 @@ impl Signature {
 
     # let mut app = App::new();
     # app.add_plugins((StatesPlugin, RepliconPlugins));
-    app.add_client_trigger::<SpawnFireball>(Channel::Ordered)
+    app.add_client_event::<SpawnFireball>(Channel::Ordered)
         .add_observer(confirm_projectile)
         .add_systems(
             FixedUpdate,
@@ -183,11 +183,11 @@ impl Signature {
     /// Depending on the type of game you may want to correct the client or disconnect it.
     /// In this example we just always confirm the spawn.
     fn confirm_projectile(
-        trigger: Trigger<FromClient<SpawnFireball>>,
+        fireball: On<FromClient<SpawnFireball>>,
         mut commands: Commands,
         clients: Query<&Controls>,
     ) {
-        if let ClientId::Client(client) = trigger.client_id {
+        if let ClientId::Client(client) = fireball.client_id {
             let instigator = **clients.get(client).unwrap();
 
             // You can insert more components, they will be replicated to the client's entity.
@@ -201,7 +201,7 @@ impl Signature {
         }
     }
 
-    /// Trigger to ask server to spawn a projectile.
+    /// Request to spawn a projectile.
     #[derive(Event, Serialize, Deserialize)]
     struct SpawnFireball;
 
diff --git a/src/shared/server_entity_map.rs b/src/shared/server_entity_map.rs
index 8e97a59f..5738864a 100644
--- a/src/shared/server_entity_map.rs
+++ b/src/shared/server_entity_map.rs
@@ -155,8 +155,8 @@ mod tests {
 
     #[test]
     fn mapping() {
-        const SERVER_ENTITY: Entity = Entity::from_raw(0);
-        const CLIENT_ENTITY: Entity = Entity::from_raw(1);
+        const SERVER_ENTITY: Entity = Entity::from_raw_u32(0).unwrap();
+        const CLIENT_ENTITY: Entity = Entity::from_raw_u32(1).unwrap();
 
         let mut map = ServerEntityMap::default();
         assert_eq!(map.server_entry(SERVER_ENTITY).get(), None);
diff --git a/tests/bidirectional_event.rs b/tests/bidirectional_event.rs
index 2fc6821f..9d9fce5d 100644
--- a/tests/bidirectional_event.rs
+++ b/tests/bidirectional_event.rs
@@ -1,25 +1,33 @@
-use bevy::{ecs::event::Events, prelude::*, state::app::StatesPlugin};
-use bevy_replicon::{prelude::*, test_app::ServerTestAppExt};
+use bevy::{prelude::*, state::app::StatesPlugin};
+use bevy_replicon::{
+    prelude::*, shared::message::registry::RemoteMessageRegistry, test_app::ServerTestAppExt,
+};
 use serde::{Deserialize, Serialize};
 use test_log::test;
 
 #[test]
-fn event() {
+fn message() {
     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, StatesPlugin, RepliconPlugins))
-            .add_client_event::<TestEvent>(Channel::Ordered)
-            .add_server_event::<TestEvent>(Channel::Ordered)
+            .add_client_message::<Test>(Channel::Ordered)
+            .add_server_message::<Test>(Channel::Ordered)
             .finish();
     }
 
+    let registry = server_app.world().resource::<RemoteMessageRegistry>();
+    assert_eq!(registry.client_message_channel::<Test>(), Some(2));
+    assert_eq!(registry.server_message_channel::<Test>(), Some(3));
+    assert_eq!(registry.client_event_channel::<Test>(), None);
+    assert_eq!(registry.server_event_channel::<Test>(), None);
+
     server_app.connect_client(&mut client_app);
 
-    client_app.world_mut().send_event(TestEvent);
-    server_app.world_mut().send_event(ToClients {
+    client_app.world_mut().write_message(Test);
+    server_app.world_mut().write_message(ToClients {
         mode: SendMode::Broadcast,
-        event: TestEvent,
+        message: Test,
     });
 
     client_app.update();
@@ -28,19 +36,17 @@ fn event() {
     client_app.update();
     server_app.update();
 
-    let client_events = server_app
-        .world()
-        .resource::<Events<FromClient<TestEvent>>>();
+    let messages = server_app.world().resource::<Messages<FromClient<Test>>>();
     assert_eq!(
-        client_events.len(),
+        messages.len(),
         2,
-        "server should get 2 events due to local resending"
+        "server should get 2 messages due to local sending"
     );
-    assert_eq!(client_app.world().resource::<Events<TestEvent>>().len(), 1);
+    assert_eq!(client_app.world().resource::<Messages<Test>>().len(), 1);
 }
 
 #[test]
-fn trigger() {
+fn event() {
     let mut server_app = App::new();
     let mut client_app = App::new();
     for app in [&mut server_app, &mut client_app] {
@@ -49,19 +55,25 @@ fn trigger() {
             StatesPlugin,
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
         ))
-        .add_client_trigger::<TestEvent>(Channel::Ordered)
-        .add_server_trigger::<TestEvent>(Channel::Ordered)
+        .add_client_event::<Test>(Channel::Ordered)
+        .add_server_event::<Test>(Channel::Ordered)
         .finish();
     }
-    server_app.init_resource::<TriggerReader<FromClient<TestEvent>>>();
-    client_app.init_resource::<TriggerReader<TestEvent>>();
+    server_app.init_resource::<EventReader<FromClient<Test>>>();
+    client_app.init_resource::<EventReader<Test>>();
+
+    let registry = server_app.world().resource::<RemoteMessageRegistry>();
+    assert_eq!(registry.client_message_channel::<Test>(), None);
+    assert_eq!(registry.server_message_channel::<Test>(), None);
+    assert_eq!(registry.client_event_channel::<Test>(), Some(2));
+    assert_eq!(registry.server_event_channel::<Test>(), Some(3));
 
     server_app.connect_client(&mut client_app);
 
-    client_app.world_mut().client_trigger(TestEvent);
+    client_app.world_mut().client_trigger(Test);
     server_app.world_mut().server_trigger(ToClients {
         mode: SendMode::Broadcast,
-        event: TestEvent,
+        message: Test,
     });
 
     client_app.update();
@@ -72,25 +84,25 @@ fn trigger() {
 
     let server_reader = server_app
         .world()
-        .resource::<TriggerReader<FromClient<TestEvent>>>();
+        .resource::<EventReader<FromClient<Test>>>();
     assert_eq!(server_reader.events.len(), 1);
 
-    let client_reader = client_app.world().resource::<TriggerReader<TestEvent>>();
+    let client_reader = client_app.world().resource::<EventReader<Test>>();
     assert_eq!(client_reader.events.len(), 1);
 }
 
-#[derive(Event, Serialize, Deserialize, Clone)]
-struct TestEvent;
+#[derive(Message, Event, Serialize, Deserialize, Clone)]
+struct Test;
 
 #[derive(Resource)]
-struct TriggerReader<E: Event> {
+struct EventReader<E: Event> {
     events: Vec<E>,
 }
 
-impl<E: Event + Clone> FromWorld for TriggerReader<E> {
+impl<E: Event + Clone> FromWorld for EventReader<E> {
     fn from_world(world: &mut World) -> Self {
-        world.add_observer(|trigger: Trigger<E>, mut counter: ResMut<Self>| {
-            counter.events.push(trigger.event().clone());
+        world.add_observer(|on: On<E>, mut reader: ResMut<Self>| {
+            reader.events.push(on.event().clone());
         });
 
         Self {
diff --git a/tests/client_event.rs b/tests/client_event.rs
index 6794fe17..ab655b6f 100644
--- a/tests/client_event.rs
+++ b/tests/client_event.rs
@@ -1,56 +1,31 @@
-use bevy::{
-    ecs::{entity::MapEntities, event::Events},
-    prelude::*,
-    state::app::StatesPlugin,
-    time::TimePlugin,
-};
+use bevy::{ecs::entity::MapEntities, prelude::*, state::app::StatesPlugin, time::TimePlugin};
 use bevy_replicon::{
-    prelude::*,
-    shared::{event::registry::RemoteEventRegistry, server_entity_map::ServerEntityMap},
-    test_app::ServerTestAppExt,
+    prelude::*, shared::server_entity_map::ServerEntityMap, test_app::ServerTestAppExt,
 };
 use serde::{Deserialize, Serialize};
 use test_log::test;
 
-#[test]
-fn channels() {
-    let mut app = App::new();
-    app.add_plugins((
-        MinimalPlugins,
-        StatesPlugin,
-        RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-    ))
-    .add_event::<NonRemoteEvent>()
-    .add_client_event::<TestEvent>(Channel::Ordered)
-    .finish();
-
-    let event_registry = app.world().resource::<RemoteEventRegistry>();
-    assert_eq!(event_registry.client_channel::<NonRemoteEvent>(), None);
-    assert_eq!(event_registry.client_channel::<TestEvent>(), Some(2));
-}
-
 #[test]
 fn regular() {
     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, StatesPlugin, RepliconPlugins))
-            .add_client_event::<TestEvent>(Channel::Ordered)
+            .add_client_event::<Test>(Channel::Ordered)
             .finish();
     }
+    server_app.init_resource::<EventReader<Test>>();
 
     server_app.connect_client(&mut client_app);
 
-    client_app.world_mut().send_event(TestEvent);
+    client_app.world_mut().client_trigger(Test);
 
     client_app.update();
     server_app.exchange_with_client(&mut client_app);
     server_app.update();
 
-    let client_events = server_app
-        .world()
-        .resource::<Events<FromClient<TestEvent>>>();
-    assert_eq!(client_events.len(), 1);
+    let reader = server_app.world().resource::<EventReader<Test>>();
+    assert_eq!(reader.events.len(), 1);
 }
 
 #[test]
@@ -63,9 +38,10 @@ fn mapped() {
             StatesPlugin,
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
         ))
-        .add_mapped_client_event::<EntityEvent>(Channel::Ordered)
+        .add_mapped_client_event::<WithEntity>(Channel::Ordered)
         .finish();
     }
+    server_app.init_resource::<EventReader<WithEntity>>();
 
     server_app.connect_client(&mut client_app);
 
@@ -84,18 +60,14 @@ fn mapped() {
 
     client_app
         .world_mut()
-        .send_event(EntityEvent(client_entity));
+        .client_trigger(WithEntity(client_entity));
 
     client_app.update();
     server_app.exchange_with_client(&mut client_app);
     server_app.update();
 
-    let mapped_entities: Vec<_> = server_app
-        .world_mut()
-        .resource_mut::<Events<FromClient<EntityEvent>>>()
-        .drain()
-        .map(|event| event.0)
-        .collect();
+    let reader = server_app.world().resource::<EventReader<WithEntity>>();
+    let mapped_entities: Vec<_> = reader.events.iter().map(|event| event.0).collect();
     assert_eq!(mapped_entities, [server_entity]);
 }
 
@@ -110,9 +82,9 @@ fn without_plugins() {
             RepliconPlugins
                 .build()
                 .disable::<ClientPlugin>()
-                .disable::<ClientEventPlugin>(),
+                .disable::<ClientMessagePlugin>(),
         ))
-        .add_client_event::<TestEvent>(Channel::Ordered)
+        .add_client_event::<Test>(Channel::Ordered)
         .finish();
     client_app
         .add_plugins((
@@ -121,48 +93,62 @@ fn without_plugins() {
             RepliconPlugins
                 .build()
                 .disable::<ServerPlugin>()
-                .disable::<ServerEventPlugin>(),
+                .disable::<ServerMessagePlugin>(),
         ))
-        .add_client_event::<TestEvent>(Channel::Ordered)
+        .add_client_event::<Test>(Channel::Ordered)
         .finish();
+    server_app.init_resource::<EventReader<Test>>();
 
     server_app.connect_client(&mut client_app);
 
-    client_app.world_mut().send_event(TestEvent);
+    client_app.world_mut().client_trigger(Test);
 
     client_app.update();
     server_app.exchange_with_client(&mut client_app);
     server_app.update();
 
-    let client_events = server_app
-        .world()
-        .resource::<Events<FromClient<TestEvent>>>();
-    assert_eq!(client_events.len(), 1);
+    let reader = server_app.world().resource::<EventReader<Test>>();
+    assert_eq!(reader.events.len(), 1);
 }
 
 #[test]
-fn local_resending() {
+fn local_sending() {
     let mut app = App::new();
     app.add_plugins((TimePlugin, StatesPlugin, RepliconPlugins))
-        .add_client_event::<TestEvent>(Channel::Ordered)
+        .add_client_event::<Test>(Channel::Ordered)
         .finish();
+    app.init_resource::<EventReader<Test>>();
 
-    app.world_mut().send_event(TestEvent);
+    app.world_mut().client_trigger(Test);
 
+    // Requires 2 updates because local sending runs
+    // in `PostUpdate` and triggering runs in `PreUpdate`.
+    app.update();
     app.update();
 
-    let events = app.world().resource::<Events<TestEvent>>();
-    assert!(events.is_empty());
-
-    let client_events = app.world().resource::<Events<FromClient<TestEvent>>>();
-    assert_eq!(client_events.len(), 1);
+    let reader = app.world().resource::<EventReader<Test>>();
+    assert_eq!(reader.events.len(), 1);
 }
 
-#[derive(Event)]
-struct NonRemoteEvent;
-
-#[derive(Deserialize, Event, Serialize)]
-struct TestEvent;
+#[derive(Deserialize, Event, Serialize, Clone)]
+struct Test;
 
 #[derive(Deserialize, Event, Serialize, Clone, MapEntities)]
-struct EntityEvent(#[entities] Entity);
+struct WithEntity(#[entities] Entity);
+
+#[derive(Resource)]
+struct EventReader<E: Event> {
+    events: Vec<FromClient<E>>,
+}
+
+impl<E: Event + Clone> FromWorld for EventReader<E> {
+    fn from_world(world: &mut World) -> Self {
+        world.add_observer(|on: On<FromClient<E>>, mut reader: ResMut<Self>| {
+            reader.events.push(on.event().clone());
+        });
+
+        Self {
+            events: Default::default(),
+        }
+    }
+}
diff --git a/tests/client_message.rs b/tests/client_message.rs
new file mode 100644
index 00000000..faf93941
--- /dev/null
+++ b/tests/client_message.rs
@@ -0,0 +1,137 @@
+use bevy::{ecs::entity::MapEntities, prelude::*, state::app::StatesPlugin, time::TimePlugin};
+use bevy_replicon::{
+    prelude::*, shared::server_entity_map::ServerEntityMap, test_app::ServerTestAppExt,
+};
+use serde::{Deserialize, Serialize};
+use test_log::test;
+
+#[test]
+fn regular() {
+    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, StatesPlugin, RepliconPlugins))
+            .add_client_message::<Test>(Channel::Ordered)
+            .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    client_app.world_mut().write_message(Test);
+
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    server_app.update();
+
+    let messages = server_app.world().resource::<Messages<FromClient<Test>>>();
+    assert_eq!(messages.len(), 1);
+}
+
+#[test]
+fn mapped() {
+    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,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .add_mapped_client_message::<WithEntity>(Channel::Ordered)
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    let server_entity = server_app.world_mut().spawn(Replicated).id();
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    let client_entity = *client_app
+        .world()
+        .resource::<ServerEntityMap>()
+        .to_client()
+        .get(&server_entity)
+        .unwrap();
+
+    client_app
+        .world_mut()
+        .write_message(WithEntity(client_entity));
+
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    server_app.update();
+
+    let mapped_entities: Vec<_> = server_app
+        .world_mut()
+        .resource_mut::<Messages<FromClient<WithEntity>>>()
+        .drain()
+        .map(|event| event.0)
+        .collect();
+    assert_eq!(mapped_entities, [server_entity]);
+}
+
+#[test]
+fn without_plugins() {
+    let mut server_app = App::new();
+    let mut client_app = App::new();
+    server_app
+        .add_plugins((
+            MinimalPlugins,
+            StatesPlugin,
+            RepliconPlugins
+                .build()
+                .disable::<ClientPlugin>()
+                .disable::<ClientMessagePlugin>(),
+        ))
+        .add_client_message::<Test>(Channel::Ordered)
+        .finish();
+    client_app
+        .add_plugins((
+            MinimalPlugins,
+            StatesPlugin,
+            RepliconPlugins
+                .build()
+                .disable::<ServerPlugin>()
+                .disable::<ServerMessagePlugin>(),
+        ))
+        .add_client_message::<Test>(Channel::Ordered)
+        .finish();
+
+    server_app.connect_client(&mut client_app);
+
+    client_app.world_mut().write_message(Test);
+
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    server_app.update();
+
+    let messages = server_app.world().resource::<Messages<FromClient<Test>>>();
+    assert_eq!(messages.len(), 1);
+}
+
+#[test]
+fn local_sending() {
+    let mut app = App::new();
+    app.add_plugins((TimePlugin, StatesPlugin, RepliconPlugins))
+        .add_client_message::<Test>(Channel::Ordered)
+        .finish();
+
+    app.world_mut().write_message(Test);
+
+    app.update();
+
+    let messages = app.world().resource::<Messages<Test>>();
+    assert!(messages.is_empty());
+
+    let client_messages = app.world().resource::<Messages<FromClient<Test>>>();
+    assert_eq!(client_messages.len(), 1);
+}
+
+#[derive(Deserialize, Message, Serialize)]
+struct Test;
+
+#[derive(Deserialize, Message, Serialize, Clone, MapEntities)]
+struct WithEntity(#[entities] Entity);
diff --git a/tests/client_trigger.rs b/tests/client_trigger.rs
deleted file mode 100644
index 2967fbd3..00000000
--- a/tests/client_trigger.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-use bevy::{ecs::entity::MapEntities, prelude::*, state::app::StatesPlugin, time::TimePlugin};
-use bevy_replicon::{
-    prelude::*, shared::server_entity_map::ServerEntityMap, test_app::ServerTestAppExt,
-};
-use serde::{Deserialize, Serialize};
-use test_log::test;
-
-#[test]
-fn regular() {
-    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, StatesPlugin, RepliconPlugins))
-            .add_client_trigger::<TestEvent>(Channel::Ordered)
-            .finish();
-    }
-    server_app.init_resource::<TriggerReader<TestEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    client_app.world_mut().client_trigger(TestEvent);
-
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    server_app.update();
-
-    let reader = server_app.world().resource::<TriggerReader<TestEvent>>();
-    assert_eq!(reader.entities, [Entity::PLACEHOLDER]);
-}
-
-#[test]
-fn with_target() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_client_trigger::<TestEvent>(Channel::Ordered)
-        .finish();
-    }
-    server_app.init_resource::<TriggerReader<TestEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    let server_entity = server_app.world_mut().spawn(Replicated).id();
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let client_entity = *client_app
-        .world()
-        .resource::<ServerEntityMap>()
-        .to_client()
-        .get(&server_entity)
-        .unwrap();
-
-    client_app
-        .world_mut()
-        .client_trigger_targets(TestEvent, client_entity);
-
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    server_app.update();
-
-    let reader = server_app.world().resource::<TriggerReader<TestEvent>>();
-    assert_eq!(reader.entities, [server_entity]);
-}
-
-#[test]
-fn mapped() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_mapped_client_trigger::<EntityEvent>(Channel::Ordered)
-        .finish();
-    }
-    server_app.init_resource::<TriggerReader<EntityEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    let server_entity = server_app.world_mut().spawn(Replicated).id();
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let client_entity = *client_app
-        .world()
-        .resource::<ServerEntityMap>()
-        .to_client()
-        .get(&server_entity)
-        .unwrap();
-
-    client_app
-        .world_mut()
-        .client_trigger(EntityEvent(client_entity));
-
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    server_app.update();
-
-    let reader = server_app.world().resource::<TriggerReader<EntityEvent>>();
-    let mapped_entities: Vec<_> = reader.events.iter().map(|event| event.0).collect();
-    assert_eq!(mapped_entities, [server_entity]);
-}
-
-#[test]
-fn without_plugins() {
-    let mut server_app = App::new();
-    let mut client_app = App::new();
-    server_app
-        .add_plugins((
-            MinimalPlugins,
-            StatesPlugin,
-            RepliconPlugins
-                .build()
-                .disable::<ClientPlugin>()
-                .disable::<ClientEventPlugin>(),
-        ))
-        .add_client_trigger::<TestEvent>(Channel::Ordered)
-        .finish();
-    client_app
-        .add_plugins((
-            MinimalPlugins,
-            StatesPlugin,
-            RepliconPlugins
-                .build()
-                .disable::<ServerPlugin>()
-                .disable::<ServerEventPlugin>(),
-        ))
-        .add_client_trigger::<TestEvent>(Channel::Ordered)
-        .finish();
-    server_app.init_resource::<TriggerReader<TestEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    client_app.world_mut().client_trigger(TestEvent);
-
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    server_app.update();
-
-    let reader = server_app.world().resource::<TriggerReader<TestEvent>>();
-    assert_eq!(reader.events.len(), 1);
-}
-
-#[test]
-fn local_resending() {
-    let mut app = App::new();
-    app.add_plugins((TimePlugin, StatesPlugin, RepliconPlugins))
-        .add_client_trigger::<TestEvent>(Channel::Ordered)
-        .finish();
-    app.init_resource::<TriggerReader<TestEvent>>();
-
-    app.world_mut().client_trigger(TestEvent);
-
-    // Requires 2 updates because local resending runs
-    // in `PostUpdate` and triggering runs in `PreUpdate`.
-    app.update();
-    app.update();
-
-    let reader = app.world().resource::<TriggerReader<TestEvent>>();
-    assert_eq!(reader.events.len(), 1);
-}
-
-#[derive(Deserialize, Event, Serialize, Clone)]
-struct TestEvent;
-
-#[derive(Deserialize, Event, Serialize, Clone, MapEntities)]
-struct EntityEvent(#[entities] Entity);
-
-#[derive(Resource)]
-struct TriggerReader<E: Event> {
-    events: Vec<FromClient<E>>,
-    entities: Vec<Entity>,
-}
-
-impl<E: Event + Clone> FromWorld for TriggerReader<E> {
-    fn from_world(world: &mut World) -> Self {
-        world.add_observer(
-            |trigger: Trigger<FromClient<E>>, mut counter: ResMut<Self>| {
-                counter.events.push(trigger.event().clone());
-                counter.entities.push(trigger.target());
-            },
-        );
-
-        Self {
-            events: Default::default(),
-            entities: Default::default(),
-        }
-    }
-}
diff --git a/tests/connection.rs b/tests/connection.rs
index 6c36c667..40fe0d03 100644
--- a/tests/connection.rs
+++ b/tests/connection.rs
@@ -73,10 +73,10 @@ fn protocol_mismatch() {
     let mut client_app = App::new();
     server_app
         .add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins))
-        .add_client_event::<TestEvent>(Channel::Ordered)
+        .add_client_message::<Test>(Channel::Ordered)
         .finish();
     client_app
-        .init_resource::<TriggerCounter<ProtocolMismatch>>()
+        .init_resource::<EventCounter<ProtocolMismatch>>()
         .add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins))
         .finish();
 
@@ -89,8 +89,8 @@ fn protocol_mismatch() {
 
     let counter = client_app
         .world()
-        .resource::<TriggerCounter<ProtocolMismatch>>();
-    assert_eq!(counter.triggers, 1);
+        .resource::<EventCounter<ProtocolMismatch>>();
+    assert_eq!(counter.events, 1);
 }
 
 #[test]
@@ -145,23 +145,23 @@ fn network_id_map() {
     assert!(app.world().resource::<NetworkIdMap>().is_empty());
 }
 
-#[derive(Event, Serialize, Deserialize)]
-struct TestEvent;
+#[derive(Message, Serialize, Deserialize)]
+struct Test;
 
 #[derive(Resource)]
-struct TriggerCounter<E: Event> {
-    triggers: usize,
+struct EventCounter<E: Event> {
+    events: usize,
     marker: PhantomData<E>,
 }
 
-impl<E: Event> FromWorld for TriggerCounter<E> {
+impl<E: Event> FromWorld for EventCounter<E> {
     fn from_world(world: &mut World) -> Self {
-        world.add_observer(|_trigger: Trigger<E>, mut counter: ResMut<Self>| {
-            counter.triggers += 1;
+        world.add_observer(|_on: On<E>, mut counter: ResMut<Self>| {
+            counter.events += 1;
         });
 
         Self {
-            triggers: 0,
+            events: 0,
             marker: PhantomData,
         }
     }
diff --git a/tests/insertion.rs b/tests/insertion.rs
index 4a8d3137..fa2c48ee 100644
--- a/tests/insertion.rs
+++ b/tests/insertion.rs
@@ -589,10 +589,10 @@ fn confirm_history() {
 
     server_app.world_mut().entity_mut(server_entity).insert(A);
 
-    // Clear previous events.
+    // Clear previous messages.
     client_app
         .world_mut()
-        .resource_mut::<Events<EntityReplicated>>()
+        .resource_mut::<Messages<EntityReplicated>>()
         .clear();
 
     server_app.update();
@@ -608,16 +608,12 @@ fn confirm_history() {
         .unwrap();
     assert!(confirm_history.contains(tick));
 
-    let mut replicated_events = client_app
+    let mut replicated = client_app
         .world_mut()
-        .resource_mut::<Events<EntityReplicated>>();
-    let [event] = replicated_events
-        .drain()
-        .collect::<Vec<_>>()
-        .try_into()
-        .unwrap();
-    assert_eq!(event.entity, client_entity);
-    assert_eq!(event.tick, tick);
+        .resource_mut::<Messages<EntityReplicated>>();
+    let [replicated] = replicated.drain().collect::<Vec<_>>().try_into().unwrap();
+    assert_eq!(replicated.entity, client_entity);
+    assert_eq!(replicated.tick, tick);
 }
 
 #[derive(Component, Deserialize, Serialize)]
diff --git a/tests/mutate_ticks.rs b/tests/mutate_ticks.rs
index 20a2a743..cc7a67e5 100644
--- a/tests/mutate_ticks.rs
+++ b/tests/mutate_ticks.rs
@@ -31,14 +31,14 @@ fn without_changes() {
     client_app.update();
     server_app.exchange_with_client(&mut client_app);
 
-    let events_count = client_app
+    let messages_count = client_app
         .world_mut()
-        .resource_mut::<Events<MutateTickReceived>>()
+        .resource_mut::<Messages<MutateTickReceived>>()
         .drain()
         .count();
     assert_eq!(
-        events_count, 2,
-        "should receive one event for connection and one for the exchange"
+        messages_count, 2,
+        "should receive one message for connection and one for the exchange"
     );
 }
 
@@ -69,13 +69,13 @@ fn one_message() {
     client_app.update();
     server_app.exchange_with_client(&mut client_app);
 
-    let mut tick_events = client_app
+    let mut received_ticks = client_app
         .world_mut()
-        .resource_mut::<Events<MutateTickReceived>>();
+        .resource_mut::<Messages<MutateTickReceived>>();
     assert_eq!(
-        tick_events.drain().count(),
+        received_ticks.drain().count(),
         2,
-        "should receive one event for connection and one for spawn"
+        "should receive one message for connection and one for spawn"
     );
 
     // Change value.
@@ -85,10 +85,10 @@ fn one_message() {
         .unwrap();
     component.0 = true;
 
-    // Clear previous events.
+    // Clear previous messages.
     client_app
         .world_mut()
-        .resource_mut::<Events<MutateTickReceived>>()
+        .resource_mut::<Messages<MutateTickReceived>>()
         .clear();
 
     server_app.update();
@@ -97,11 +97,15 @@ fn one_message() {
 
     let tick = **server_app.world().resource::<ServerTick>();
 
-    let mut tick_events = client_app
+    let mut received_ticks = client_app
         .world_mut()
-        .resource_mut::<Events<MutateTickReceived>>();
-    let [event] = tick_events.drain().collect::<Vec<_>>().try_into().unwrap();
-    assert_eq!(event.tick, tick);
+        .resource_mut::<Messages<MutateTickReceived>>();
+    let [received_tick] = received_ticks
+        .drain()
+        .collect::<Vec<_>>()
+        .try_into()
+        .unwrap();
+    assert_eq!(received_tick.tick, tick);
 
     let mutate_ticks = client_app.world().resource::<ServerMutateTicks>();
     assert!(mutate_ticks.contains(tick));
@@ -138,13 +142,13 @@ fn multiple_messages() {
     let mut replicated = client_app.world_mut().query::<&Replicated>();
     assert_eq!(replicated.iter(client_app.world()).len(), ENTITIES_COUNT);
 
-    let mut tick_events = client_app
+    let mut received_ticks = client_app
         .world_mut()
-        .resource_mut::<Events<MutateTickReceived>>();
+        .resource_mut::<Messages<MutateTickReceived>>();
     assert_eq!(
-        tick_events.drain().count(),
+        received_ticks.drain().count(),
         2,
-        "should receive one event for connection and one for spawns"
+        "should receive one message for connection and one for spawns"
     );
 
     for mut component in server_app
@@ -161,11 +165,15 @@ fn multiple_messages() {
 
     let tick = **server_app.world().resource::<ServerTick>();
 
-    let mut tick_events = client_app
+    let mut received_ticks = client_app
         .world_mut()
-        .resource_mut::<Events<MutateTickReceived>>();
-    let [event] = tick_events.drain().collect::<Vec<_>>().try_into().unwrap();
-    assert_eq!(event.tick, tick);
+        .resource_mut::<Messages<MutateTickReceived>>();
+    let [received_tick] = received_ticks
+        .drain()
+        .collect::<Vec<_>>()
+        .try_into()
+        .unwrap();
+    assert_eq!(received_tick.tick, tick);
 
     let mutate_ticks = client_app.world().resource::<ServerMutateTicks>();
     assert!(mutate_ticks.contains(tick));
diff --git a/tests/mutations.rs b/tests/mutations.rs
index fe133dc4..7a6a65d5 100644
--- a/tests/mutations.rs
+++ b/tests/mutations.rs
@@ -1060,10 +1060,10 @@ fn confirm_history() {
         .unwrap();
     component.0 = true;
 
-    // Clear previous events.
+    // Clear previous messages.
     client_app
         .world_mut()
-        .resource_mut::<Events<EntityReplicated>>()
+        .resource_mut::<Messages<EntityReplicated>>()
         .clear();
 
     server_app.update();
@@ -1079,16 +1079,12 @@ fn confirm_history() {
         .unwrap();
     assert!(confirm_history.contains(tick));
 
-    let mut replicated_events = client_app
+    let mut replicated = client_app
         .world_mut()
-        .resource_mut::<Events<EntityReplicated>>();
-    let [event] = replicated_events
-        .drain()
-        .collect::<Vec<_>>()
-        .try_into()
-        .unwrap();
-    assert_eq!(event.entity, client_entity);
-    assert_eq!(event.tick, tick);
+        .resource_mut::<Messages<EntityReplicated>>();
+    let [replicated] = replicated.drain().collect::<Vec<_>>().try_into().unwrap();
+    assert_eq!(replicated.entity, client_entity);
+    assert_eq!(replicated.tick, tick);
 }
 
 #[test]
diff --git a/tests/removal.rs b/tests/removal.rs
index 01716456..f12a8f1e 100644
--- a/tests/removal.rs
+++ b/tests/removal.rs
@@ -416,10 +416,10 @@ fn confirm_history() {
         .entity_mut(server_entity)
         .remove::<A>();
 
-    // Clear previous events.
+    // Clear previous messages.
     client_app
         .world_mut()
-        .resource_mut::<Events<EntityReplicated>>()
+        .resource_mut::<Messages<EntityReplicated>>()
         .clear();
 
     server_app.update();
@@ -434,16 +434,12 @@ fn confirm_history() {
         .unwrap();
     assert!(confirm_history.contains(tick));
 
-    let mut replicated_events = client_app
+    let mut replicated = client_app
         .world_mut()
-        .resource_mut::<Events<EntityReplicated>>();
-    let [event] = replicated_events
-        .drain()
-        .collect::<Vec<_>>()
-        .try_into()
-        .unwrap();
-    assert_eq!(event.entity, client_entity);
-    assert_eq!(event.tick, tick);
+        .resource_mut::<Messages<EntityReplicated>>();
+    let [replicated] = replicated.drain().collect::<Vec<_>>().try_into().unwrap();
+    assert_eq!(replicated.entity, client_entity);
+    assert_eq!(replicated.tick, tick);
 }
 
 #[test]
diff --git a/tests/server_event.rs b/tests/server_event.rs
index 6b52e767..459fc01c 100644
--- a/tests/server_event.rs
+++ b/tests/server_event.rs
@@ -1,36 +1,11 @@
-use bevy::{
-    ecs::{entity::MapEntities, event::Events},
-    prelude::*,
-    state::app::StatesPlugin,
-    time::TimePlugin,
-};
+use bevy::{ecs::entity::MapEntities, prelude::*, state::app::StatesPlugin, time::TimePlugin};
 use bevy_replicon::{
-    client::ServerUpdateTick,
-    prelude::*,
-    server::server_tick::ServerTick,
-    shared::{event::registry::RemoteEventRegistry, server_entity_map::ServerEntityMap},
-    test_app::{ServerTestAppExt, TestClientEntity},
+    client::ServerUpdateTick, prelude::*, shared::server_entity_map::ServerEntityMap,
+    test_app::ServerTestAppExt,
 };
 use serde::{Deserialize, Serialize};
 use test_log::test;
 
-#[test]
-fn channels() {
-    let mut app = App::new();
-    app.add_plugins((
-        MinimalPlugins,
-        StatesPlugin,
-        RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-    ))
-    .add_event::<NonRemoteEvent>()
-    .add_server_event::<TestEvent>(Channel::Ordered)
-    .finish();
-
-    let event_registry = app.world().resource::<RemoteEventRegistry>();
-    assert_eq!(event_registry.server_channel::<NonRemoteEvent>(), None);
-    assert_eq!(event_registry.server_channel::<TestEvent>(), Some(3));
-}
-
 #[test]
 fn regular() {
     let mut server_app = App::new();
@@ -41,37 +16,24 @@ fn regular() {
             StatesPlugin,
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
         ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
+        .add_server_event::<Test>(Channel::Ordered)
         .finish();
     }
+    client_app.init_resource::<EventReader<Test>>();
 
     server_app.connect_client(&mut client_app);
 
-    let client = **client_app.world().resource::<TestClientEntity>();
-    for (mode, events_count) in [
-        (SendMode::Broadcast, 1),
-        (SendMode::Direct(ClientId::Server), 0),
-        (SendMode::Direct(client.into()), 1),
-        (SendMode::BroadcastExcept(ClientId::Server), 1),
-        (SendMode::BroadcastExcept(client.into()), 0),
-    ] {
-        server_app.world_mut().send_event(ToClients {
-            mode,
-            event: TestEvent,
-        });
+    server_app.world_mut().server_trigger(ToClients {
+        mode: SendMode::Broadcast,
+        message: Test,
+    });
 
-        server_app.update();
-        server_app.exchange_with_client(&mut client_app);
-        client_app.update();
-        server_app.exchange_with_client(&mut client_app);
-
-        let mut events = client_app.world_mut().resource_mut::<Events<TestEvent>>();
-        assert_eq!(
-            events.drain().count(),
-            events_count,
-            "event should be emitted {events_count} times for {mode:?}"
-        );
-    }
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    let reader = client_app.world().resource::<EventReader<Test>>();
+    assert_eq!(reader.events.len(), 1);
 }
 
 #[test]
@@ -84,17 +46,18 @@ fn mapped() {
             StatesPlugin,
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
         ))
-        .add_mapped_server_event::<EntityEvent>(Channel::Ordered)
+        .add_mapped_server_event::<WithEntity>(Channel::Ordered)
         .finish();
     }
+    client_app.init_resource::<EventReader<WithEntity>>();
 
     server_app.connect_client(&mut client_app);
 
     let server_entity = server_app.world_mut().spawn(Replicated).id();
 
-    server_app.world_mut().send_event(ToClients {
+    server_app.world_mut().server_trigger(ToClients {
         mode: SendMode::Broadcast,
-        event: EntityEvent(server_entity),
+        message: WithEntity(server_entity),
     });
 
     server_app.update();
@@ -108,12 +71,8 @@ fn mapped() {
         .get(&server_entity)
         .unwrap();
 
-    let mapped_entities: Vec<_> = client_app
-        .world_mut()
-        .resource_mut::<Events<EntityEvent>>()
-        .drain()
-        .map(|event| event.0)
-        .collect();
+    let reader = client_app.world().resource::<EventReader<WithEntity>>();
+    let mapped_entities: Vec<_> = reader.events.iter().map(|event| event.0).collect();
     assert_eq!(mapped_entities, [client_entity]);
 }
 
@@ -129,9 +88,9 @@ fn without_plugins() {
                 .build()
                 .set(ServerPlugin::new(PostUpdate))
                 .disable::<ClientPlugin>()
-                .disable::<ClientEventPlugin>(),
+                .disable::<ClientMessagePlugin>(),
         ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
+        .add_server_event::<Test>(Channel::Ordered)
         .finish();
     client_app
         .add_plugins((
@@ -140,285 +99,51 @@ fn without_plugins() {
             RepliconPlugins
                 .build()
                 .disable::<ServerPlugin>()
-                .disable::<ServerEventPlugin>(),
+                .disable::<ServerMessagePlugin>(),
         ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
+        .add_server_event::<Test>(Channel::Ordered)
         .finish();
+    client_app.init_resource::<EventReader<Test>>();
 
     server_app.connect_client(&mut client_app);
 
-    let client = **client_app.world().resource::<TestClientEntity>();
-    for (mode, events_count) in [
-        (SendMode::Broadcast, 1),
-        (SendMode::Direct(ClientId::Server), 0),
-        (SendMode::Direct(client.into()), 1),
-        (SendMode::BroadcastExcept(ClientId::Server), 1),
-        (SendMode::BroadcastExcept(client.into()), 0),
-    ] {
-        server_app.world_mut().send_event(ToClients {
-            mode,
-            event: TestEvent,
-        });
+    server_app.world_mut().server_trigger(ToClients {
+        mode: SendMode::Broadcast,
+        message: Test,
+    });
 
-        server_app.update();
-        server_app.exchange_with_client(&mut client_app);
-        client_app.update();
-        server_app.exchange_with_client(&mut client_app);
-
-        let mut events = client_app.world_mut().resource_mut::<Events<TestEvent>>();
-        assert_eq!(
-            events.drain().count(),
-            events_count,
-            "event should be emitted {events_count} times for {mode:?}"
-        );
-    }
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    let reader = client_app.world().resource::<EventReader<Test>>();
+    assert_eq!(reader.events.len(), 1);
 }
 
 #[test]
-fn local_resending() {
+fn local_sending() {
     let mut app = App::new();
     app.add_plugins((
         TimePlugin,
         StatesPlugin,
         RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
     ))
-    .add_server_event::<TestEvent>(Channel::Ordered)
+    .add_server_event::<Test>(Channel::Ordered)
     .finish();
+    app.init_resource::<EventReader<Test>>();
 
-    const PLACEHOLDER_CLIENT_ID: ClientId = ClientId::Client(Entity::from_raw(1));
-    for (mode, events_count) in [
-        (SendMode::Broadcast, 1),
-        (SendMode::Direct(ClientId::Server), 1),
-        (SendMode::Direct(PLACEHOLDER_CLIENT_ID), 0),
-        (SendMode::BroadcastExcept(ClientId::Server), 0),
-        (SendMode::BroadcastExcept(PLACEHOLDER_CLIENT_ID), 1),
-    ] {
-        app.world_mut().send_event(ToClients {
-            mode,
-            event: TestEvent,
-        });
-
-        app.update();
-
-        let server_events = app.world().resource::<Events<ToClients<TestEvent>>>();
-        assert!(server_events.is_empty());
-
-        let mut events = app.world_mut().resource_mut::<Events<TestEvent>>();
-        assert_eq!(
-            events.drain().count(),
-            events_count,
-            "event should be emitted {events_count} times for {mode:?}"
-        );
-    }
-}
-
-#[test]
-fn server_buffering() {
-    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, StatesPlugin, RepliconPlugins))
-            .add_server_event::<TestEvent>(Channel::Ordered)
-            .finish();
-    }
-
-    server_app.connect_client(&mut client_app);
-
-    server_app.world_mut().send_event(ToClients {
-        mode: SendMode::Broadcast,
-        event: TestEvent,
-    });
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert!(events.is_empty(), "event should be buffered on server");
-
-    // Trigger replication.
-    server_app
-        .world_mut()
-        .resource_mut::<ServerTick>()
-        .increment();
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert_eq!(events.len(), 1);
-}
-
-#[test]
-fn client_queue() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
-        .finish();
-    }
-
-    server_app.connect_client(&mut client_app);
-
-    // Spawn entity to trigger world change.
-    server_app.world_mut().spawn(Replicated);
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-
-    // Artificially reset the update tick to force the next received event to be queued.
-    let mut update_tick = client_app.world_mut().resource_mut::<ServerUpdateTick>();
-    let previous_tick = *update_tick;
-    *update_tick = Default::default();
-    server_app.world_mut().send_event(ToClients {
-        mode: SendMode::Broadcast,
-        event: TestEvent,
-    });
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert!(events.is_empty());
-
-    // Restore the update tick to receive the event.
-    *client_app.world_mut().resource_mut::<ServerUpdateTick>() = previous_tick;
-
-    client_app.update();
-
-    assert_eq!(client_app.world().resource::<Events<TestEvent>>().len(), 1);
-}
-
-#[test]
-fn client_queue_and_mapping() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_mapped_server_event::<EntityEvent>(Channel::Ordered)
-        .finish();
-    }
-
-    server_app.connect_client(&mut client_app);
-
-    // Spawn an entity to trigger world change.
-    let server_entity = server_app.world_mut().spawn(Replicated).id();
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-
-    // Artificially reset the update tick to force the next received event to be queued.
-    let mut update_tick = client_app.world_mut().resource_mut::<ServerUpdateTick>();
-    let previous_tick = *update_tick;
-    *update_tick = Default::default();
-    server_app.world_mut().send_event(ToClients {
-        mode: SendMode::Broadcast,
-        event: EntityEvent(server_entity),
-    });
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let events = client_app.world().resource::<Events<EntityEvent>>();
-    assert!(events.is_empty());
-
-    // Restore the update tick to receive the event.
-    *client_app.world_mut().resource_mut::<ServerUpdateTick>() = previous_tick;
-
-    client_app.update();
-
-    let client_entity = *client_app
-        .world()
-        .resource::<ServerEntityMap>()
-        .to_client()
-        .get(&server_entity)
-        .unwrap();
-
-    let mapped_entities: Vec<_> = client_app
-        .world_mut()
-        .resource_mut::<Events<EntityEvent>>()
-        .drain()
-        .map(|event| event.0)
-        .collect();
-    assert_eq!(mapped_entities, [client_entity]);
-}
-
-#[test]
-fn multiple_client_queues() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
-        .add_server_event::<EntityEvent>(Channel::Ordered) // Use as a regular event with a different serialization size.
-        .finish();
-    }
-
-    server_app.connect_client(&mut client_app);
-
-    // Spawn entity to trigger world change.
-    server_app.world_mut().spawn(Replicated);
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-
-    // Artificially reset the update tick to force the next received event to be queued.
-    let mut update_tick = client_app.world_mut().resource_mut::<ServerUpdateTick>();
-    let previous_tick = *update_tick;
-    *update_tick = Default::default();
-    server_app.world_mut().send_event(ToClients {
-        mode: SendMode::Broadcast,
-        event: TestEvent,
-    });
-    server_app.world_mut().send_event(ToClients {
+    app.world_mut().server_trigger(ToClients {
         mode: SendMode::Broadcast,
-        event: EntityEvent(Entity::PLACEHOLDER),
+        message: Test,
     });
 
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert!(events.is_empty());
-
-    let mapped_events = client_app.world().resource::<Events<EntityEvent>>();
-    assert!(mapped_events.is_empty());
-
-    // Restore the update tick to receive the event.
-    *client_app.world_mut().resource_mut::<ServerUpdateTick>() = previous_tick;
-
-    client_app.update();
+    // Requires 2 updates because local sending runs
+    // in `PostUpdate` and triggering runs in `PreUpdate`.
+    app.update();
+    app.update();
 
-    assert_eq!(client_app.world().resource::<Events<TestEvent>>().len(), 1);
-    assert_eq!(
-        client_app.world().resource::<Events<EntityEvent>>().len(),
-        1
-    );
+    let reader = app.world().resource::<EventReader<Test>>();
+    assert_eq!(reader.events.len(), 1);
 }
 
 #[test]
@@ -431,11 +156,14 @@ fn independent() {
             StatesPlugin,
             RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
         ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
-        .add_server_event::<IndependentEvent>(Channel::Ordered)
-        .make_event_independent::<IndependentEvent>()
+        .add_server_event::<Test>(Channel::Ordered)
+        .add_server_event::<Independent>(Channel::Ordered)
+        .make_event_independent::<Independent>()
         .finish();
     }
+    client_app
+        .init_resource::<EventReader<Test>>()
+        .init_resource::<EventReader<Independent>>();
 
     server_app.connect_client(&mut client_app);
 
@@ -452,187 +180,48 @@ 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::<TestClientEntity>();
-    for (mode, events_count) in [
-        (SendMode::Broadcast, 1),
-        (SendMode::Direct(ClientId::Server), 0),
-        (SendMode::Direct(client.into()), 1),
-        (SendMode::BroadcastExcept(ClientId::Server), 1),
-        (SendMode::BroadcastExcept(client.into()), 0),
-    ] {
-        server_app.world_mut().send_event(ToClients {
-            mode,
-            event: TestEvent,
-        });
-        server_app.world_mut().send_event(ToClients {
-            mode,
-            event: IndependentEvent,
-        });
-
-        server_app.update();
-        server_app.exchange_with_client(&mut client_app);
-        client_app.update();
-        server_app.exchange_with_client(&mut client_app);
-
-        let events = client_app.world().resource::<Events<TestEvent>>();
-        assert!(events.is_empty());
-
-        // Event should have already been triggered, even without resetting the tick,
-        // since it's independent.
-        let mut independent_events = client_app
-            .world_mut()
-            .resource_mut::<Events<IndependentEvent>>();
-        assert_eq!(
-            independent_events.drain().count(),
-            events_count,
-            "event should be emitted {events_count} times for {mode:?}"
-        );
-    }
-}
-
-#[test]
-fn before_started_replication() {
-    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,
-            StatesPlugin,
-            RepliconPlugins
-                .set(ServerPlugin::new(PostUpdate))
-                .set(RepliconSharedPlugin {
-                    auth_method: AuthMethod::Custom,
-                }),
-        ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
-        .finish();
-    }
-
-    server_app.connect_client(&mut client_app);
-
-    let client = **client_app.world().resource::<TestClientEntity>();
-    for mode in [
-        SendMode::Broadcast,
-        SendMode::BroadcastExcept(ClientId::Server),
-        SendMode::Direct(client.into()),
-    ] {
-        server_app.world_mut().send_event(ToClients {
-            mode,
-            event: TestEvent,
-        });
-    }
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert!(events.is_empty());
-}
-
-#[test]
-fn independent_before_started_replication() {
-    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,
-            StatesPlugin,
-            RepliconPlugins
-                .set(ServerPlugin::new(PostUpdate))
-                .set(RepliconSharedPlugin {
-                    auth_method: AuthMethod::Custom,
-                }),
-        ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
-        .add_server_event::<IndependentEvent>(Channel::Ordered)
-        .make_event_independent::<IndependentEvent>()
-        .finish();
-    }
-
-    server_app.connect_client(&mut client_app);
-
-    // Spawn entity to trigger world change.
-    server_app.world_mut().spawn(Replicated);
-
-    server_app.world_mut().send_event(ToClients {
+    server_app.world_mut().server_trigger(ToClients {
         mode: SendMode::Broadcast,
-        event: TestEvent,
+        message: Test,
     });
-    server_app.world_mut().send_event(ToClients {
+    server_app.world_mut().server_trigger(ToClients {
         mode: SendMode::Broadcast,
-        event: IndependentEvent,
+        message: Independent,
     });
 
     server_app.update();
     server_app.exchange_with_client(&mut client_app);
     client_app.update();
-    server_app.exchange_with_client(&mut client_app);
 
-    let events = client_app.world().resource::<Events<TestEvent>>();
-    assert!(events.is_empty());
+    let reader = client_app.world().resource::<EventReader<Test>>();
+    assert!(reader.events.is_empty());
 
-    let independent_events = client_app.world().resource::<Events<IndependentEvent>>();
-    assert_eq!(independent_events.len(), 1);
+    let independent_reader = client_app.world().resource::<EventReader<Independent>>();
+    assert_eq!(independent_reader.events.len(), 1);
 }
 
-#[test]
-fn different_ticks() {
-    let mut server_app = App::new();
-    let mut client_app1 = App::new();
-    let mut client_app2 = App::new();
-    for app in [&mut server_app, &mut client_app1, &mut client_app2] {
-        app.add_plugins((
-            MinimalPlugins,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_server_event::<TestEvent>(Channel::Ordered)
-        .finish();
-    }
-
-    // Connect client 1 first.
-    server_app.connect_client(&mut client_app1);
-
-    // Spawn entity to trigger world change.
-    server_app.world_mut().spawn(Replicated);
-
-    // Update client 1 to initialize their replicon tick.
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app1);
-    client_app1.update();
-    server_app.exchange_with_client(&mut client_app1);
+#[derive(Event, Serialize, Deserialize, Clone)]
+struct Test;
 
-    // Connect client 2 later to make it have a higher replicon tick than client 1,
-    // since only client 1 will receive a update message here.
-    server_app.connect_client(&mut client_app2);
+#[derive(Event, Serialize, Deserialize, Clone)]
+struct Independent;
 
-    server_app.world_mut().send_event(ToClients {
-        mode: SendMode::Broadcast,
-        event: TestEvent,
-    });
+#[derive(Event, Serialize, Deserialize, MapEntities, Clone)]
+struct WithEntity(#[entities] Entity);
 
-    // If any client does not have a replicon tick >= the update tick associated with this event,
-    // then they will not receive the event until their replicon tick is updated.
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app1);
-    server_app.exchange_with_client(&mut client_app2);
-    client_app1.update();
-    client_app2.update();
-
-    assert_eq!(client_app1.world().resource::<Events<TestEvent>>().len(), 1);
-    assert_eq!(client_app2.world().resource::<Events<TestEvent>>().len(), 1);
+#[derive(Resource)]
+struct EventReader<E: Event> {
+    events: Vec<E>,
 }
 
-#[derive(Event)]
-struct NonRemoteEvent;
-
-#[derive(Event, Serialize, Deserialize)]
-struct TestEvent;
-
-#[derive(Event, Serialize, Deserialize)]
-struct IndependentEvent;
+impl<E: Event + Clone> FromWorld for EventReader<E> {
+    fn from_world(world: &mut World) -> Self {
+        world.add_observer(|on: On<E>, mut reader: ResMut<Self>| {
+            reader.events.push(on.event().clone());
+        });
 
-#[derive(Event, Serialize, Deserialize, MapEntities)]
-struct EntityEvent(#[entities] Entity);
+        Self {
+            events: Default::default(),
+        }
+    }
+}
diff --git a/tests/server_message.rs b/tests/server_message.rs
new file mode 100644
index 00000000..1b42d3f1
--- /dev/null
+++ b/tests/server_message.rs
@@ -0,0 +1,618 @@
+use bevy::{ecs::entity::MapEntities, prelude::*, state::app::StatesPlugin, time::TimePlugin};
+use bevy_replicon::{
+    client::ServerUpdateTick,
+    prelude::*,
+    server::server_tick::ServerTick,
+    shared::server_entity_map::ServerEntityMap,
+    test_app::{ServerTestAppExt, TestClientEntity},
+};
+use serde::{Deserialize, Serialize};
+use test_log::test;
+
+#[test]
+fn regular() {
+    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,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    let client = **client_app.world().resource::<TestClientEntity>();
+    for (mode, messages_count) in [
+        (SendMode::Broadcast, 1),
+        (SendMode::Direct(ClientId::Server), 0),
+        (SendMode::Direct(client.into()), 1),
+        (SendMode::BroadcastExcept(ClientId::Server), 1),
+        (SendMode::BroadcastExcept(client.into()), 0),
+    ] {
+        server_app.world_mut().write_message(ToClients {
+            mode,
+            message: Test,
+        });
+
+        server_app.update();
+        server_app.exchange_with_client(&mut client_app);
+        client_app.update();
+        server_app.exchange_with_client(&mut client_app);
+
+        let mut messages = client_app.world_mut().resource_mut::<Messages<Test>>();
+        assert_eq!(
+            messages.drain().count(),
+            messages_count,
+            "message should be received {messages_count} times for {mode:?}"
+        );
+    }
+}
+
+#[test]
+fn mapped() {
+    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,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .add_mapped_server_message::<WithEntity>(Channel::Ordered)
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    let server_entity = server_app.world_mut().spawn(Replicated).id();
+
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: WithEntity(server_entity),
+    });
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    let client_entity = *client_app
+        .world()
+        .resource::<ServerEntityMap>()
+        .to_client()
+        .get(&server_entity)
+        .unwrap();
+
+    let mapped_entities: Vec<_> = client_app
+        .world_mut()
+        .resource_mut::<Messages<WithEntity>>()
+        .drain()
+        .map(|m| m.0)
+        .collect();
+    assert_eq!(mapped_entities, [client_entity]);
+}
+
+#[test]
+fn without_plugins() {
+    let mut server_app = App::new();
+    let mut client_app = App::new();
+    server_app
+        .add_plugins((
+            MinimalPlugins,
+            StatesPlugin,
+            RepliconPlugins
+                .build()
+                .set(ServerPlugin::new(PostUpdate))
+                .disable::<ClientPlugin>()
+                .disable::<ClientMessagePlugin>(),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .finish();
+    client_app
+        .add_plugins((
+            MinimalPlugins,
+            StatesPlugin,
+            RepliconPlugins
+                .build()
+                .disable::<ServerPlugin>()
+                .disable::<ServerMessagePlugin>(),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .finish();
+
+    server_app.connect_client(&mut client_app);
+
+    let client = **client_app.world().resource::<TestClientEntity>();
+    for (mode, messages_count) in [
+        (SendMode::Broadcast, 1),
+        (SendMode::Direct(ClientId::Server), 0),
+        (SendMode::Direct(client.into()), 1),
+        (SendMode::BroadcastExcept(ClientId::Server), 1),
+        (SendMode::BroadcastExcept(client.into()), 0),
+    ] {
+        server_app.world_mut().write_message(ToClients {
+            mode,
+            message: Test,
+        });
+
+        server_app.update();
+        server_app.exchange_with_client(&mut client_app);
+        client_app.update();
+        server_app.exchange_with_client(&mut client_app);
+
+        let mut messages = client_app.world_mut().resource_mut::<Messages<Test>>();
+        assert_eq!(
+            messages.drain().count(),
+            messages_count,
+            "message should be received {messages_count} times for {mode:?}"
+        );
+    }
+}
+
+#[test]
+fn local_sending() {
+    let mut app = App::new();
+    app.add_plugins((
+        TimePlugin,
+        StatesPlugin,
+        RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+    ))
+    .add_server_message::<Test>(Channel::Ordered)
+    .finish();
+
+    const CLIENT_ENTITY: Entity = Entity::from_raw_u32(1).unwrap();
+    const PLACEHOLDER_CLIENT_ID: ClientId = ClientId::Client(CLIENT_ENTITY);
+    for (mode, messages_count) in [
+        (SendMode::Broadcast, 1),
+        (SendMode::Direct(ClientId::Server), 1),
+        (SendMode::Direct(PLACEHOLDER_CLIENT_ID), 0),
+        (SendMode::BroadcastExcept(ClientId::Server), 0),
+        (SendMode::BroadcastExcept(PLACEHOLDER_CLIENT_ID), 1),
+    ] {
+        app.world_mut().write_message(ToClients {
+            mode,
+            message: Test,
+        });
+
+        app.update();
+
+        let server_messages = app.world().resource::<Messages<ToClients<Test>>>();
+        assert!(server_messages.is_empty());
+
+        let mut messages = app.world_mut().resource_mut::<Messages<Test>>();
+        assert_eq!(
+            messages.drain().count(),
+            messages_count,
+            "message should be received {messages_count} times for {mode:?}"
+        );
+    }
+}
+
+#[test]
+fn server_buffering() {
+    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, StatesPlugin, RepliconPlugins))
+            .add_server_message::<Test>(Channel::Ordered)
+            .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: Test,
+    });
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    let messages = client_app.world().resource::<Messages<Test>>();
+    assert!(messages.is_empty(), "message should be buffered on server");
+
+    // Trigger replication.
+    server_app
+        .world_mut()
+        .resource_mut::<ServerTick>()
+        .increment();
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    let messages = client_app.world().resource::<Messages<Test>>();
+    assert_eq!(messages.len(), 1);
+}
+
+#[test]
+fn client_queue() {
+    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,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    // Spawn entity to trigger world change.
+    server_app.world_mut().spawn(Replicated);
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    // Artificially reset the update tick to force the next received message to be queued.
+    let mut update_tick = client_app.world_mut().resource_mut::<ServerUpdateTick>();
+    let previous_tick = *update_tick;
+    *update_tick = Default::default();
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: Test,
+    });
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    let messages = client_app.world().resource::<Messages<Test>>();
+    assert!(messages.is_empty());
+
+    // Restore the update tick to receive the message.
+    *client_app.world_mut().resource_mut::<ServerUpdateTick>() = previous_tick;
+
+    client_app.update();
+
+    let messages = client_app.world().resource::<Messages<Test>>();
+    assert_eq!(messages.len(), 1);
+}
+
+#[test]
+fn client_queue_and_mapping() {
+    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,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .add_mapped_server_message::<WithEntity>(Channel::Ordered)
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    // Spawn an entity to trigger world change.
+    let server_entity = server_app.world_mut().spawn(Replicated).id();
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    // Artificially reset the update tick to force the next received message to be queued.
+    let mut update_tick = client_app.world_mut().resource_mut::<ServerUpdateTick>();
+    let previous_tick = *update_tick;
+    *update_tick = Default::default();
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: WithEntity(server_entity),
+    });
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    let messages = client_app.world().resource::<Messages<WithEntity>>();
+    assert!(messages.is_empty());
+
+    // Restore the update tick to receive the message.
+    *client_app.world_mut().resource_mut::<ServerUpdateTick>() = previous_tick;
+
+    client_app.update();
+
+    let client_entity = *client_app
+        .world()
+        .resource::<ServerEntityMap>()
+        .to_client()
+        .get(&server_entity)
+        .unwrap();
+
+    let mapped_entities: Vec<_> = client_app
+        .world_mut()
+        .resource_mut::<Messages<WithEntity>>()
+        .drain()
+        .map(|m| m.0)
+        .collect();
+    assert_eq!(mapped_entities, [client_entity]);
+}
+
+#[test]
+fn multiple_client_queues() {
+    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,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .add_server_message::<WithEntity>(Channel::Ordered) // Use as a regular message with a different serialization size.
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    // Spawn entity to trigger world change.
+    server_app.world_mut().spawn(Replicated);
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    // Artificially reset the update tick to force the next received message to be queued.
+    let mut update_tick = client_app.world_mut().resource_mut::<ServerUpdateTick>();
+    let previous_tick = *update_tick;
+    *update_tick = Default::default();
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: Test,
+    });
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: WithEntity(Entity::PLACEHOLDER),
+    });
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+
+    let messages = client_app.world().resource::<Messages<Test>>();
+    assert!(messages.is_empty());
+
+    let mapped_messages = client_app.world().resource::<Messages<WithEntity>>();
+    assert!(mapped_messages.is_empty());
+
+    // Restore the update tick to receive the message.
+    *client_app.world_mut().resource_mut::<ServerUpdateTick>() = previous_tick;
+
+    client_app.update();
+
+    let messages = client_app.world().resource::<Messages<Test>>();
+    assert_eq!(messages.len(), 1);
+
+    let mapped_messages = client_app.world().resource::<Messages<WithEntity>>();
+    assert_eq!(mapped_messages.len(), 1);
+}
+
+#[test]
+fn independent() {
+    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,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .add_server_message::<Independent>(Channel::Ordered)
+        .make_message_independent::<Independent>()
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    // Spawn entity to trigger world change.
+    server_app.world_mut().spawn(Replicated);
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    // Artificially reset the update tick.
+    // Normal messages would be queued and not triggered yet,
+    // but our independent message should be triggered immediately.
+    *client_app.world_mut().resource_mut::<ServerUpdateTick>() = Default::default();
+
+    let client = **client_app.world().resource::<TestClientEntity>();
+    for (mode, messages_count) in [
+        (SendMode::Broadcast, 1),
+        (SendMode::Direct(ClientId::Server), 0),
+        (SendMode::Direct(client.into()), 1),
+        (SendMode::BroadcastExcept(ClientId::Server), 1),
+        (SendMode::BroadcastExcept(client.into()), 0),
+    ] {
+        server_app.world_mut().write_message(ToClients {
+            mode,
+            message: Test,
+        });
+        server_app.world_mut().write_message(ToClients {
+            mode,
+            message: Independent,
+        });
+
+        server_app.update();
+        server_app.exchange_with_client(&mut client_app);
+        client_app.update();
+        server_app.exchange_with_client(&mut client_app);
+
+        let messages = client_app.world().resource::<Messages<Test>>();
+        assert!(messages.is_empty());
+
+        // Message should have already been triggered, even without resetting the tick,
+        // since it's independent.
+        let mut independent_messages = client_app
+            .world_mut()
+            .resource_mut::<Messages<Independent>>();
+        assert_eq!(
+            independent_messages.drain().count(),
+            messages_count,
+            "message should be received {messages_count} times for {mode:?}"
+        );
+    }
+}
+
+#[test]
+fn before_started_replication() {
+    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,
+            StatesPlugin,
+            RepliconPlugins
+                .set(ServerPlugin::new(PostUpdate))
+                .set(RepliconSharedPlugin {
+                    auth_method: AuthMethod::Custom,
+                }),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    let client = **client_app.world().resource::<TestClientEntity>();
+    for mode in [
+        SendMode::Broadcast,
+        SendMode::BroadcastExcept(ClientId::Server),
+        SendMode::Direct(client.into()),
+    ] {
+        server_app.world_mut().write_message(ToClients {
+            mode,
+            message: Test,
+        });
+    }
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    let messages = client_app.world().resource::<Messages<Test>>();
+    assert!(messages.is_empty());
+}
+
+#[test]
+fn independent_before_started_replication() {
+    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,
+            StatesPlugin,
+            RepliconPlugins
+                .set(ServerPlugin::new(PostUpdate))
+                .set(RepliconSharedPlugin {
+                    auth_method: AuthMethod::Custom,
+                }),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .add_server_message::<Independent>(Channel::Ordered)
+        .make_message_independent::<Independent>()
+        .finish();
+    }
+
+    server_app.connect_client(&mut client_app);
+
+    // Spawn entity to trigger world change.
+    server_app.world_mut().spawn(Replicated);
+
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: Test,
+    });
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: Independent,
+    });
+
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app);
+    client_app.update();
+    server_app.exchange_with_client(&mut client_app);
+
+    let messages = client_app.world().resource::<Messages<Test>>();
+    assert!(messages.is_empty());
+
+    let independent_messages = client_app.world().resource::<Messages<Independent>>();
+    assert_eq!(independent_messages.len(), 1);
+}
+
+#[test]
+fn different_ticks() {
+    let mut server_app = App::new();
+    let mut client_app1 = App::new();
+    let mut client_app2 = App::new();
+    for app in [&mut server_app, &mut client_app1, &mut client_app2] {
+        app.add_plugins((
+            MinimalPlugins,
+            StatesPlugin,
+            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
+        ))
+        .add_server_message::<Test>(Channel::Ordered)
+        .finish();
+    }
+
+    // Connect client 1 first.
+    server_app.connect_client(&mut client_app1);
+
+    // Spawn entity to trigger world change.
+    server_app.world_mut().spawn(Replicated);
+
+    // Update client 1 to initialize their replicon tick.
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app1);
+    client_app1.update();
+    server_app.exchange_with_client(&mut client_app1);
+
+    // Connect client 2 later to make it have a higher replicon tick than client 1,
+    // since only client 1 will receive a update message here.
+    server_app.connect_client(&mut client_app2);
+
+    server_app.world_mut().write_message(ToClients {
+        mode: SendMode::Broadcast,
+        message: Test,
+    });
+
+    // If any client does not have a replicon tick >= the update tick associated with this message,
+    // then they will not receive the message until their replicon tick is updated.
+    server_app.update();
+    server_app.exchange_with_client(&mut client_app1);
+    server_app.exchange_with_client(&mut client_app2);
+    client_app1.update();
+    client_app2.update();
+
+    let messages1 = client_app1.world().resource::<Messages<Test>>();
+    assert_eq!(messages1.len(), 1);
+
+    let messages2 = client_app2.world().resource::<Messages<Test>>();
+    assert_eq!(messages2.len(), 1);
+}
+
+#[derive(Message, Serialize, Deserialize)]
+struct Test;
+
+#[derive(Message, Serialize, Deserialize)]
+struct Independent;
+
+#[derive(Message, Serialize, Deserialize, MapEntities)]
+struct WithEntity(#[entities] Entity);
diff --git a/tests/server_trigger.rs b/tests/server_trigger.rs
deleted file mode 100644
index fbd82521..00000000
--- a/tests/server_trigger.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-use bevy::{ecs::entity::MapEntities, prelude::*, state::app::StatesPlugin, time::TimePlugin};
-use bevy_replicon::{
-    client::ServerUpdateTick, prelude::*, shared::server_entity_map::ServerEntityMap,
-    test_app::ServerTestAppExt,
-};
-use serde::{Deserialize, Serialize};
-use test_log::test;
-
-#[test]
-fn regular() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_server_trigger::<TestEvent>(Channel::Ordered)
-        .finish();
-    }
-    client_app.init_resource::<TriggerReader<TestEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
-        event: TestEvent,
-    });
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let reader = client_app.world().resource::<TriggerReader<TestEvent>>();
-    assert_eq!(reader.entities, [Entity::PLACEHOLDER]);
-}
-
-#[test]
-fn with_target() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_server_trigger::<TestEvent>(Channel::Ordered)
-        .finish();
-    }
-    client_app.init_resource::<TriggerReader<TestEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    let server_entity = server_app.world_mut().spawn(Replicated).id();
-
-    server_app.world_mut().server_trigger_targets(
-        ToClients {
-            mode: SendMode::Broadcast,
-            event: TestEvent,
-        },
-        server_entity,
-    );
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let client_entity = *client_app
-        .world()
-        .resource::<ServerEntityMap>()
-        .to_client()
-        .get(&server_entity)
-        .unwrap();
-
-    let reader = client_app.world().resource::<TriggerReader<TestEvent>>();
-    assert_eq!(reader.entities, [client_entity]);
-}
-
-#[test]
-fn mapped() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_mapped_server_trigger::<EntityEvent>(Channel::Ordered)
-        .finish();
-    }
-    client_app.init_resource::<TriggerReader<EntityEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    let server_entity = server_app.world_mut().spawn(Replicated).id();
-
-    server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
-        event: EntityEvent(server_entity),
-    });
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let client_entity = *client_app
-        .world()
-        .resource::<ServerEntityMap>()
-        .to_client()
-        .get(&server_entity)
-        .unwrap();
-
-    let reader = client_app.world().resource::<TriggerReader<EntityEvent>>();
-    let mapped_entities: Vec<_> = reader.events.iter().map(|event| event.0).collect();
-    assert_eq!(mapped_entities, [client_entity]);
-}
-
-#[test]
-fn without_plugins() {
-    let mut server_app = App::new();
-    let mut client_app = App::new();
-    server_app
-        .add_plugins((
-            MinimalPlugins,
-            StatesPlugin,
-            RepliconPlugins
-                .build()
-                .set(ServerPlugin::new(PostUpdate))
-                .disable::<ClientPlugin>()
-                .disable::<ClientEventPlugin>(),
-        ))
-        .add_server_trigger::<TestEvent>(Channel::Ordered)
-        .finish();
-    client_app
-        .add_plugins((
-            MinimalPlugins,
-            StatesPlugin,
-            RepliconPlugins
-                .build()
-                .disable::<ServerPlugin>()
-                .disable::<ServerEventPlugin>(),
-        ))
-        .add_server_trigger::<TestEvent>(Channel::Ordered)
-        .finish();
-    client_app.init_resource::<TriggerReader<TestEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
-        event: TestEvent,
-    });
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let reader = client_app.world().resource::<TriggerReader<TestEvent>>();
-    assert_eq!(reader.events.len(), 1);
-}
-
-#[test]
-fn local_resending() {
-    let mut app = App::new();
-    app.add_plugins((
-        TimePlugin,
-        StatesPlugin,
-        RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-    ))
-    .add_server_trigger::<TestEvent>(Channel::Ordered)
-    .finish();
-    app.init_resource::<TriggerReader<TestEvent>>();
-
-    app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
-        event: TestEvent,
-    });
-
-    // Requires 2 updates because local resending runs
-    // in `PostUpdate` and triggering runs in `PreUpdate`.
-    app.update();
-    app.update();
-
-    let reader = app.world().resource::<TriggerReader<TestEvent>>();
-    assert_eq!(reader.events.len(), 1);
-}
-
-#[test]
-fn independent() {
-    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,
-            StatesPlugin,
-            RepliconPlugins.set(ServerPlugin::new(PostUpdate)),
-        ))
-        .add_server_trigger::<TestEvent>(Channel::Ordered)
-        .add_server_trigger::<IndependentEvent>(Channel::Ordered)
-        .make_trigger_independent::<IndependentEvent>()
-        .finish();
-    }
-    client_app
-        .init_resource::<TriggerReader<TestEvent>>()
-        .init_resource::<TriggerReader<IndependentEvent>>();
-
-    server_app.connect_client(&mut client_app);
-
-    // Spawn entity to trigger world change.
-    server_app.world_mut().spawn(Replicated);
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-    server_app.exchange_with_client(&mut client_app);
-
-    // Artificially reset the update tick.
-    // Normal events would be queued and not triggered yet,
-    // but our independent event should be triggered immediately.
-    *client_app.world_mut().resource_mut::<ServerUpdateTick>() = Default::default();
-
-    server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
-        event: TestEvent,
-    });
-    server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
-        event: IndependentEvent,
-    });
-
-    server_app.update();
-    server_app.exchange_with_client(&mut client_app);
-    client_app.update();
-
-    let reader = client_app.world().resource::<TriggerReader<TestEvent>>();
-    assert!(reader.events.is_empty());
-
-    let independent_reader = client_app
-        .world()
-        .resource::<TriggerReader<IndependentEvent>>();
-    assert_eq!(independent_reader.events.len(), 1);
-}
-
-#[derive(Event, Serialize, Deserialize, Clone)]
-struct TestEvent;
-
-#[derive(Event, Serialize, Deserialize, Clone)]
-struct IndependentEvent;
-
-#[derive(Event, Serialize, Deserialize, MapEntities, Clone)]
-struct EntityEvent(#[entities] Entity);
-
-#[derive(Resource)]
-struct TriggerReader<E: Event> {
-    events: Vec<E>,
-    entities: Vec<Entity>,
-}
-
-impl<E: Event + Clone> FromWorld for TriggerReader<E> {
-    fn from_world(world: &mut World) -> Self {
-        world.add_observer(|trigger: Trigger<E>, mut counter: ResMut<Self>| {
-            counter.events.push(trigger.event().clone());
-            counter.entities.push(trigger.target());
-        });
-
-        Self {
-            events: Default::default(),
-            entities: Default::default(),
-        }
-    }
-}