@rbxts/replecs 0.2.3 → 0.2.4

package/out/replecs/server.luau

@@ -1,71 +1,85 @@
 --!optimize 2
 --!native
 
-local jecs = require "../jecs"
-local utils = require "./utils"
-local common = require "./common"
-local customid = require "./customid"
-local masking_controller = require "./masking"
+local utils = require (script.Parent:WaitForChild('utils'))
+local common = require (script.Parent:WaitForChild('common'))
+local types = require (script.Parent:WaitForChild('types'))
+local customid = require (script.Parent:WaitForChild('customid'))
+local masking_controller = require (script.Parent:WaitForChild('masking'))
 
 local cursor = utils.cursor
 
 type Cursor = utils.Cursor
 type CustomId = customid.CustomId
+type StorageGroup = masking_controller.StorageGroup
 
-type World = jecs.World
-type Entity<T = any> = jecs.Entity<T>
-type Component = Entity
+type World = common.World
+type Entity = common.Entity
+type Component<T = any> = common.Component<T>
 
 type Set<T> = { [T]: boolean }
 type Map<K, V> = { [K]: V }
 type Array<T> = { T }
 
-type FunctionFilter = common.FunctionFilter
-type AnyFilter = common.AnyFilter
+type FunctionFilter = types.FunctionFilter
+type AnyFilter = types.AnyFilter
 
 type CustomIdSerialization = {
 	required: Map<Entity, CustomId>,
 	cursor_skip: number,
 }
 
+type EntityTrackInfo = {
+	components: Map<Component, number>,
+	pairs: Map<Component, number>,
+}
+
 type TrackInfo = {
 	networked: Set<Entity>,
-	entities: Map<Entity, Map<Component, number>>,
+	entities: Map<Entity, EntityTrackInfo>,
 	components: Map<Component, Map<Entity, number>>,
+	pairs: Map<Component, Map<Entity, number>>,
 }
 
 type EntityStorage = {
 	tags: { [Component]: boolean },
-	values: { [Component]: any },
-	pairs: { [Component]: Set<Entity> },
-	pairs_values: { [Component]: Map<Entity, any> },
+	components: { [Component]: any },
+	pair_tags: { [Component]: boolean },
+	pair_components: { [Component]: any },
+
+	relations: { [Component]: Set<Entity> },
+	relation_values: { [Component]: Map<Entity, any> },
 }
 
 type Storage = { [Entity]: EntityStorage }
 
 export type ServerImp = {
 	set_networked: (server: Server, entity: Entity, filter: AnyFilter?) -> (),
-	stop_networked: (server: Server, entity: Entity) -> (),
-
 	set_reliable: (server: Server, entity: Entity, component: Component, filter: AnyFilter?) -> (),
 	set_unreliable: (server: Server, entity: Entity, component: Component, filter: AnyFilter?) -> (),
-	set_pair: (server: Server, entity: Entity, relation: Component, filter: AnyFilter?) -> (),
-	set_custom: (server: Server, entity: Entity, component: Component | CustomId) -> (),
+	set_pair: (server: Server, entity: Entity, id: Component, filter: AnyFilter?) -> (),
+	set_relation: (server: Server, entity: Entity, relation: Component, filter: AnyFilter?) -> (),
+
+	stop_networked: (server: Server, entity: Entity, keep: boolean?) -> (),
+	stop_reliable: (server: Server, entity: Entity, component: Component, keep: boolean?) -> (),
+	stop_unreliable: (server: Server, entity: Entity, component: Component, keep: boolean?) -> (),
+	stop_pair: (server: Server, entity: Entity, id: Component, keep: boolean?) -> (),
+	stop_relation: (server: Server, entity: Entity, relation: Component, keep: boolean?) -> (),
 
-	stop_reliable: (server: Server, entity: Entity, component: Component) -> (),
-	stop_unreliable: (server: Server, entity: Entity, component: Component) -> (),
-	stop_pair: (server: Server, entity: Entity, relation: Component) -> (),
+	set_custom: (server: Server, entity: Entity, component: Component | CustomId) -> (),
 	remove_custom: (server: Server, entity: Entity) -> (),
+
+	set_serdes: <T>(server: Server, id: Component<T>, serdes: types.Serdes<T>) -> (),
+	remove_serdes: (server: Server, id: Component) -> (),
 }
 
 export type Server = ServerImp & {
 	world: World,
 	inited: boolean?,
 
-	shared: common.Shared,
+	shared: types.Shared,
 
-	components: common.Components,
-	hooks: common.WorldHooks,
+	components: types.Components,
 	alive_tracked: Set<Entity>,
 
 	is_shared_dirty: boolean,
@@ -83,15 +97,18 @@ export type Server = ServerImp & {
 	function_filters: masking_controller.EntityComponentIndex<FunctionFilter>,
 
 	registered_custom_ids: Map<CustomId, boolean>,
+	component_serdes: Map<Component, types.Serdes>,
 
 	init: (self: Server, world: World?) -> (),
 	destroy: (self: Server) -> (),
 
 	encode_component: (self: Server, component: Component) -> number,
-	decode_component: (self: Server, component: number) -> Component,
+	decode_component: (self: Server, component: number) -> Component?,
+	get_shared_count: (self: Server) -> number,
 	register_custom_id: (self: Server, custom_id: CustomId) -> (),
 
 	get_full: (self: Server, player: Player) -> (buffer, { { any } }),
+	collect_entity: (self: Server, entity: Entity) -> () -> (Player, buffer, { { any } }),
 	collect_updates: (self: Server) -> () -> (Player, buffer, { { any } }),
 	collect_unreliable: (self: Server) -> () -> (Player, buffer, { { any } }),
 
@@ -101,8 +118,8 @@ export type Server = ServerImp & {
 	add_player_alias: (self: Server, client: Player, alias: any) -> (),
 	remove_player_alias: (self: Server, alias: any) -> (),
 
-	generate_handshake: (self: Server) -> common.HandshakeInfo,
-	verify_handshake: (self: Server, handshake: common.HandshakeInfo) -> (boolean, string?),
+	generate_handshake: (self: Server) -> types.HandshakeInfo,
+	verify_handshake: (self: Server, handshake: types.HandshakeInfo) -> (boolean, string?),
 }
 
 local server_replicator = {}
@@ -111,18 +128,30 @@ server_replicator.__index = server_replicator
 local NIL_COMPONENT_VALUE = newproxy()
 local GLOBAL_ID_OFFSET = 10
 
-local COMPONENT_TYPES = masking_controller.COMPONENT_TYPES
+local COMPONENT_TYPES = {
+	tag = 1,
+	component = 2,
+	pair_tag = 3,
+	pair_component = 4,
+	relation = 5,
+	relation_value = 6,
+	unreliable = 7,
+}
+
 local TRACK_TYPES = {
-	component = 1,
-	tag = 2,
-	pair = 3,
-	pair_value = 4,
+	tag = 1,
+	component = 2,
+	pair_tag = 3,
+	pair_component = 4,
+	relation = 5,
+	relation_value = 6,
 }
 
 local PACKET_TYPES = {
 	full = 1,
-	unreliable = 2,
-	reliable = 3,
+	entity = 2,
+	updates = 3,
+	unreliable = 4,
 }
 
 local MAX_PACKET_SIZE = 900
@@ -133,22 +162,93 @@ local ENTITY_ID_TYPES = {
 	shared = 4,
 }
 
-local ECS_COMPONENT = jecs.Component
-local WILDCARD = jecs.Wildcard
+local RELATIONSHIPS = common.relationships
+local WILDCARD = common.wildcard
+local ECS_NAME = common.ecs_name
+
+local IS_PAIR = common.is_pair
+local PAIR = common.pair
+local PAIR_FIRST = common.pair_first
+local PAIR_SECOND = common.pair_second
+local WORLD_ADD = common.world_add
+local WORLD_HAS = common.world_has
+local WORLD_GET = common.world_get
+local WORLD_TARGET = common.world_target
+local IS_COMPONENT = common.is_component
+
+local LISTEN_RELATION = common.listen_relation
+
+local HOOK_ADDED = common.hook_added
+local HOOK_CHANGED = common.hook_changed
+local HOOK_REMOVED = common.hook_removed
+
+local function HOOK_PAIR_ADDED(world: World, pair_id: Entity, callback: (Entity, Component, any) -> ())
+	local relation = PAIR_FIRST(world, pair_id)
+
+	return HOOK_ADDED(world, relation, function(entity, id, value)
+		if id ~= pair_id then
+			return
+		end
+		callback(entity, id, value)
+	end)
+end
+
+local function HOOK_PAIR_CHANGED(world: World, pair_id: Entity, callback: (Entity, Component, any) -> ())
+	local relation = PAIR_FIRST(world, pair_id)
 
-local function IS_PAIR(id: Component): boolean
-	return jecs.IS_PAIR(id)
+	return HOOK_CHANGED(world, relation, function(entity, id, value)
+		if id ~= pair_id then
+			return
+		end
+		callback(entity, id, value)
+	end)
 end
 
-local function PAIR(relation: Entity, target: Entity): Entity
-	return jecs.pair(relation, target)
+local function HOOK_PAIR_REMOVED(world: World, pair_id: Entity, callback: (Entity, Component) -> ())
+	local relation = PAIR_FIRST(world, pair_id)
+
+	return HOOK_REMOVED(world, relation, function(entity, id)
+		if id ~= pair_id then
+			return
+		end
+		callback(entity, id)
+	end)
 end
 
-local function PAIR_SECOND(world: World, id: Entity): Entity
-	if not IS_PAIR(id) then
-		error(`expected a pair, got: {utils.logcomponent(world, id)}`)
+local function QUERY_TRACKING_TYPE(server: Server, track_type: Component)
+	local world = server.world
+	for entity in world:query(PAIR(track_type, WILDCARD)):iter() do
+		local index = 0
+		while true do
+			local target = WORLD_TARGET(world, entity, track_type, index)
+			if not target then
+				break
+			end
+			server.set_reliable(server, entity, target, WORLD_GET(world, entity, PAIR(track_type, target)))
+			index += 1
+		end
+	end
+end
+
+local function QUERY_CURRENT_NETWORKED(server: Server)
+	for entity, filter in server.world:query(server.components.networked):iter() do
+		server.set_networked(server, entity, filter)
+	end
+
+	if RELATIONSHIPS then
+		QUERY_TRACKING_TYPE(server, server.components.reliable)
+		QUERY_TRACKING_TYPE(server, server.components.unreliable)
+		QUERY_TRACKING_TYPE(server, server.components.relation)
+	end
+end
+
+local function QUERY_CURRENT_COMPONENTS(server: Server)
+	for component, serdes in server.world:query(server.components.serdes):iter() do
+		server.component_serdes[component] = serdes
+	end
+	for entity, id in server.world:query(server.components.global):iter() do
+		server.global_ids[entity] = id
 	end
-	return jecs.pair_second(world, id)
 end
 
 local function track_entity_lifetime(server: Server, entity: Entity)
@@ -156,18 +256,20 @@ local function track_entity_lifetime(server: Server, entity: Entity)
 		return
 	end
 	server.alive_tracked[entity] = true
-	server.world:add(entity, server.components.__alive_tracking__)
+	WORLD_ADD(server.world, entity, server.components.__alive_tracking__)
 end
 
 local function get_or_set_entity_storage(server: Server, entity: Entity): EntityStorage
-	local storage = server.storage[entity]
+	local storage: EntityStorage = server.storage[entity]
 
 	if not storage then
 		storage = {
 			tags = {},
-			values = {},
-			pairs = {},
-			pairs_values = {},
+			components = {},
+			pair_tags = {},
+			pair_components = {},
+			relations = {},
+			relation_values = {},
 		}
 		server.storage[entity] = storage
 	end
@@ -175,36 +277,47 @@ local function get_or_set_entity_storage(server: Server, entity: Entity): Entity
 	return storage
 end
 
-local function add_entity_tracked(server: Server, entity: Entity, component: Component, track_type: number)
-	local track = server.track_info.entities[entity]
-	if track == nil then
-		track = {
-			[component] = track_type,
-		}
-		server.track_info.entities[entity] = track
-	else
-		track[component] = track_type
+local function allocate_component_change(server: Server, entity: Entity, component: Component, value: any)
+	local storage = get_or_set_entity_storage(server, entity)
+
+	local non_nil = if value == nil then NIL_COMPONENT_VALUE else value
+	storage.components[component] = non_nil
+
+	if not server.additions[entity] and server.track_info.networked[entity] then
+		server.masking:allocate_component_change(entity, component, non_nil)
 	end
 end
 
-local function remove_entity_tracked(server: Server, entity: Entity, component: Component)
-	local track = server.track_info.entities[entity]
-	if track then
-		track[component] = nil
+local function allocate_tag_addition(server: Server, entity: Entity, tag: Component)
+	local storage = get_or_set_entity_storage(server, entity)
+	storage.tags[tag] = true
+
+	if not server.additions[entity] and server.track_info.networked[entity] then
+		server.masking:allocate_tag_addition(entity, tag)
 	end
 end
 
-local function allocate_component_change(server: Server, entity: Entity, component: Component, value: any)
+local function allocate_pair_addition(server: Server, entity: Entity, id: Component)
+	local storage = get_or_set_entity_storage(server, entity)
+	storage.pair_tags[id] = true
+
+	if not server.additions[entity] and server.track_info.networked[entity] then
+		server.masking:allocate_pair_addition(entity, id)
+	end
+end
+
+local function allocate_pair_change(server: Server, entity: Entity, id: Component, value: any)
 	local storage = get_or_set_entity_storage(server, entity)
 
 	local non_nil = if value == nil then NIL_COMPONENT_VALUE else value
+	storage.pair_components[id] = non_nil
 
-	storage.values[component] = non_nil
 	if not server.additions[entity] and server.track_info.networked[entity] then
-		server.masking:allocate_component_change(entity, component, non_nil)
+		server.masking:allocate_pair_change(entity, id, non_nil)
 	end
 end
-local function allocate_pair_value_change(
+
+local function allocate_relation_value_change(
 	server: Server,
 	entity: Entity,
 	relation: Component,
@@ -213,79 +326,91 @@ local function allocate_pair_value_change(
 )
 	local storage = get_or_set_entity_storage(server, entity)
 
-	local non_nil = if value == nil then NIL_COMPONENT_VALUE else value
-
-	local values = storage.pairs_values[relation]
+	local values = storage.relation_values[relation]
 	if values == nil then
 		values = {}
-		storage.pairs_values[relation] = values
+		storage.relation_values[relation] = values
 	end
+
+	local non_nil = if value == nil then NIL_COMPONENT_VALUE else value
 	values[target] = non_nil
 
 	if not server.additions[entity] and server.track_info.networked[entity] then
-		server.masking:allocate_pair_value_change(entity, relation, target, non_nil)
+		server.masking:allocate_relation_value_change(entity, relation, target, non_nil)
 	end
 end
 
-local function allocate_tag_addition(server: Server, entity: Entity, tag: Component)
-	local storage = get_or_set_entity_storage(server, entity)
-	storage.tags[tag] = true
-
-	if not server.additions[entity] and server.track_info.networked[entity] then
-		server.masking:allocate_tag_addition(entity, tag)
-	end
-end
-local function allocate_pair_addition(server: Server, entity: Entity, relation: Component, target: Entity)
+local function allocate_relation_addition(server: Server, entity: Entity, relation: Component, target: Entity)
 	local storage = get_or_set_entity_storage(server, entity)
-	local targets = storage.pairs[relation]
+	local targets = storage.relations[relation]
 	if targets == nil then
 		targets = {}
-		storage.pairs[relation] = targets
+		storage.relations[relation] = targets
 	end
 	targets[target] = true
 
 	if not server.additions[entity] and server.track_info.networked[entity] then
-		server.masking:allocate_pair_addition(entity, relation, target)
+		server.masking:allocate_relation_addition(entity, relation, target)
 	end
 end
 
 local function allocate_component_removal(server: Server, entity: Entity, component: Component)
 	local storage = get_or_set_entity_storage(server, entity)
-	storage.values[component] = nil
+	storage.components[component] = nil
 
 	if not server.additions[entity] and server.track_info.networked[entity] then
 		server.masking:allocate_component_removal(entity, component)
 	end
 end
-local function allocate_pair_value_removal(server: Server, entity: Entity, relation: Component, target: Entity)
+
+local function allocate_tag_removal(server: Server, entity: Entity, tag: Component)
 	local storage = get_or_set_entity_storage(server, entity)
-	local values = storage.pairs_values[relation]
-	if values then
-		values[target] = nil
+	storage.tags[tag] = nil
+
+	if not server.additions[entity] and server.track_info.networked[entity] then
+		server.masking:allocate_tag_removal(entity, tag)
 	end
+end
+
+local function allocate_pair_tag_removal(server: Server, entity: Entity, id: Component)
+	local storage = get_or_set_entity_storage(server, entity)
+	storage.pair_tags[id] = nil
 
 	if not server.additions[entity] and server.track_info.networked[entity] then
-		server.masking:allocate_pair_value_removal(entity, relation, target)
+		server.masking:allocate_pair_tag_removal(entity, id)
 	end
 end
 
-local function allocate_tag_removal(server: Server, entity: Entity, tag: Component)
+local function allocate_pair_component_removal(server: Server, entity: Entity, id: Component)
 	local storage = get_or_set_entity_storage(server, entity)
-	storage.tags[tag] = nil
+	storage.pair_components[id] = nil
 
 	if not server.additions[entity] and server.track_info.networked[entity] then
-		server.masking:allocate_tag_removal(entity, tag)
+		server.masking:allocate_pair_component_removal(entity, id)
 	end
 end
-local function allocate_pair_removal(server: Server, entity: Entity, relation: Component, target: Entity)
+
+local function allocate_relation_value_removal(server: Server, entity: Entity, relation: Component, target: Entity)
 	local storage = get_or_set_entity_storage(server, entity)
-	local targets = storage.pairs[relation]
+	local values = storage.relation_values[relation]
+	if values then
+		values[target] = nil
+	end
+
+	if not server.additions[entity] and server.track_info.networked[entity] then
+		server.masking:allocate_relation_value_removal(entity, relation, target)
+	end
+end
+
+local function allocate_relation_removal(server: Server, entity: Entity, relation: Component, target: Entity)
+	local storage = get_or_set_entity_storage(server, entity)
+	local targets = storage.relations[relation]
 	if targets then
 		targets[target] = nil
 	end
 
 	if not server.additions[entity] and server.track_info.networked[entity] then
-		server.masking:allocate_pair_removal(entity, relation, target)
+		server.masking:allocate_relation_removal(entity, relation, target)
 	end
 end
 
@@ -299,22 +424,77 @@ local function cleanup_entity(server: Server, entity: Entity)
 
 	local track_info = server.track_info.entities[entity]
 	if track_info then
-		for component in track_info do
+		for component in track_info.components do
 			local track_component = server.track_info.components[component]
 			if track_component then
 				track_component[entity] = nil
 			end
 		end
+		for id in track_info.pairs do
+			local track_pair = server.track_info.pairs[id]
+			if track_pair then
+				track_pair[entity] = nil
+			end
+		end
 		server.track_info.entities[entity] = nil
 	end
 end
 
+local function track_pair(server: Server, pair_id: Component)
+	local world = server.world
+
+	if server.track_info.pairs[pair_id] then
+		error(`attemped to track a pair twice: {common.log_component(server.world, PAIR_SECOND(world, pair_id))}`)
+	end
+
+	local info = {} :: Map<Entity, number>
+	server.track_info.pairs[pair_id] = info
+
+	local function hook(unhook: () -> ())
+		table.insert(server.hooked, unhook)
+	end
+
+	hook(HOOK_PAIR_ADDED(world, pair_id, function(entity, id, value)
+		local track_type = info[entity]
+		if not track_type then
+			return
+		end
+
+		if track_type == TRACK_TYPES.pair_component then
+			allocate_pair_change(server, entity, id, value)
+		else
+			allocate_pair_addition(server, entity, id)
+		end
+	end))
+	hook(HOOK_PAIR_CHANGED(world, pair_id, function(entity, id, value)
+		local track_type = info[entity]
+		if not track_type then
+			return
+		end
+
+		allocate_pair_change(server, entity, id, value)
+	end))
+	hook(HOOK_PAIR_REMOVED(world, pair_id, function(entity, id)
+		local track_type = info[entity]
+		if not track_type then
+			return
+		end
+
+		if track_type == TRACK_TYPES.pair_component then
+			allocate_pair_component_removal(server, entity, id)
+		else
+			allocate_pair_tag_removal(server, entity, id)
+		end
+	end))
+
+	return info
+end
+
 local function track_component(server: Server, component: Component)
 	local world = server.world
-	local hooks = server.hooks
 
 	if server.track_info.components[component] then
-		error(`attemped to track a component twice: {utils.logcomponent(server.world, component)}`)
+		error(`attemped to track a component twice: {common.log_component(server.world, component)}`)
 	end
 
 	local info = {} :: Map<Entity, number>
@@ -324,7 +504,7 @@ local function track_component(server: Server, component: Component)
 		table.insert(server.hooked, unhook)
 	end
 
-	hook(hooks.added(world, component, function(entity, id, value)
+	hook(HOOK_ADDED(world, component, function(entity, id, value)
 		local track_type = info[entity]
 		if not track_type then
 			return
@@ -334,33 +514,33 @@ local function track_component(server: Server, component: Component)
 			allocate_component_change(server, entity, component, value)
 		elseif track_type == TRACK_TYPES.tag then
 			allocate_tag_addition(server, entity, component)
-		elseif track_type == TRACK_TYPES.pair then
+		elseif track_type == TRACK_TYPES.relation then
 			if not IS_PAIR(id) then
 				return
 			end
-			allocate_pair_addition(server, entity, component, PAIR_SECOND(world, id))
-		elseif track_type == TRACK_TYPES.pair_value then
+			allocate_relation_addition(server, entity, component, PAIR_SECOND(world, id))
+		elseif track_type == TRACK_TYPES.relation_value then
 			if not IS_PAIR(id) then
 				return
 			end
-			allocate_pair_value_change(server, entity, component, PAIR_SECOND(world, id), value)
+			allocate_relation_value_change(server, entity, component, PAIR_SECOND(world, id), value)
 		end
 	end))
-	hook(hooks.changed(world, component, function(entity, id, value)
+	hook(HOOK_CHANGED(world, component, function(entity, id, value)
 		local track_type = info[entity]
 		if not track_type then
 			return
 		end
 		if track_type == TRACK_TYPES.component then
 			allocate_component_change(server, entity, component, value)
-		elseif track_type == TRACK_TYPES.pair_value then
+		elseif track_type == TRACK_TYPES.relation_value then
 			if not IS_PAIR(id) then
 				return
 			end
-			allocate_pair_value_change(server, entity, component, PAIR_SECOND(world, id), value)
+			allocate_relation_value_change(server, entity, component, PAIR_SECOND(world, id), value)
 		end
 	end))
-	hook(hooks.removed(world, component, function(entity, id)
+	hook(HOOK_REMOVED(world, component, function(entity, id)
 		local track_type = info[entity]
 		if not track_type then
 			return
@@ -370,23 +550,63 @@ local function track_component(server: Server, component: Component)
 			allocate_component_removal(server, entity, component)
 		elseif track_type == TRACK_TYPES.tag then
 			allocate_tag_removal(server, entity, component)
-		elseif track_type == TRACK_TYPES.pair then
+		elseif track_type == TRACK_TYPES.relation then
 			if not IS_PAIR(id) then
 				return
 			end
-			allocate_pair_removal(server, entity, component, PAIR_SECOND(world, id))
-		elseif track_type == TRACK_TYPES.pair_value then
+			allocate_relation_removal(server, entity, component, PAIR_SECOND(world, id))
+		elseif track_type == TRACK_TYPES.relation_value then
 			if not IS_PAIR(id) then
 				return
 			end
-			allocate_pair_value_removal(server, entity, component, PAIR_SECOND(world, id))
+			allocate_relation_value_removal(server, entity, component, PAIR_SECOND(world, id))
 		end
 	end))
 
 	return info
 end
 
-local function track_entity_component(server: Server, entity: Entity, component: Entity<any>)
+local function add_entity_component_tracked(server: Server, entity: Entity, component: Component, track_type: number)
+	local track: EntityTrackInfo = server.track_info.entities[entity]
+	if track == nil then
+		track = {
+			components = { [component] = track_type },
+			pairs = {},
+		}
+		server.track_info.entities[entity] = track
+	else
+		track.components[component] = track_type
+	end
+end
+
+local function add_entity_pair_tracked(server: Server, entity: Entity, id: Component, track_type: number)
+	local track: EntityTrackInfo = server.track_info.entities[entity]
+	if track == nil then
+		track = {
+			components = {},
+			pairs = { [id] = track_type },
+		}
+		server.track_info.entities[entity] = track
+	else
+		track.pairs[id] = track_type
+	end
+end
+
+local function remove_entity_component_tracked(server: Server, entity: Entity, component: Component)
+	local track = server.track_info.entities[entity]
+	if track then
+		track.components[component] = nil
+	end
+end
+
+local function remove_entity_pair_tracked(server: Server, entity: Entity, id: Component)
+	local track = server.track_info.entities[entity]
+	if track then
+		track.pairs[id] = nil
+	end
+end
+
+local function track_entity_component(server: Server, entity: Entity, component: Component)
 	local world = server.world
 	local info = server.track_info.components[component]
 	if not info then
@@ -395,34 +615,70 @@ local function track_entity_component(server: Server, entity: Entity, component:
 
 	local entity_storage = get_or_set_entity_storage(server, entity)
 
-	if world:has(component, ECS_COMPONENT) then
-		if world:has(entity, component) then
-			local value = world:get(entity, component)
+	if IS_COMPONENT(world, component) then
+		if WORLD_HAS(world, entity, component) then
+			local value = WORLD_GET(world, entity, component)
 
 			if value == nil then
-				entity_storage.values[component] = NIL_COMPONENT_VALUE
+				entity_storage.components[component] = NIL_COMPONENT_VALUE
 			else
-				entity_storage.values[component] = value
+				entity_storage.components[component] = value
 			end
 		end
 
 		info[entity] = TRACK_TYPES.component
-		add_entity_tracked(server, entity, component, TRACK_TYPES.component)
+		add_entity_component_tracked(server, entity, component, TRACK_TYPES.component)
 
 		return COMPONENT_TYPES.component
 	else
-		if world:has(entity, component) then
+		if WORLD_HAS(world, entity, component) then
 			entity_storage.tags[component] = true
 		end
 
 		info[entity] = TRACK_TYPES.tag
-		add_entity_tracked(server, entity, component, TRACK_TYPES.tag)
+		add_entity_component_tracked(server, entity, component, TRACK_TYPES.tag)
 
 		return COMPONENT_TYPES.tag
 	end
 end
 
-local function track_entity_pair(server: Server, entity: Entity, relation: Entity)
+local function track_entity_pair(server: Server, entity: Entity, id: Component)
+	local world = server.world
+	local info = server.track_info.pairs[id]
+	if not info then
+		info = track_pair(server, id)
+	end
+
+	local entity_storage = get_or_set_entity_storage(server, entity)
+
+	if IS_COMPONENT(world, id) then
+		if WORLD_HAS(world, entity, id) then
+			local value = WORLD_GET(world, entity, id)
+
+			if value == nil then
+				entity_storage.pair_components[id] = NIL_COMPONENT_VALUE
+			else
+				entity_storage.pair_components[id] = value
+			end
+		end
+
+		info[entity] = TRACK_TYPES.pair_component
+		add_entity_pair_tracked(server, entity, id, TRACK_TYPES.pair_component)
+
+		return COMPONENT_TYPES.pair_component
+	else
+		if WORLD_HAS(world, entity, id) then
+			entity_storage.pair_tags[id] = true
+		end
+
+		info[entity] = TRACK_TYPES.pair_tag
+		add_entity_pair_tracked(server, entity, id, TRACK_TYPES.pair_tag)
+
+		return COMPONENT_TYPES.pair_tag
+	end
+end
+
+local function track_entity_relation(server: Server, entity: Entity, relation: Component)
 	local world = server.world
 	local info = server.track_info.components[relation]
 	if not info then
@@ -431,31 +687,31 @@ local function track_entity_pair(server: Server, entity: Entity, relation: Entit
 
 	local entity_storage = get_or_set_entity_storage(server, entity)
 
-	if world:has(relation, ECS_COMPONENT) then
+	if IS_COMPONENT(world, relation) then
 		local targets = {} :: Map<Entity, any>
 
 		local index = 0
 		while true do
-			local target = world:target(entity, relation, index)
+			local target = WORLD_TARGET(world, entity, relation, index)
 			if not target then
 				break
 			end
 			index += 1
-			local value = world:get(entity, jecs.pair(relation, target))
+			local value = WORLD_GET(world, entity, PAIR(relation, target))
 			targets[target] = if value == nil then NIL_COMPONENT_VALUE else value :: any
 		end
 
-		entity_storage.pairs_values[relation] = targets
-		info[entity] = TRACK_TYPES.pair_value
-		add_entity_tracked(server, entity, relation, TRACK_TYPES.pair_value)
+		entity_storage.relation_values[relation] = targets
+		info[entity] = TRACK_TYPES.relation_value
+		add_entity_component_tracked(server, entity, relation, TRACK_TYPES.relation_value)
 
-		return COMPONENT_TYPES.pair_value
+		return COMPONENT_TYPES.relation_value
 	else
 		local targets = {} :: Set<Entity>
 
 		local index = 0
 		while true do
-			local target = world:target(entity, relation, index)
+			local target = WORLD_TARGET(world, entity, relation, index)
 			if not target then
 				break
 			end
@@ -463,15 +719,15 @@ local function track_entity_pair(server: Server, entity: Entity, relation: Entit
 			targets[target] = true
 		end
 
-		entity_storage.pairs[relation] = targets
-		info[entity] = TRACK_TYPES.pair
-		add_entity_tracked(server, entity, relation, TRACK_TYPES.pair)
+		entity_storage.relations[relation] = targets
+		info[entity] = TRACK_TYPES.relation
+		add_entity_component_tracked(server, entity, relation, TRACK_TYPES.relation)
 
-		return COMPONENT_TYPES.pair
+		return COMPONENT_TYPES.relation
 	end
 end
 
-local function untrack_entity_component(server: Server, entity: Entity, component: Entity<any>): number?
+local function untrack_entity_component(server: Server, entity: Entity, component: Component): number?
 	local info = server.track_info.components[component]
 	if not info then
 		return nil
@@ -481,21 +737,33 @@ local function untrack_entity_component(server: Server, entity: Entity, componen
 
 	local storage = server.storage[entity]
 	if storage then
-		storage.values[component] = nil
+		storage.components[component] = nil
 		storage.tags[component] = nil
 	end
 
-	local entity_tracked = server.track_info.entities[entity]
-	if entity_tracked then
-		entity_tracked[component] = nil
+	remove_entity_component_tracked(server, entity, component)
+	return listen_type
+end
+
+local function untrack_entity_pair(server: Server, entity: Entity, id: Entity): number?
+	local info = server.track_info.pairs[id]
+	if not info then
+		return nil
 	end
+	local listen_type = info[entity]
+	info[entity] = nil
 
-	remove_entity_tracked(server, entity, component)
+	local storage = server.storage[entity]
+	if storage then
+		storage.pair_tags[id] = nil
+		storage.pair_components[id] = nil
+	end
 
+	remove_entity_pair_tracked(server, entity, id)
 	return listen_type
 end
 
-local function untrack_entity_pair(server: Server, entity: Entity, relation: Entity): number?
+local function untrack_entity_relation(server: Server, entity: Entity, relation: Entity): number?
 	local info = server.track_info.components[relation]
 	if not info then
 		return nil
@@ -505,55 +773,41 @@ local function untrack_entity_pair(server: Server, entity: Entity, relation: Ent
 
 	local storage = server.storage[entity]
 	if storage then
-		storage.pairs[relation] = nil
-		storage.pairs_values[relation] = nil
-	end
-
-	local entity_tracked = server.track_info.entities[entity]
-	if entity_tracked then
-		entity_tracked[relation] = nil
+		storage.relations[relation] = nil
+		storage.relation_values[relation] = nil
 	end
 
-	remove_entity_tracked(server, entity, relation)
+	remove_entity_component_tracked(server, entity, relation)
 	return listen_type
 end
 
-function server_replicator.encode_component(server: Server, component: Entity): number
-	local encoded = server.shared.components.members[component]
-	if not encoded then
-		utils.logerror(`attempted to encode a non-shared component `, utils.logcomponent(server.world, component))
-		return 0
-	end
-	return encoded
-end
-
-function server_replicator.decode_component(server: Server, encoded: number): Entity
-	local component = server.shared.components.indexes[encoded]
-	if not component then
-		print("NON SHARED COMPONENTS", encoded, server.shared.components)
-		error "attemped to decode a non shared component"
+local function write_vlq_bitmask(c: Cursor, value: number, mask: number, bit: number): number
+	if value > 0 then
+		cursor.write_vlq(c, value)
+		return utils.setbit(mask, bit)
+	else
+		return mask
 	end
-	return component
 end
 
 function server_replicator.write_component_id(server: Server, c: Cursor, component: Entity)
 	local shared_componens = server.shared.components
 	local encoded = shared_componens.members[component]
 	if not encoded then
-		utils.logerror(`attempted to replicate a non-shared component `, utils.logcomponent(server.world, component))
+		common.log_error(`attempted to replicate a non-shared component `, common.log_component(server.world, component))
 		return
 	end
 	cursor.write_span(c, encoded, #shared_componens.keys)
 end
 
-function server_replicator.write_component_value(
+function server_replicator.write_variant_value(
 	server: Server,
 	c: Cursor,
-	component: Entity,
+	log_component: Component,
+	serdes: types.Serdes?,
 	value: any,
-	variants: { any }
+	variants: any
 )
-	local serdes = server.shared.serdes[component]
 	if serdes then
 		local output, serdes_variants = serdes.serialize(if value == NIL_COMPONENT_VALUE then nil else value)
 
@@ -570,9 +824,9 @@ function server_replicator.write_component_value(
 				cursor.write_vlq(c, start_variants + 1)
 			end
 		elseif serdes_variants ~= nil then
-			utils.logerror(
-				"serdes: serializer provided variants yet includes_variants is not set to true for component",
-				utils.logcomponent(server.world, component)
+			common.log_error(
+				"serdes: serializer provided variants yet includes_variants is not set to true for component: ",
+				common.log_component(server.world, log_component)
 			)
 		end
 
@@ -580,9 +834,9 @@ function server_replicator.write_component_value(
 		cursor.write_buffer(c, output)
 		if bytespan then
 			if bytespan ~= buffer.len(output) then
-				utils.logerror(
-					`bytespan: {bytespan} mismatch for buffer lenght: {buffer.len(output)} in component`,
-					utils.logcomponent(server.world, component)
+				common.log_error(
+					`bytespan: {bytespan} mismatch for buffer lenght: {buffer.len(output)} in component: `,
+					common.log_component(server.world, log_component)
 				)
 			end
 		else
@@ -600,9 +854,27 @@ function server_replicator.write_component_value(
 	end
 end
 
-function server_replicator.write_component(server: Server, c: Cursor, component: Entity, value: any, variants: { any })
-	server_replicator.write_component_value(server, c, component, value, variants)
-	server_replicator.write_component_id(server, c, component)
+function server_replicator.write_component_value(
+	server: Server,
+	c: Cursor,
+	component: Component,
+	value: any,
+	variants: { any }
+)
+	local serdes = server.shared.serdes[component]
+	server_replicator.write_variant_value(server, c, component, serdes, value, variants)
+end
+
+function server_replicator.write_pair_value(
+	server: Server,
+	c: Cursor,
+	relation: Component,
+	id: Entity,
+	value: any,
+	variants: { any }
+)
+	local serdes = server.shared.serdes[id] or server.shared.serdes[PAIR(relation, WILDCARD)]
+	server_replicator.write_variant_value(server, c, relation, serdes, value, variants)
 end
 
 function server_replicator.write_entity_id(server: Server, c: Cursor, entity: Entity)
@@ -634,7 +906,7 @@ function server_replicator.write_entity_id(server: Server, c: Cursor, entity: En
 end
 
 function server_replicator.write_entity_relations(server: Server, storage: EntityStorage, c: Cursor, relation: Entity)
-	local targets = storage.pairs[relation]
+	local targets = storage.relations[relation]
 	local total_targets = 0
 
 	for target in targets do
@@ -652,7 +924,7 @@ function server_replicator.write_entity_relations_values(
 	relation: Entity,
 	variants: { any }
 )
-	local targets = storage.pairs_values[relation]
+	local targets = storage.relation_values[relation]
 	local total_targets = 0
 
 	for target, value in targets do
@@ -664,6 +936,35 @@ function server_replicator.write_entity_relations_values(
 	server_replicator.write_component_id(server, c, relation)
 end
 
+function server_replicator.write_entity_pair_value(
+	server: Server,
+	world: World,
+	c: Cursor,
+	id: Component,
+	value: any,
+	variants: { any }
+)
+	local first, second = PAIR_FIRST(world, id), PAIR_SECOND(world, id)
+	local pointer_start = c.offset
+
+	server_replicator.write_pair_value(server, c, first, id, value, variants)
+
+	-- if the entity is a custom id, we dont know if this has a serdes in the client, as it needs to be processed first
+	-- we write a vlq so the client can jump in the cursor to skip this value entirely and process it later
+	local pointer_offset = c.offset - pointer_start
+	cursor.write_vlq(c, pointer_offset)
+
+	server_replicator.write_entity_id(server, c, second)
+	server_replicator.write_component_id(server, c, first)
+end
+
+function server_replicator.write_entity_pair(server: Server, world: World, c: Cursor, id: Component)
+	local first, second = PAIR_FIRST(world, id), PAIR_SECOND(world, id)
+
+	server_replicator.write_entity_id(server, c, second)
+	server_replicator.write_component_id(server, c, first)
+end
+
 function server_replicator.write_entity(
 	server: Server,
 	c: Cursor,
@@ -671,56 +972,87 @@ function server_replicator.write_entity(
 	active: masking_controller.ActiveEntity,
 	variants: { any }
 )
+	local world = server.world
 	local storage = server.storage[entity]
+	local entity_mask = 0
 
-	local all_pairs_values = 0
-	for relation in active.components[COMPONENT_TYPES.pair_value] do
+	local total_relation_values = 0
+	for relation in active.components[COMPONENT_TYPES.relation_value] do
 		server_replicator.write_entity_relations_values(server, storage, c, relation, variants)
-		all_pairs_values += 1
+		total_relation_values += 1
 	end
-	cursor.write_vlq(c, all_pairs_values)
+	entity_mask = write_vlq_bitmask(c, total_relation_values, entity_mask, 5)
 
-	local all_pairs = 0
-	for relation in active.components[COMPONENT_TYPES.pair] do
+	local total_relations = 0
+	for relation in active.components[COMPONENT_TYPES.relation] do
 		server_replicator.write_entity_relations(server, storage, c, relation)
-		all_pairs += 1
+		total_relations += 1
+	end
+	entity_mask = write_vlq_bitmask(c, total_relations, entity_mask, 4)
+
+	local total_pair_values = 0
+	for id in active.components[COMPONENT_TYPES.pair_component] do
+		local value = storage.pair_components[id]
+		if value == nil then
+			continue
+		end
+
+		server_replicator.write_entity_pair_value(server, world, c, id, value, variants)
+		total_pair_values += 1
+	end
+	entity_mask = write_vlq_bitmask(c, total_pair_values, entity_mask, 3)
+
+	local total_pairs = 0
+	for id in active.components[COMPONENT_TYPES.pair_tag] do
+		local has_pair = storage.pair_tags[id]
+		if has_pair then
+			server_replicator.write_entity_pair(server, world, c, id)
+			total_pairs += 1
+		end
 	end
-	cursor.write_vlq(c, all_pairs)
+	entity_mask = write_vlq_bitmask(c, total_pairs, entity_mask, 2)
 
-	local components = 0
+	local total_components = 0
 	for component in active.components[COMPONENT_TYPES.component] do
-		local value = storage.values[component]
+		local value = storage.components[component]
 		if value == nil then
 			continue
 		end
 
-		server_replicator.write_component(server, c, component, value, variants)
-		components += 1
+		server_replicator.write_component_value(server, c, component, value, variants)
+		server_replicator.write_component_id(server, c, component)
+		total_components += 1
 	end
-	cursor.write_vlq(c, components)
+	entity_mask = write_vlq_bitmask(c, total_components, entity_mask, 1)
 
-	local tags = 0
+	local total_tags = 0
 	for tag in active.components[COMPONENT_TYPES.tag] do
 		local has_tag = storage.tags[tag]
 		if has_tag then
 			server_replicator.write_component_id(server, c, tag)
-			tags += 1
+			total_tags += 1
 		end
 	end
-	cursor.write_vlq(c, tags)
-	server_replicator.write_entity_id(server, c, entity)
+	entity_mask = write_vlq_bitmask(c, total_tags, entity_mask, 0)
+	cursor.writeu8(c, entity_mask)
 end
 
 function server_replicator.resolve_dirty(server: Server)
 	if server.is_shared_dirty then
-		server.shared = utils.resolved_shared(server.world, server.components, server.registered_custom_ids)
+		-- stylua: ignore
+		server.shared = utils.resolved_shared(
+			server.world,
+			server.components,
+			server.registered_custom_ids,
+			server.component_serdes
+		)
 		server.is_shared_dirty = false
 	end
 end
 
 type Packet = {
 	buffer: buffer,
-	variants: { { any } },
+	variants: { any },
 }
 type MemberPackets = {
 	packets: Array<Packet>,
@@ -728,12 +1060,7 @@ type MemberPackets = {
 	total_size: number,
 }
 
-local function append_packet(
-	packets: { [Player]: MemberPackets },
-	members: { any },
-	output: buffer,
-	variants: { { any } }
-)
+local function append_packet(packets: { [Player]: MemberPackets }, members: { any }, output: buffer, variants: { any })
 	local len = buffer.len(output)
 	for _, member in members do
 		if not utils.is_client_valid(member) then
@@ -783,14 +1110,14 @@ end
 type PacketIterator = () -> (Player, buffer, { { any } })
 
 local function create_packet_iterator(packets: { [Player]: MemberPackets }, id: number)
-	local iterated: Player? = nil
-	local function iterator()
+	local iterated: Player? 	
+local function iterator()
 		local player, data = next(packets, iterated)
 		while not utils.is_client_valid(player) do
 			if not player and not data then
 				break
 			end
-			player, data = next(packets, iterated)
+			player, data = next(packets, player)
 		end
 		if not player then
 			return nil :: any
@@ -849,7 +1176,7 @@ function server_replicator.get_full(server: Server, client: Player): (buffer, {
 	server_replicator.resolve_dirty(server)
 	local index = server.masking.client_indexes[client]
 	if index == nil then
-		utils.logerror "attempted to replicate for a non registered client"
+		common.log_error "attempted to replicate for a non registered client"
 	end
 
 	local packets: Array<Packet> = {}
@@ -864,11 +1191,12 @@ function server_replicator.get_full(server: Server, client: Player): (buffer, {
 			continue
 		end
 		local c = cursor.new()
-		local variants = {}
+		local variants: { any } = {}
 
 		local total_entities = 0
 		for entity, active in storage.active do
 			server_replicator.write_entity(server, c, entity, active, variants)
+			server_replicator.write_entity_id(server, c, entity)
 			total_entities += 1
 		end
 		cursor.write_vlq(c, total_entities)
@@ -884,22 +1212,49 @@ function server_replicator.get_full(server: Server, client: Player): (buffer, {
 	return combine_packet_outputs(packets, total_size, PACKET_TYPES.full)
 end
 
-local function write_vlq_bitmask(c: Cursor, value: number, mask: number, bit: number): number
-	if value > 0 then
-		cursor.write_vlq(c, value)
-		return utils.setbit(mask, bit)
-	else
-		return mask
+function server_replicator.collect_entity(server: Server, entity: Entity)
+	server_replicator.resolve_dirty(server)
+	local packets: { [Player]: MemberPackets } = {}
+	local processed_storages: Set<StorageGroup> = {}
+
+	local lookup = server.masking.lookups.entities[entity]
+	local entity_storage = lookup.storage_group
+
+	local c_main = cursor.new()
+	local variants_main = {}
+
+	server_replicator.write_entity(server, c_main, entity, entity_storage.active[entity], variants_main)
+	server_replicator.write_entity_id(server, c_main, entity)
+	append_packet(packets, entity_storage.mask.members, cursor.close(c_main), variants_main)
+	processed_storages[entity_storage] = true
+
+	for _, filtered in lookup.filtered_components do
+		for _, component in filtered do
+			local storage = component.storage_group
+			if processed_storages[storage] then
+				continue
+			end
+
+			local c = cursor.new()
+			local variants = {}
+
+			server_replicator.write_entity(server, c, entity, storage.active[entity], variants)
+			server_replicator.write_entity_id(server, c_main, entity)
+			append_packet(packets, storage.mask.members, cursor.close(c), variants)
+			processed_storages[storage] = true
+		end
 	end
+
+	return create_packet_iterator(packets, PACKET_TYPES.entity)
 end
 
 function server_replicator.collect_updates(server: Server)
 	server_replicator.resolve_dirty(server)
+	local world = server.world
 	local packets: { [Player]: MemberPackets } = {}
 
 	for _, storage in server.masking.storages do
 		local c = cursor.new()
-
 		local variants = {}
 
 		local storage_mask = 0
@@ -916,28 +1271,39 @@ function server_replicator.collect_updates(server: Server)
 		local total_component_deleted = 0
 		local component_deletions = storage.deletions.components
 		for entity, deleted in component_deletions do
-			local total_pairs = 0
+			local total_relations = 0
 
-			for relation in deleted[COMPONENT_TYPES.pair_value] do
+			for relation in deleted[COMPONENT_TYPES.relation_value] do
 				server_replicator.write_component_id(server, c, relation)
-				total_pairs += 1
+				total_relations += 1
 			end
-			for relation in deleted[COMPONENT_TYPES.pair] do
+			for relation in deleted[COMPONENT_TYPES.relation] do
 				server_replicator.write_component_id(server, c, relation)
+				total_relations += 1
+			end
+			cursor.write_vlq(c, total_relations)
+
+			local total_pairs = 0
+			for id in deleted[COMPONENT_TYPES.pair_component] do
+				server_replicator.write_entity_pair(server, world, c, id)
+				total_pairs += 1
+			end
+			for id in deleted[COMPONENT_TYPES.pair_tag] do
+				server_replicator.write_entity_pair(server, world, c, id)
 				total_pairs += 1
 			end
 			cursor.write_vlq(c, total_pairs)
 
-			local total_removed = 0
+			local total_components = 0
 			for component in deleted[COMPONENT_TYPES.component] do
 				server_replicator.write_component_id(server, c, component)
-				total_removed += 1
+				total_components += 1
 			end
 			for tag in deleted[COMPONENT_TYPES.tag] do
 				server_replicator.write_component_id(server, c, tag)
-				total_removed += 1
+				total_components += 1
 			end
-			cursor.write_vlq(c, total_removed)
+			cursor.write_vlq(c, total_components)
 
 			server_replicator.write_entity_id(server, c, entity)
 			total_component_deleted += 1
@@ -948,25 +1314,21 @@ function server_replicator.collect_updates(server: Server)
 		local storage_changes = storage.changes
 		local changed = 0
 		for entity, changes in storage_changes.changed do
-			local changed_mask = 0
+			-- relations remove
 
-			local total_pairs_values = 0
-			for relation, targets in changes.pairs_values.changed do
+			local total_relations_removed = 0
+			for relation, targets in changes.relation_removed.component do
 				local total_targets = 0
 
-				for target, value in targets do
+				for target in targets do
 					server_replicator.write_entity_id(server, c, target)
-					server_replicator.write_component_value(server, c, relation, value, variants)
 					total_targets += 1
 				end
 				cursor.write_vlq(c, total_targets)
 				server_replicator.write_component_id(server, c, relation)
-				total_pairs_values += 1
+				total_relations_removed += 1
 			end
-			changed_mask = write_vlq_bitmask(c, total_pairs_values, changed_mask, 5)
-
-			local total_pairs_values_removed = 0
-			for relation, targets in changes.pairs_values.removed do
+			for relation, targets in changes.relation_removed.tag do
 				local total_targets = 0
 
 				for target in targets do
@@ -975,39 +1337,93 @@ function server_replicator.collect_updates(server: Server)
 				end
 				cursor.write_vlq(c, total_targets)
 				server_replicator.write_component_id(server, c, relation)
-				total_pairs_values_removed += 1
+				total_relations_removed += 1
 			end
-			changed_mask = write_vlq_bitmask(c, total_pairs_values_removed, changed_mask, 4)
+			-- using a normal vlq here sadly
+			-- cause I ran out of bitmask space for this one :/
+			cursor.write_vlq(c, total_relations_removed)
 
-			local total_pairs = 0
-			for relation, targets in changes.pairs do
+			local changed_mask = 0
+
+			-- relations add/set
+
+			local total_relation_values = 0
+			for relation, targets in changes.relation_value do
 				local total_targets = 0
 
-				for target, added in targets do
+				for target, value in targets do
 					server_replicator.write_entity_id(server, c, target)
-					if added then
-						cursor.writei8(c, 1)
-					else
-						cursor.writei8(c, -1)
-					end
+					server_replicator.write_component_value(server, c, relation, value, variants)
 					total_targets += 1
 				end
 				cursor.write_vlq(c, total_targets)
 				server_replicator.write_component_id(server, c, relation)
-				total_pairs += 1
+				total_relation_values += 1
+			end
+			changed_mask = write_vlq_bitmask(c, total_relation_values, changed_mask, 7)
+
+			local total_relations_added = 0
+			for relation, targets in changes.relation_added do
+				local total_targets = 0
+
+				for target in targets do
+					server_replicator.write_entity_id(server, c, target)
+					total_targets += 1
+				end
+				cursor.write_vlq(c, total_targets)
+				server_replicator.write_component_id(server, c, relation)
+				total_relations_added += 1
 			end
-			changed_mask = write_vlq_bitmask(c, total_pairs, changed_mask, 3)
+			changed_mask = write_vlq_bitmask(c, total_relations_added, changed_mask, 6)
+
+			-- pairs removed
+
+			local total_pairs_removed = 0
+			for id in changes.pair_removed.component do
+				server_replicator.write_entity_pair(server, world, c, id)
+				total_pairs_removed += 1
+			end
+			for id in changes.pair_removed.tag do
+				server_replicator.write_entity_pair(server, world, c, id)
+				total_pairs_removed += 1
+			end
+			changed_mask = write_vlq_bitmask(c, total_pairs_removed, changed_mask, 5)
+
+			-- pairs add/set
+
+			local total_pairs_set = 0
+			for id, value in changes.pair_changed do
+				server_replicator.write_entity_pair_value(server, world, c, id, value, variants)
+				total_pairs_set += 1
+			end
+			changed_mask = write_vlq_bitmask(c, total_pairs_set, changed_mask, 4)
+
+			local total_pairs_added = 0
+			for id in changes.pair_added do
+				server_replicator.write_entity_pair(server, world, c, id)
+				total_pairs_added += 1
+			end
+			changed_mask = write_vlq_bitmask(c, total_pairs_added, changed_mask, 3)
+
+			-- tags/components removed
 
 			local total_removed = 0
-			for component in changes.removed do
+			for component in changes.removed.component do
+				server_replicator.write_component_id(server, c, component)
+				total_removed += 1
+			end
+			for component in changes.removed.tag do
 				server_replicator.write_component_id(server, c, component)
 				total_removed += 1
 			end
 			changed_mask = write_vlq_bitmask(c, total_removed, changed_mask, 2)
 
+			-- tags/components set
+
 			local total_components = 0
 			for component, value in changes.component do
-				server_replicator.write_component(server, c, component, value, variants)
+				server_replicator.write_component_value(server, c, component, value, variants)
+				server_replicator.write_component_id(server, c, component)
 				total_components += 1
 			end
 			changed_mask = write_vlq_bitmask(c, total_components, changed_mask, 1)
@@ -1019,7 +1435,7 @@ function server_replicator.collect_updates(server: Server)
 			end
 			changed_mask = write_vlq_bitmask(c, total_tagged, changed_mask, 0)
 
-			if changed_mask ~= 0 then
+			if changed_mask + total_relations_removed ~= 0 then
 				cursor.writeu8(c, changed_mask)
 				server_replicator.write_entity_id(server, c, entity)
 				changed += 1
@@ -1033,27 +1449,49 @@ function server_replicator.collect_updates(server: Server)
 			local entity_storage = server.storage[entity]
 			local added_mask = 0
 
-			local total_pairs_values = 0
-			for relation in components[COMPONENT_TYPES.pair_value] do
+			local total_relation_values = 0
+			for relation in components[COMPONENT_TYPES.relation_value] do
 				server_replicator.write_entity_relations_values(server, entity_storage, c, relation, variants)
-				total_pairs_values += 1
+				total_relation_values += 1
 			end
-			added_mask = write_vlq_bitmask(c, total_pairs_values, added_mask, 3)
+			added_mask = write_vlq_bitmask(c, total_relation_values, added_mask, 5)
 
-			local total_pairs = 0
-			for relation in components[COMPONENT_TYPES.pair] do
+			local total_relations = 0
+			for relation in components[COMPONENT_TYPES.relation] do
 				server_replicator.write_entity_relations(server, entity_storage, c, relation)
+				total_relations += 1
+			end
+			added_mask = write_vlq_bitmask(c, total_relations, added_mask, 4)
+
+			local total_pair_values = 0
+			for id in components[COMPONENT_TYPES.pair_component] do
+				local value = entity_storage.pair_components[id]
+				-- nil is saved here as a special value, this gets automatically handled by write_component_value
+				if value == nil then
+					continue
+				end
+
+				server_replicator.write_entity_pair_value(server, world, c, id, value, variants)
+				total_pair_values += 1
+			end
+			added_mask = write_vlq_bitmask(c, total_pair_values, added_mask, 3)
+
+			local total_pairs = 0
+			for id in components[COMPONENT_TYPES.pair_tag] do
+				server_replicator.write_entity_pair(server, world, c, id)
 				total_pairs += 1
 			end
 			added_mask = write_vlq_bitmask(c, total_pairs, added_mask, 2)
 
 			local total_components = 0
 			for component in components[COMPONENT_TYPES.component] do
-				local value = entity_storage.values[component]
+				local value = entity_storage.components[component]
+				-- nil is saved here as a special value, this gets automatically handled by write_component_value
 				if value == nil then
 					continue
 				end
-				server_replicator.write_component(server, c, component, value, variants)
+				server_replicator.write_component_value(server, c, component, value, variants)
+				server_replicator.write_component_id(server, c, component)
 				total_components += 1
 			end
 			added_mask = write_vlq_bitmask(c, total_components, added_mask, 1)
@@ -1085,6 +1523,7 @@ function server_replicator.collect_updates(server: Server)
 			end
 
 			server_replicator.write_entity(server, c, entity, active, variants)
+			server_replicator.write_entity_id(server, c, entity)
 			total_added += 1
 		end
 		table.clear(storage_changes.added)
@@ -1097,7 +1536,7 @@ function server_replicator.collect_updates(server: Server)
 		end
 	end
 	table.clear(server.additions)
-	return create_packet_iterator(packets, PACKET_TYPES.reliable)
+	return create_packet_iterator(packets, PACKET_TYPES.updates)
 end
 
 function server_replicator.collect_unreliable(server: Server)
@@ -1112,20 +1551,17 @@ function server_replicator.collect_unreliable(server: Server)
 		local active = mask_storage.active
 
 		local c = cursor.new()
-		local variants = {} :: { { any } }
-		local custom_ids: Set<Entity> = {}
+		local variants = {} :: Array<{ any }>
 		local total_entities = 0
 
 		local checkpoint_offset = 0
 		local checkpoint_variants_count = 0
 		local checkpoint_total_entities = 0
-		local checkpoint_entity: Entity? = nil
 
-		local function create_checkpoint(entity: Entity)
+		local function create_checkpoint()
 			checkpoint_offset = c.offset
 			checkpoint_variants_count = #variants
 			checkpoint_total_entities = total_entities
-			checkpoint_entity = entity
 		end
 
 		local function rollback_checkpoint()
@@ -1134,17 +1570,10 @@ function server_replicator.collect_unreliable(server: Server)
 			c.offset = checkpoint_offset
 			c = new_cursor
 
-			local new_variants = {} :: { { any } }
+			local new_variants = {} :: Array<{ any }>
 			for _ = #variants, checkpoint_variants_count + 1, -1 do
-				table.insert(new_variants, 1, table.remove(variants))
-			end
-
-			local new_custom_ids = {} :: Set<Entity>
-			if checkpoint_entity then
-				new_custom_ids[checkpoint_entity] = true
-				custom_ids[checkpoint_entity] = nil
+				table.insert(new_variants, 1, table.remove(variants) :: { any })
 			end
-			custom_ids = new_custom_ids
 
 			variants = new_variants
 			total_entities = total_entities - checkpoint_total_entities
@@ -1161,16 +1590,18 @@ function server_replicator.collect_unreliable(server: Server)
 		end
 
 		for entity, actives in active do
-			create_checkpoint(entity)
+			create_checkpoint()
 
 			local total_unreliable = 0
 			for component in actives.components[COMPONENT_TYPES.unreliable] do
-				local value = world:get(entity, component)
+				local value = WORLD_GET(world, entity, component)
 				if value == nil then
 					continue
 				end
 
-				server_replicator.write_component(server, c, component, value, variants)
+				server_replicator.write_component_value(server, c, component, value, variants)
+				server_replicator.write_component_id(server, c, component)
+
 				total_unreliable += 1
 			end
 
@@ -1198,47 +1629,64 @@ end
 function server_replicator.start_networked(server: Server, entity: Entity, filter: AnyFilter?)
 	local masking = server.masking
 
-	masking:unregister_stop_entity(entity)
+	masking:deallocate_entity_stop(entity)
 	masking:start_entity(entity, filter)
-	masking:propagate_entity_addition(entity)
+	masking:allocate_propagated_entity_start(entity)
 
 	server.additions[entity] = true
 	server.track_info.networked[entity] = true
 	track_entity_lifetime(server, entity)
 end
+
 function server_replicator.start_reliable(server: Server, entity: Entity, component: Component, filter: AnyFilter?)
 	local masking = server.masking
 
-	local component_type = track_entity_component(server :: Server, entity, component)
-	masking:unregister_stop_component(entity, component, component_type)
-	masking:start_component(entity, component, component_type, filter)
+	local track_type = track_entity_component(server :: Server, entity, component)
+	masking:deallocate_component_stop(entity, component, track_type)
+	masking:start_component(entity, component, track_type, filter)
+
 	if server.additions[entity] then
-		masking:allocate_entity_addition(entity, component, component_type)
+		masking:allocate_shared_entity_start(entity, component, track_type)
 	elseif server.track_info.networked[entity] then
-		masking:register_component_addition(entity, component, component_type)
+		masking:allocate_component_start(entity, component, track_type)
 	end
 end
 
 function server_replicator.start_unreliable(server: Server, entity: Entity, component: Component, filter: AnyFilter?)
 	local masking = server.masking
 
-	masking:unregister_stop_component(entity, component, COMPONENT_TYPES.unreliable)
+	masking:deallocate_component_stop(entity, component, COMPONENT_TYPES.unreliable)
 	masking:start_component(entity, component, COMPONENT_TYPES.unreliable, filter)
 	if server.additions[entity] then
-		masking:allocate_entity_addition(entity, component, COMPONENT_TYPES.unreliable)
+		masking:allocate_component_start(entity, component, COMPONENT_TYPES.unreliable)
 	end
 end
 
-function server_replicator.start_pair(server: Server, entity: Entity, relation: Component, filter: AnyFilter?)
+function server_replicator.start_pair(server: Server, entity: Entity, id: Component, filter: AnyFilter?)
 	local masking = server.masking
 
-	local component_type = track_entity_pair(server, entity, relation)
-	masking:unregister_stop_component(entity, relation, component_type)
-	masking:start_component(entity, relation, component_type, filter)
+	local track_type = track_entity_pair(server :: Server, entity, id)
+	masking:deallocate_component_stop(entity, id, track_type)
+	masking:start_component(entity, id, track_type, filter)
+
 	if server.additions[entity] then
-		masking:allocate_entity_addition(entity, relation, component_type)
+		masking:allocate_shared_entity_start(entity, id, track_type)
 	elseif server.track_info.networked[entity] then
-		masking:register_component_addition(entity, relation, component_type)
+		masking:allocate_component_start(entity, id, track_type)
+	end
+end
+
+function server_replicator.start_relation(server: Server, entity: Entity, relation: Component, filter: AnyFilter?)
+	local masking = server.masking
+
+	local track_type = track_entity_relation(server, entity, relation)
+	masking:deallocate_component_stop(entity, relation, track_type)
+	masking:start_component(entity, relation, track_type, filter)
+
+	if server.additions[entity] then
+		masking:allocate_shared_entity_start(entity, relation, track_type)
+	elseif server.track_info.networked[entity] then
+		masking:allocate_component_start(entity, relation, track_type)
 	end
 end
 
@@ -1246,92 +1694,127 @@ function server_replicator.change_networked(server: Server, entity: Entity, filt
 	local masking = server.masking
 	masking:set_entity(entity, filter)
 end
+
 function server_replicator.change_reliable(server: Server, entity: Entity, component: Component, filter: AnyFilter?)
 	local world = server.world
 	local masking = server.masking
 
-	if world:has(component, ECS_COMPONENT) then
+	if IS_COMPONENT(world, component) then
 		masking:set_component(entity, component, COMPONENT_TYPES.component, filter)
 	else
 		masking:set_component(entity, component, COMPONENT_TYPES.tag, filter)
 	end
 end
+
 function server_replicator.change_unreliable(server: Server, entity: Entity, component: Component, filter: AnyFilter?)
 	local masking = server.masking
 	masking:set_component(entity, component, COMPONENT_TYPES.unreliable, filter)
 end
-function server_replicator.change_pair(server: Server, entity: Entity, relation: Component, filter: AnyFilter?)
+
+function server_replicator.change_pair(server: Server, entity: Entity, id: Component, filter: AnyFilter?)
 	local world = server.world
 	local masking = server.masking
 
-	if world:has(relation, ECS_COMPONENT) then
-		masking:set_component(entity, relation, COMPONENT_TYPES.pair_value, filter)
+	if IS_COMPONENT(world, id) then
+		masking:set_component(entity, id, COMPONENT_TYPES.pair_component, filter)
 	else
-		masking:set_component(entity, relation, COMPONENT_TYPES.pair, filter)
+		masking:set_component(entity, id, COMPONENT_TYPES.pair_tag, filter)
 	end
 end
 
-function server_replicator.stop_networked(server: Server, entity: Entity)
+function server_replicator.change_relation(server: Server, entity: Entity, relation: Component, filter: AnyFilter?)
+	local world = server.world
+	local masking = server.masking
+
+	if IS_COMPONENT(world, relation) then
+		masking:set_component(entity, relation, COMPONENT_TYPES.relation_value, filter)
+	else
+		masking:set_component(entity, relation, COMPONENT_TYPES.relation, filter)
+	end
+end
+
+local function stop_tracked_component(
+	server: Server,
+	entity: Entity,
+	component: Component,
+	track_type: number,
+	keep: boolean?
+)
+	local masking = server.masking
+	if server.track_info.networked[entity] then
+		masking:deallocate_component_start(entity, component, track_type)
+		if not keep then
+			masking:allocate_component_stop(entity, component, track_type)
+		end
+	end
+	masking:stop_component(entity, component, track_type)
+end
+
+function server_replicator.stop_networked(server: Server, entity: Entity, keep: boolean?)
 	if not server.track_info.networked[entity] then
 		return
 	end
 
 	local masking = server.masking
-	masking:register_stop_entity(entity)
+	if not keep then
+		masking:allocate_entity_stop(entity)
+	end
 	masking:stop_entity(entity)
 
 	server.additions[entity] = nil
 	server.track_info.networked[entity] = nil
 end
-function server_replicator.stop_reliable(server: Server, entity: Entity, component: Component)
-	local masking = server.masking
+
+function server_replicator.stop_reliable(server: Server, entity: Entity, component: Component, keep: boolean?)
 	if not server.track_info.entities[entity] then
 		return
 	end
 
-	local component_type = untrack_entity_component(server, entity, component)
-	if not component_type then
+	local track_type = untrack_entity_component(server, entity, component)
+	if not track_type then
 		return
 	end
 
-	if server.track_info.networked[entity] then
-		masking:unregister_component_addition(entity, component, component_type)
-		masking:register_stop_component(entity, component, component_type)
-	end
-	masking:stop_component(entity, component, component_type)
+	stop_tracked_component(server, entity, component, track_type, keep)
 end
-function server_replicator.stop_unreliable(server: Server, entity: Entity, component: Component)
-	local masking = server.masking
+
+function server_replicator.stop_unreliable(server: Server, entity: Entity, component: Component, keep: boolean?)
 	if not server.track_info.entities[entity] then
 		return
 	end
 
-	local component_type = untrack_entity_component(server, entity, component)
-	if not component_type then
+	local track_type = untrack_entity_component(server, entity, component)
+	if not track_type then
 		return
 	end
 
-	if server.track_info.networked[entity] then
-		masking:register_stop_component(entity, component, COMPONENT_TYPES.unreliable)
-	end
-	masking:stop_component(entity, component, COMPONENT_TYPES.unreliable)
+	stop_tracked_component(server, entity, component, COMPONENT_TYPES.unreliable, keep)
 end
-function server_replicator.stop_pair(server: Server, entity: Entity, relation: Component)
-	local masking = server.masking
+
+function server_replicator.stop_pair(server: Server, entity: Entity, id: Component, keep: boolean?)
 	if not server.track_info.entities[entity] then
 		return
 	end
 
-	local component_type = untrack_entity_pair(server, entity, relation)
-	if not component_type then
+	local track_type = untrack_entity_pair(server, entity, id)
+	if not track_type then
 		return
 	end
 
-	if server.track_info.networked[entity] then
-		masking:unregister_component_addition(entity, relation, component_type)
-		masking:register_stop_component(entity, relation, component_type)
+	stop_tracked_component(server, entity, id, track_type, keep)
+end
+
+function server_replicator.stop_relation(server: Server, entity: Entity, relation: Component, keep: boolean?)
+	if not server.track_info.entities[entity] then
+		return
+	end
+
+	local track_type = untrack_entity_relation(server, entity, relation)
+	if not track_type then
+		return
 	end
-	masking:stop_component(entity, relation, component_type)
+
+	stop_tracked_component(server, entity, relation, track_type, keep)
 end
 
 function server_replicator.set_networked(server: Server, entity: Entity, filter: AnyFilter?)
@@ -1341,33 +1824,46 @@ function server_replicator.set_networked(server: Server, entity: Entity, filter:
 		server_replicator.start_networked(server, entity, filter)
 	end
 end
+
 function server_replicator.set_reliable(server: Server, entity: Entity, component: Component, filter: AnyFilter?)
 	local entity_tracked = server.track_info.entities[entity]
-	if entity_tracked and entity_tracked[component] then
+	if entity_tracked and entity_tracked.components[component] then
 		server_replicator.change_reliable(server, entity, component, filter)
 	else
 		server_replicator.start_reliable(server, entity, component, filter)
 	end
 end
+
 function server_replicator.set_unreliable(server: Server, entity: Entity, component: Component, filter: AnyFilter?)
 	local entity_tracked = server.track_info.entities[entity]
-	if entity_tracked and entity_tracked[component] then
+	if entity_tracked and entity_tracked.components[component] then
 		server_replicator.change_unreliable(server, entity, component, filter)
 	else
 		server_replicator.start_unreliable(server, entity, component, filter)
 	end
 end
-function server_replicator.set_pair(server: Server, entity: Entity, relation: Component, filter: AnyFilter?)
+
+function server_replicator.set_pair(server: Server, entity: Entity, id: Component, filter: AnyFilter?)
+	local entity_tracked = server.track_info.entities[entity]
+	if entity_tracked and entity_tracked.pairs[id] then
+		server_replicator.change_pair(server, entity, id, filter)
+	else
+		server_replicator.start_pair(server, entity, id, filter)
+	end
+end
+
+function server_replicator.set_relation(server: Server, entity: Entity, relation: Component, filter: AnyFilter?)
 	local entity_tracked = server.track_info.entities[entity]
-	if entity_tracked and entity_tracked[relation] then
-		server_replicator.change_pair(server, entity, relation, filter)
+	if entity_tracked and entity_tracked.components[relation] then
+		server_replicator.change_relation(server, entity, relation, filter)
 	else
-		server_replicator.start_pair(server, entity, relation, filter)
+		server_replicator.start_relation(server, entity, relation, filter)
 	end
 end
+
 function server_replicator.set_custom(server: Server, entity: Entity, handler: Component | CustomId)
 	if server.custom_ids[entity] then
-		utils.logwarn("attempted to register a custom_id twice for the same entity", debug.traceback())
+		common.log_warn("attempted to register a custom_id twice for the same entity", debug.traceback())
 		return
 	end
 	server.custom_ids[entity] = handler
@@ -1377,42 +1873,28 @@ function server_replicator.remove_custom(server: Server, entity: Entity)
 	server.custom_ids[entity] = nil
 end
 
+function server_replicator.set_serdes(server: Server, component: Component, serdes: types.Serdes)
+	server.component_serdes[component] = serdes
+	server.is_shared_dirty = true
+end
+
+function server_replicator.remove_serdes(server: Server, component: Component)
+	server.component_serdes[component] = nil
+	server.is_shared_dirty = true
+end
+
 local function check_created(server: Server)
 	if server.inited == true then
 		warn "attempted to init a server twice"
 		return false
 	end
 	if server.inited == nil then
-		warn "attempted to create a server twice"
+		warn "attempted to init a destroyed server"
 		return false
 	end
 	return true
 end
 
-local function query_tracking_type(server: Server, track_type: Component)
-	for entity in server.world:query(PAIR(track_type, WILDCARD)):iter() do
-		local index = 0
-		while true do
-			local target = server.world:target(entity, track_type, index)
-			if not target then
-				break
-			end
-			server.set_reliable(server, entity, target, server.world:get(entity, PAIR(track_type, target)))
-			index += 1
-		end
-	end
-end
-
-local function query_current_networked(server: Server)
-	for entity, filter in server.world:query(server.components.networked):iter() do
-		server.set_networked(server, entity, filter)
-	end
-
-	query_tracking_type(server, server.components.reliable)
-	query_tracking_type(server, server.components.unreliable)
-	query_tracking_type(server, server.components.pair)
-end
-
 function server_replicator.init(server: Server, wrd: World?)
 	if not check_created(server) then
 		return
@@ -1426,100 +1908,108 @@ function server_replicator.init(server: Server, wrd: World?)
 		error "Providing a world is required to start replecs"
 	end
 
-	local hooks = server.hooks
-	if not hooks then
-		hooks = {
-			added = (world :: any).added,
-			changed = (world :: any).changed,
-			removed = (world :: any).removed,
-		}
-		server.hooks = hooks
+	if not server.components then
+		server.components = utils.create_components(utils.tag_factory(world), utils.component_factory(world))
+		utils.add_component_names(server.components, function(component, name)
+			common.add_name(world, component, name)
+		end)
 	end
 
 	local components = server.components
-	server.shared = utils.resolved_shared(world, components, server.registered_custom_ids)
 
 	local function hook(unhook: () -> ())
 		table.insert(server.hooked, unhook)
 	end
 
-	hook(hooks.added(world, components.networked, function(entity, _, filter)
+	hook(HOOK_ADDED(world, components.networked, function(entity, _, filter)
 		server_replicator.start_networked(server, entity, filter)
 	end))
-	hook(hooks.changed(world, components.networked, function(entity, _, filter)
+	hook(HOOK_CHANGED(world, components.networked, function(entity, _, filter)
 		server_replicator.change_networked(server, entity, filter)
 	end))
-	hook(hooks.removed(world, components.networked, function(entity)
+	hook(HOOK_REMOVED(world, components.networked, function(entity)
 		server_replicator.stop_networked(server, entity)
 	end))
 
-	hook(hooks.added(world, components.reliable, function(entity, id, filter)
-		local component = PAIR_SECOND(world, id)
-		server_replicator.start_reliable(server, entity, component, filter)
-	end))
-	hook(hooks.changed(world, components.reliable, function(entity, id, filter)
-		local component = PAIR_SECOND(world, id)
-		server_replicator.change_reliable(server, entity, component, filter)
-	end))
-	hook(hooks.removed(world, components.reliable, function(entity, id)
-		local component = PAIR_SECOND(world, id)
-		server_replicator.stop_reliable(server, entity, component)
-	end))
+	if RELATIONSHIPS then
+		hook(HOOK_ADDED(world, LISTEN_RELATION(components.reliable), function(entity, id, filter)
+			local component = PAIR_SECOND(world, id)
+			server_replicator.start_reliable(server, entity, component, filter)
+		end))
+		hook(HOOK_CHANGED(world, LISTEN_RELATION(components.reliable), function(entity, id, filter)
+			local component = PAIR_SECOND(world, id)
+			server_replicator.change_reliable(server, entity, component, filter)
+		end))
+		hook(HOOK_REMOVED(world, LISTEN_RELATION(components.reliable), function(entity, id)
+			local component = PAIR_SECOND(world, id)
+			server_replicator.stop_reliable(server, entity, component)
+		end))
 
-	hook(hooks.added(world, components.pair, function(entity, id, filter)
-		local relation = PAIR_SECOND(world, id)
-		server_replicator.start_pair(server, entity, relation, filter)
-	end))
-	hook(hooks.changed(world, components.pair, function(entity, id, filter)
-		local relation = PAIR_SECOND(world, id)
-		server_replicator.change_pair(server, entity, relation, filter)
-	end))
-	hook(hooks.removed(world, components.pair, function(entity, id)
-		local relation = PAIR_SECOND(world, id)
-		server_replicator.stop_pair(server, entity, relation)
-	end))
+		hook(HOOK_ADDED(world, LISTEN_RELATION(components.relation), function(entity, id, filter)
+			local relation = PAIR_SECOND(world, id)
+			server_replicator.start_relation(server, entity, relation, filter)
+		end))
+		hook(HOOK_CHANGED(world, LISTEN_RELATION(components.relation), function(entity, id, filter)
+			local relation = PAIR_SECOND(world, id)
+			server_replicator.change_relation(server, entity, relation, filter)
+		end))
+		hook(HOOK_REMOVED(world, LISTEN_RELATION(components.relation), function(entity, id)
+			local relation = PAIR_SECOND(world, id)
+			server_replicator.stop_relation(server, entity, relation)
+		end))
 
-	hook(hooks.added(world, components.unreliable, function(entity, id, filter)
-		local component = PAIR_SECOND(world, id)
-		server_replicator.start_unreliable(server, entity, component, filter)
-	end))
-	hook(hooks.changed(world, components.unreliable, function(entity, id, filter)
-		local component = PAIR_SECOND(world, id)
-		server_replicator.change_unreliable(server, entity, component, filter)
-	end))
-	hook(hooks.removed(world, components.unreliable, function(entity, id)
-		local component = PAIR_SECOND(world, id)
-		server_replicator.stop_unreliable(server, entity, component)
-	end))
+		hook(HOOK_ADDED(world, LISTEN_RELATION(components.unreliable), function(entity, id, filter)
+			local component = PAIR_SECOND(world, id)
+			server_replicator.start_unreliable(server, entity, component, filter)
+		end))
+		hook(HOOK_CHANGED(world, LISTEN_RELATION(components.unreliable), function(entity, id, filter)
+			local component = PAIR_SECOND(world, id)
+			server_replicator.change_unreliable(server, entity, component, filter)
+		end))
+		hook(HOOK_REMOVED(world, LISTEN_RELATION(components.unreliable), function(entity, id)
+			local component = PAIR_SECOND(world, id)
+			server_replicator.stop_unreliable(server, entity, component)
+		end))
 
-	hook(hooks.added(world, components.custom, function(entity, id)
-		if not IS_PAIR(id) then
-			utils.logerror "replecs.custom should be used with a relationship in the server"
-		end
-		local target = PAIR_SECOND(world, id)
-		server_replicator.set_custom(server, entity, target)
-	end))
-	hook(hooks.removed(world, components.custom, function(entity)
-		server_replicator.remove_custom(server, entity)
-	end))
-	hook(hooks.added(world, components.global, function(entity, _, value)
+		hook(HOOK_ADDED(world, LISTEN_RELATION(components.custom), function(entity, id)
+			if not IS_PAIR(id) then
+				common.log_error "replecs.custom should be used with a relationship in the server"
+			end
+			local target = PAIR_SECOND(world, id)
+			server_replicator.set_custom(server, entity, target)
+		end))
+		hook(HOOK_REMOVED(world, LISTEN_RELATION(components.custom), function(entity)
+			server_replicator.remove_custom(server, entity)
+		end))
+	end
+	hook(HOOK_ADDED(world, components.global, function(entity, _, value)
 		if value > 245 then
-			utils.logerror "global id size exceeded, max is 245"
+			common.log_error "global id size exceeded, max is 245"
 		end
 		server.global_ids[entity] = value
 	end))
 
-	hook(hooks.changed(world, components.global, function(entity, _, value)
+	hook(HOOK_CHANGED(world, components.global, function(entity, _, value)
 		if value > 245 then
-			utils.logerror "global id size exceeded, max is 245"
+			common.log_error "global id size exceeded, max is 245"
 		end
 		server.global_ids[entity] = value
 	end))
-	hook(hooks.removed(world, components.global, function(entity)
+	hook(HOOK_REMOVED(world, components.global, function(entity)
 		server.global_ids[entity] = nil
 	end))
 
-	hook(hooks.removed(world, components.__alive_tracking__, function(entity)
+	hook(HOOK_ADDED(world, components.serdes, function(component, _, serdes)
+		server_replicator.set_serdes(server, component, serdes)
+	end))
+	hook(HOOK_CHANGED(world, components.serdes, function(component, _, serdes)
+		server_replicator.set_serdes(server, component, serdes)
+	end))
+	hook(HOOK_REMOVED(world, components.serdes, function(component)
+		server_replicator.remove_serdes(server, component)
+	end))
+
+	hook(HOOK_REMOVED(world, components.__alive_tracking__, function(entity)
 		if server.track_info.networked[entity] then
 			server_replicator.stop_networked(server, entity)
 		end
@@ -1527,18 +2017,21 @@ function server_replicator.init(server: Server, wrd: World?)
 	end))
 
 	for _, component in server.requires_shared_lookup do
-		hook(hooks.added(world, component, function()
+		hook(HOOK_ADDED(world, component, function()
 			server.is_shared_dirty = true
 		end))
-		hook(hooks.changed(world, component, function()
+		hook(HOOK_CHANGED(world, component, function()
 			server.is_shared_dirty = true
 		end))
-		hook(hooks.removed(world, component, function()
+		hook(HOOK_REMOVED(world, component, function()
 			server.is_shared_dirty = true
 		end))
 	end
 
-	query_current_networked(server)
+	QUERY_CURRENT_COMPONENTS(server)
+	QUERY_CURRENT_NETWORKED(server)
+
+	server.shared = utils.resolved_shared(world, components, server.registered_custom_ids, server.component_serdes)
 
 	if game and game:GetService("RunService"):IsServer() then
 		local Players = game:GetService "Players"
@@ -1558,6 +2051,27 @@ function server_replicator.init(server: Server, wrd: World?)
 	end
 end
 
+function server_replicator.encode_component(server: Server, component: Entity): number
+	server_replicator.resolve_dirty(server)
+	local encoded = server.shared.components.members[component]
+	if not encoded then
+		common.log_error(`attempted to encode a non-shared component `, common.log_component(server.world, component))
+		return 0
+	end
+	return encoded
+end
+
+function server_replicator.decode_component(server: Server, encoded: number): Entity?
+	server_replicator.resolve_dirty(server)
+	local component = server.shared.components.indexes[encoded]
+	return component
+end
+
+function server_replicator.get_shared_count(server: Server): number
+	server_replicator.resolve_dirty(server)
+	return #server.shared.components.keys
+end
+
 function server_replicator.mark_player_ready(server: Server, player: Player)
 	server.masking:activate_client(player)
 end
@@ -1579,14 +2093,14 @@ function server_replicator.register_custom_id(server: Server, custom_id: CustomI
 	server.is_shared_dirty = true
 end
 
-function server_replicator.generate_handshake(server: Server): common.HandshakeInfo
+function server_replicator.generate_handshake(server: Server): types.HandshakeInfo
 	server_replicator.resolve_dirty(server)
-	return utils.generate_handshake(server.world, server.shared)
+	return utils.generate_handshake(server.shared)
 end
 
-function server_replicator.verify_handshake(server: Server, handshake: common.HandshakeInfo): (boolean, string?)
+function server_replicator.verify_handshake(server: Server, handshake: types.HandshakeInfo): (boolean, string?)
 	server_replicator.resolve_dirty(server)
-	return utils.verify_handshake(server.world, server.shared, handshake, "client", "server")
+	return utils.verify_handshake(server.shared, handshake, "client", "server")
 end
 
 function server_replicator.destroy(server: Server)
@@ -1603,12 +2117,19 @@ function server_replicator.destroy(server: Server)
 	end
 end
 
-local function create(world: World?, components: common.Components): Server
+local function create(world: World?, components: types.Components?): Server
 	local self = {} :: Server
 
-	self.components = components
+	if components then
+		self.components = components
+	elseif world then
+		self.components = utils.create_components(utils.tag_factory(world), utils.component_factory(world))
+		utils.add_component_names(self.components, function(component, name)
+			common.add_name(world, component, name)
+		end)
+	end
 
-	self.shared = {} :: common.Shared
+	self.shared = {} :: types.Shared
 	self.world = world :: any
 	self.additions = {}
 	self.storage = {}
@@ -1620,6 +2141,7 @@ local function create(world: World?, components: common.Components): Server
 		networked = {},
 		entities = {},
 		components = {},
+		pairs = {},
 	}
 	self.connections = {}
 	self.inited = false
@@ -1627,21 +2149,12 @@ local function create(world: World?, components: common.Components): Server
 	self.alive_tracked = {}
 	self.custom_ids = {}
 	self.registered_custom_ids = {}
+	self.component_serdes = {}
 	self.requires_shared_lookup = {
 		self.components.shared,
-		self.components.serdes,
-		jecs.Name,
+		ECS_NAME,
 	}
 
-	if world then
-		local hooks = {
-			added = (world :: any).added,
-			changed = (world :: any).changed,
-			removed = (world :: any).removed,
-		}
-		self.hooks = hooks
-	end
-
 	return setmetatable(self, server_replicator) :: any
 end