@rbxts/replecs 0.2.3 → 0.2.4

package/out/replecs/client.luau

@@ -1,19 +1,19 @@
---!native
 --!optimize 2
+--!native
 
-local jecs = require "../jecs"
-local common = require "./common"
-local customid = require "./customid"
-local utils = require "./utils"
+local common = require (script.Parent:WaitForChild('common'))
+local types = require (script.Parent:WaitForChild('types'))
+local customid = require (script.Parent:WaitForChild('customid'))
+local utils = require (script.Parent:WaitForChild('utils'))
 
 local cursor = utils.cursor
 
 type Cursor = utils.Cursor
 type CustomId = customid.CustomId
 
-type Entity<T = any> = jecs.Entity<T>
-type Id<T = any> = jecs.Id<T>
-type World = jecs.World
+type Entity = common.Entity
+type Component<T = any> = common.Component<T>
+type World = common.World
 
 type Array<T> = { T }
 type Map<K, V> = { [K]: V }
@@ -21,33 +21,46 @@ type Set<T> = { [T]: boolean }
 type Disconnect = () -> ()
 
 type CommandBuffer = {
-	tags: { [Entity]: boolean },
-	components: { [Entity]: { value: any } },
-	unreliable_components: { [Entity]: { value: any } },
-	remove: { [Entity]: boolean },
-	pairs: { [Entity]: Set<Entity> },
-	pairs_values: { [Entity]: { [Entity]: { value: any } } },
-	pairs_remove: { [Entity]: Set<Entity> },
-	pairs_clear: Set<Entity>,
+	tags: Set<Component>,
+	components: Map<Component, { value: any }>,
+	unreliable_components: Map<Component, { value: any }>,
+	remove: Set<Component>,
+
+	pairs_add: { [Component]: Set<Entity> },
+	pairs_set: { [Component]: Map<Entity, { value: any }> },
+	pairs_unprocessed: {
+		[Component]: Map<Entity, {
+			cursor: Cursor,
+			variants: { any }?,
+			processed_value: { value: any }?,
+		}>,
+	},
+	pairs_remove: { [Component]: Set<Entity> },
+	relations_clear: Set<Component>,
 }
 
 type HookMethod =
 	& ((
 		self: Client,
 		action: "changed",
-		relation: Id,
-		callback: (entity: Entity, id: Id, value: any) -> ()
+		relation: Component,
+		callback: (entity: Entity, id: Component, value: any) -> ()
 	) -> Disconnect)
-	& ((self: Client, action: "removed", relation: Id, callback: (entity: Entity, id: Id) -> ()) -> Disconnect)
-	& (self: Client, action: "deleted", entity: Entity, callback: (entity: Entity) -> ()) -> Disconnect
-
+	& ((
+		self: Client,
+		action: "removed",
+		relation: Component,
+		callback: (entity: Entity, id: Component) -> ()
+	) -> Disconnect)
+	& ((self: Client, action: "deleted", entity: Entity, callback: (entity: Entity) -> ()) -> Disconnect
+)
 type ChangedHooksEntry = {
 	overrides: boolean,
-	callbacks: Array<(entity: Entity, id: Id, value: any) -> ()>,
+	callbacks: Array<(entity: Entity, id: Component, value: any) -> ()>,
 }
 type RemovedHooksEntry = {
 	overrides: boolean,
-	callbacks: Array<(entity: Entity, id: Id) -> ()>,
+	callbacks: Array<(entity: Entity, id: Component) -> ()>,
 }
 type DeletedHookEntry = {
 	overrides: boolean,
@@ -56,7 +69,12 @@ type DeletedHookEntry = {
 
 type CustomIdMap = { [Entity]: CustomId | Entity }
 
-export type Client = {
+export type ClientImp = {
+	set_serdes: <T>(client: Client, id: Component<T>, serdes: types.Serdes<T>) -> (),
+	remove_serdes: (client: Client, id: Component) -> (),
+}
+
+export type Client = ClientImp & {
 	world: World,
 	inited: boolean?,
 
@@ -65,16 +83,17 @@ export type Client = {
 
 	is_shared_dirty: boolean,
 	requires_shared_lookup: { Entity },
-	components: common.Components,
-	shared: common.Shared,
+	components: types.Components,
+	shared: types.Shared,
 	global_handler: ((id: number) -> Entity)?,
 	server_ids: { [number]: Entity },
 	client_ids: { [Entity]: number },
-	ordered_creation: boolean,
-	registered_custom_ids: { [CustomId]: boolean },
 	command_buffers: { [Entity]: CommandBuffer }?,
 	command_buffers_active: boolean,
 
+	registered_custom_ids: { [CustomId]: boolean },
+	component_serdes: Map<Component, types.Serdes>,
+
 	init: (self: Client, world: World?) -> (),
 	destroy: (self: Client) -> (),
 	handle_global: (self: Client, handler: (id: number) -> Entity) -> (),
@@ -84,7 +103,6 @@ export type Client = {
 	register_entity: (self: Client, entity: Entity, server_entity: number) -> (),
 	unregister_entity: (self: Client, entity: Entity) -> (),
 
-	hooks: common.WorldHooks,
 	hooked: Array<() -> ()>,
 
 	after_replication: (self: Client, callback: () -> ()) -> (),
@@ -94,20 +112,23 @@ export type Client = {
 	addition_hooks: Array<(entity: Entity) -> ()>,
 	network_hooks: {
 		deleted: { [Entity]: DeletedHookEntry },
-		changed: { [Id]: ChangedHooksEntry },
-		removed: { [Id]: RemovedHooksEntry },
+		changed: { [Component]: ChangedHooksEntry },
+		removed: { [Component]: RemovedHooksEntry },
 	},
 
 	encode_component: (self: Client, component: Entity) -> number,
 	decode_component: (self: Client, component: number) -> Entity,
+	get_shared_count: (self: Client) -> number,
+
 	register_custom_id: (self: Client, custom_id: CustomId) -> (),
 
+	apply_full: (self: Client, buf: buffer, all_variants: { { any } }?) -> (),
+	apply_entity: (self: Client, buf: buffer, all_variants: { { any } }?) -> (),
 	apply_updates: (self: Client, buf: buffer, all_variants: { { any } }?) -> (),
 	apply_unreliable: (self: Client, buf: buffer, all_variants: { { any } }?) -> (),
-	apply_full: (self: Client, buf: buffer, all_variants: { { any } }?) -> (),
 
-	generate_handshake: (self: Client) -> common.HandshakeInfo,
-	verify_handshake: (self: Client, handshake: common.HandshakeInfo) -> (boolean, string?),
+	generate_handshake: (self: Client) -> types.HandshakeInfo,
+	verify_handshake: (self: Client, handshake: types.HandshakeInfo) -> (boolean, string?),
 }
 
 local client_replicator = {}
@@ -123,23 +144,41 @@ local ENTITY_ID_TYPES = {
 }
 local PACKET_TYPES = {
 	full = 1,
-	unreliable = 2,
-	reliable = 3,
+	entity = 2,
+	updates = 3,
+	unreliable = 4,
 }
 
-local WILDCARD = jecs.Wildcard
-
-local function PAIR(first: Entity, second: Entity): Entity
-	return jecs.pair(first, second)
+local ECS_NAME = common.ecs_name
+local ECS_WILDCARD = common.wildcard
+local PAIR = common.pair
+local ITERATE_ALL_RELATIONS = common.iterate_all_relations
+local WORLD_ENTITY = common.world_entity
+local WORLD_ADD = common.world_add
+local WORLD_SET = common.world_set
+local WORLD_REMOVE = common.world_remove
+local WORLD_GET = common.world_get
+local WORLD_DELETE = common.world_delete
+
+local HOOK_ADDED = common.hook_added
+local HOOK_CHANGED = common.hook_changed
+local HOOK_REMOVED = common.hook_removed
+
+local function QUERY_CURRENT_COMPONENTS(client: Client)
+	for component, serdes in client.world:query(client.components.serdes):iter() do
+		client.component_serdes[component] = serdes
+	end
 end
 
 local function get_or_create_entity(client: Client, server_id: number): Entity
+	local world = client.world
+
 	local server_entity = client.server_ids[server_id]
 	if server_entity then
 		return server_entity
 	else
-		local entity = client.world:entity()
-		client.world:add(entity, client.components.__alive_tracking__)
+		local entity = WORLD_ENTITY(world)
+		WORLD_ADD(world, entity, client.components.__alive_tracking__)
 
 		client.server_ids[server_id] = entity
 		client.client_ids[entity] = server_id
@@ -152,11 +191,11 @@ local function get_or_create_entity(client: Client, server_id: number): Entity
 	end
 end
 
-local function get_command_buffer(client: Client, entity: Entity): CommandBuffer
+local function get_or_create_command_buffer(client: Client, entity: Entity): CommandBuffer
 	local command_buffers = client.command_buffers
 
 	if not command_buffers then
-		error "attempted to use a command buffer without having one. (this should never happen)"
+		error "attempted to use a command buffer without being active. (this should never happen)"
 	end
 
 	local command_buffer = command_buffers[entity :: any]
@@ -166,10 +205,11 @@ local function get_command_buffer(client: Client, entity: Entity): CommandBuffer
 			components = {},
 			unreliable_components = {},
 			remove = {},
-			pairs = {},
-			pairs_values = {},
+			pairs_add = {},
+			pairs_set = {},
+			pairs_unprocessed = {},
 			pairs_remove = {},
-			pairs_clear = {},
+			relations_clear = {},
 		}
 		command_buffers[entity :: any] = command_buffer
 	end
@@ -179,41 +219,41 @@ end
 function client_replicator.entity_set(
 	client: Client,
 	entity: Entity,
-	id: Id,
+	id: Component,
 	value: any,
 	changed_hooks: ChangedHooksEntry?
 )
 	if client.command_buffers_active then
-		local command_buffer = get_command_buffer(client, entity)
+		local command_buffer = get_or_create_command_buffer(client, entity)
 		command_buffer.components[id] = { value = value }
 	else
 		if changed_hooks then
 			if not changed_hooks.overrides then
-				client.world:set(entity, id, value)
+				WORLD_SET(client.world, entity, id, value)
 			end
 			for _, callback in changed_hooks.callbacks do
 				callback(entity, id, value)
 			end
 		else
-			client.world:set(entity, id, value)
+			WORLD_SET(client.world, entity, id, value)
 		end
 	end
 end
 
 function client_replicator.entity_add(client: Client, entity: Entity, tag: Entity, changed_hooks: ChangedHooksEntry?)
 	if client.command_buffers_active then
-		local command_buffer = get_command_buffer(client, entity)
+		local command_buffer = get_or_create_command_buffer(client, entity)
 		command_buffer.tags[tag] = true
 	else
 		if changed_hooks then
 			if not changed_hooks.overrides then
-				client.world:add(entity, tag)
+				WORLD_ADD(client.world, entity, tag)
 			end
 			for _, callback in changed_hooks.callbacks do
 				callback(entity, tag)
 			end
 		else
-			client.world:add(entity, tag)
+			WORLD_ADD(client.world, entity, tag)
 		end
 	end
 end
@@ -226,7 +266,7 @@ function client_replicator.entity_set_unreliable(
 	changed_hooks: ChangedHooksEntry?
 )
 	if client.command_buffers_active then
-		local command_buffer = get_command_buffer(client, entity)
+		local command_buffer = get_or_create_command_buffer(client, entity)
 		command_buffer.unreliable_components[id] = { value = value }
 	else
 		client_replicator.entity_set(client, entity, id, value, changed_hooks)
@@ -242,13 +282,13 @@ function client_replicator.entity_set_pair(
 	changed_hooks: ChangedHooksEntry?
 )
 	if client.command_buffers_active then
-		local command_buffer = get_command_buffer(client, entity)
-		local pair_relation = command_buffer.pairs_values[relation]
+		local command_buffer = get_or_create_command_buffer(client, entity)
+		local pair_relation = command_buffer.pairs_set[relation]
 
 		if pair_relation then
 			pair_relation[target] = { value = value }
 		else
-			command_buffer.pairs_values[relation] = { [target] = { value = value } }
+			command_buffer.pairs_set[relation] = { [target] = { value = value } }
 		end
 	else
 		client_replicator.entity_set(client, entity, PAIR(relation, target), value, changed_hooks)
@@ -263,22 +303,56 @@ function client_replicator.entity_add_pair(
 	changed_hooks: ChangedHooksEntry?
 )
 	if client.command_buffers_active then
-		local command_buffer = get_command_buffer(client, entity)
-		local pair_relation = command_buffer.pairs[relation]
+		local command_buffer = get_or_create_command_buffer(client, entity)
+		local pair_relation = command_buffer.pairs_add[relation]
 
 		if pair_relation then
 			pair_relation[target] = true
 		else
-			command_buffer.pairs[relation] = { [target] = true }
+			command_buffer.pairs_add[relation] = { [target] = true }
 		end
 	else
 		client_replicator.entity_add(client, entity, PAIR(relation, target), changed_hooks)
 	end
 end
 
+function client_replicator.entity_set_postponed_pair(
+	client: Client,
+	entity: Entity,
+	relation: Component,
+	target: Entity,
+	c: Cursor,
+	variants: { any }?
+): any
+	if client.command_buffers_active then
+		local commmand_buffer = get_or_create_command_buffer(client, entity)
+		local pairs_unprocessed = commmand_buffer.pairs_unprocessed
+		local pair_relation = pairs_unprocessed[relation]
+		if pair_relation then
+			pair_relation[target] = {
+				cursor = c,
+				variants = variants,
+			}
+		else
+			pairs_unprocessed[relation] = {
+				[target] = {
+					cursor = c,
+					variants = variants,
+				},
+			}
+		end
+		return nil
+	else
+		local pair_id, value = client_replicator.read_pair_value(client, relation, target, c, variants)
+		-- TODO: respect hooks
+		WORLD_SET(client.world, entity, pair_id, value)
+		return value
+	end
+end
+
 function client_replicator.entity_remove(client: Client, entity: Entity, id: Entity, removed_hooks: RemovedHooksEntry?)
 	if client.command_buffers_active then
-		local command_buffer = get_command_buffer(client, entity)
+		local command_buffer = get_or_create_command_buffer(client, entity)
 		command_buffer.remove[id] = true
 	else
 		if removed_hooks then
@@ -286,10 +360,10 @@ function client_replicator.entity_remove(client: Client, entity: Entity, id: Ent
 				callback(entity, id)
 			end
 			if not removed_hooks.overrides then
-				client.world:remove(entity, id)
+				WORLD_REMOVE(client.world, entity, id)
 			end
 		else
-			client.world:remove(entity, id)
+			WORLD_REMOVE(client.world, entity, id)
 		end
 	end
 end
@@ -302,7 +376,7 @@ function client_replicator.entity_remove_pair(
 	removed_hooks: RemovedHooksEntry?
 )
 	if client.command_buffers_active then
-		local command_buffer = get_command_buffer(client, entity)
+		local command_buffer = get_or_create_command_buffer(client, entity)
 		local pair_relation = command_buffer.pairs_remove[relation]
 
 		if pair_relation then
@@ -315,97 +389,91 @@ function client_replicator.entity_remove_pair(
 	end
 end
 
-function client_replicator.entity_remove_relations(
+function client_replicator.entity_clear_relation(
 	client: Client,
 	entity: Entity,
 	relation: Entity,
 	removed_hooks: RemovedHooksEntry?
 )
 	if client.command_buffers_active then
-		local command_buffer = get_command_buffer(client, entity)
-		command_buffer.pairs_clear[relation] = true
+		local command_buffer = get_or_create_command_buffer(client, entity)
+		command_buffer.relations_clear[relation] = true
 	else
 		local world = client.world
-		local entity_index = jecs.entity_index_try_get_fast(world.entity_index :: any, entity :: any)
-		if not entity_index then
-			return
-		end
-		local archetype = entity_index.archetype
-
-		local wildcard = PAIR(relation, WILDCARD) :: any
-		local idr = world.component_index[wildcard]
-		if not idr then
-			return
-		end
-
-		local archetype_id = archetype.id
-		local count = idr.counts[archetype_id]
-		if not count then
-			return
-		end
-
-		local start = idr.records[archetype_id]
-		if not start then
-			return
-		end
-
 		if removed_hooks then
-			for i = start, start + count - 1 do
-				local pair = archetype.types[i]
+			ITERATE_ALL_RELATIONS(world, entity, relation, function(pair)
 				for _, callback in removed_hooks.callbacks do
 					callback(entity, pair)
 				end
 				if not removed_hooks.overrides then
-					world:remove(entity, pair :: any)
+					WORLD_REMOVE(world, entity, pair)
 				end
-			end
+			end)
 		else
-			for i = start, start + count - 1 do
-				local pair = archetype.types[i]
-				world:remove(entity, pair :: any)
-			end
+			ITERATE_ALL_RELATIONS(world, entity, relation, function(pair)
+				WORLD_REMOVE(world, entity, pair)
+			end)
 		end
 	end
 end
 
-function client_replicator.encode_component(client: Client, component: Entity): number
-	local encoded = client.shared.components.members[component]
-	if not encoded then
-		utils.logerror(`attempted to encode a non-shared component `, utils.logcomponent(client.world, component))
-		return 0
-	end
-	return encoded
-end
-function client_replicator.decode_component(client: Client, encoded: number): Entity
-	local component = client.shared.components.indexes[encoded]
-	if not component then
-		print("NON SHARED COMPONENT", encoded, client.shared.components)
-		error "attemped to decode a non shared component"
+local function read_variant_value(c: Cursor, serdes: types.Serdes?, variants: { any }?)
+	if serdes then
+		local bytespan = serdes.bytespan or cursor.read_vlq(c)
+
+		local appended = cursor.read_buffer(c, bytespan)
+		local serdes_variants: { any }? 
+		
+if serdes.includes_variants then
+			local start_variant = cursor.read_vlq(c)
+
+			if start_variant > 0 then
+				local size = cursor.read_vlq(c)
+				serdes_variants = table.move(variants :: { any }, start_variant, start_variant + size - 1, 1, {})
+			end
+		end
+
+		local output = serdes.deserialize(appended, serdes_variants :: any)
+		return output
+	else
+		local variant_id = cursor.read_vlq(c)
+		if variant_id == 0 then
+			return nil
+		end
+		local value = (variants :: { any })[variant_id]
+		return value
 	end
-	return component
 end
 
-function client_replicator.read_component_id(client: Client, c: Cursor): Entity
-	local shared_components = client.shared.components
-	local shared_id = cursor.read_span(c, #shared_components.keys)
-	local component = shared_components.indexes[shared_id]
-	if not component then
-		print("NON SHARED COMPONENT", shared_id, client.shared.components)
-		error "received a non shared component"
-	end
-	return component
+function client_replicator.read_pair_value(
+	client: Client,
+	relation: Component,
+	target: Entity,
+	c: Cursor,
+	variants: { any }?
+)
+	local pair_id = PAIR(relation, target)
+	local pair_wildcard = PAIR(relation, ECS_WILDCARD)
+	local serdes = client.component_serdes[pair_id] or client.component_serdes[pair_wildcard]
+	local value = read_variant_value(c, serdes, variants)
+	return pair_id, value
 end
 
-function client_replicator.read_component_value(client: Client, component: Entity, c: Cursor, variants: { any }?): any
+function client_replicator.read_component_value(
+	client: Client,
+	component: Component,
+	c: Cursor,
+	variants: { any }?
+): any
 	local serdes = client.shared.serdes[component]
 
 	if serdes then
 		local bytespan = serdes.bytespan or cursor.read_vlq(c)
 
 		local appended = cursor.read_buffer(c, bytespan)
-		local serdes_variants: { any }? = nil
-
-		if serdes.includes_variants then
+		local serdes_variants: { any }? 
+		
+if serdes.includes_variants then
 			local start_variant = cursor.read_vlq(c)
 
 			if start_variant > 0 then
@@ -414,7 +482,7 @@ function client_replicator.read_component_value(client: Client, component: Entit
 			end
 		end
 
-		local output = serdes.deserialize(appended, serdes_variants)
+		local output = serdes.deserialize(appended, serdes_variants :: any)
 		return output
 	else
 		local variant_id = cursor.read_vlq(c)
@@ -426,10 +494,15 @@ function client_replicator.read_component_value(client: Client, component: Entit
 	end
 end
 
-function client_replicator.read_component(client: Client, c: Cursor, variants: { any }?): (Entity, any)
-	local component = client_replicator.read_component_id(client, c)
-	local value = client_replicator.read_component_value(client, component, c, variants)
-	return component, value
+function client_replicator.read_component_id(client: Client, c: Cursor): Entity
+	local shared_components = client.shared.components
+	local shared_id = cursor.read_span(c, #shared_components.keys)
+	local component = shared_components.indexes[shared_id]
+	if not component then
+		print("NON SHARED COMPONENT", shared_id, client.shared.components)
+		error "received a non shared component"
+	end
+	return component
 end
 
 function client_replicator.resolve_global(client: Client, global_id: number): Entity
@@ -461,6 +534,14 @@ function client_replicator.read_entity_id(client: Client, c: Cursor): (Entity?,
 	end
 end
 
+local function read_vlq_bitmask(c: Cursor, mask: number, bit: number): number
+	if utils.checkbit(mask, bit) then
+		return cursor.read_vlq(c)
+	else
+		return 0
+	end
+end
+
 function client_replicator.process_entity_id(
 	client: Client,
 	c: Cursor,
@@ -488,7 +569,7 @@ function client_replicator.process_entity_id(
 				local handler = client.shared.custom_ids.indexes[shared_custom_id]
 
 				if not handler then
-					utils.logerror "attempted to use a custom id that wasn't registered"
+					common.log_error "attempted to use a custom id that wasn't registered"
 				end
 				custom_ids[server_id :: any] = handler
 			end
@@ -509,16 +590,11 @@ function client_replicator.process_entity_id(
 	end
 end
 
-function client_replicator.process_entity_relations(
-	client: Client,
-	entity: jecs.Entity,
-	c: Cursor,
-	custom_ids: CustomIdMap
-)
+function client_replicator.process_entity_relations(client: Client, entity: Entity, c: Cursor, custom_ids: CustomIdMap)
 	local components = client.components
 	local relation = client_replicator.read_component_id(client, c)
 	local total_targets = cursor.read_vlq(c)
-	local pair_hooks = client.network_hooks.changed[PAIR(components.pair, relation)]
+	local pair_hooks = client.network_hooks.changed[PAIR(components.relation, relation)]
 
 	for _ = 1, total_targets do
 		client_replicator.process_entity_id(client, c, custom_ids, function(target)
@@ -529,7 +605,7 @@ end
 
 function client_replicator.process_entity_relation_values(
 	client: Client,
-	entity: jecs.Entity,
+	entity: Entity,
 	c: Cursor,
 	custom_ids: CustomIdMap,
 	variants: { any }?
@@ -537,47 +613,99 @@ function client_replicator.process_entity_relation_values(
 	local relation = client_replicator.read_component_id(client, c)
 	local total_targets = cursor.read_vlq(c)
 	local components = client.components
-	local pair_hooks = client.network_hooks.changed[PAIR(components.pair, relation)]
+	local relation_hooks = client.network_hooks.changed[PAIR(components.relation, relation)]
 
 	for _ = 1, total_targets do
 		local value = client_replicator.read_component_value(client, relation, c, variants)
 		client_replicator.process_entity_id(client, c, custom_ids, function(target)
-			client_replicator.entity_set_pair(client, entity, relation, target, value, pair_hooks)
+			client_replicator.entity_set_pair(client, entity, relation, target, value, relation_hooks)
 		end)
 	end
 end
 
-function client_replicator.process_entity(client: Client, c: Cursor, custom_ids: CustomIdMap, variants: { any }?)
-	client_replicator.process_entity_id(client, c, custom_ids, function(entity)
-		local changed_hooks = client.network_hooks.changed
-		local components = client.components
+function client_replicator.process_entity_pair_value(
+	client: Client,
+	entity: Entity,
+	c: Cursor,
+	custom_ids: CustomIdMap,
+	variants: { any }?
+)
+	local relation = client_replicator.read_component_id(client, c)
+	client_replicator.process_entity_id(client, c, custom_ids, function(target)
+		if (target :: any) > 0 then
+			local pointer_offset = cursor.read_vlq(c)
+			local jump_offset = c.offset - pointer_offset
 
-		local total_tags = cursor.read_vlq(c)
-		for _ = 1, total_tags do
-			local tag = client_replicator.read_component_id(client, c)
-			local tag_hooks = changed_hooks[PAIR(components.reliable, tag)]
-			client_replicator.entity_add(client, entity, tag, tag_hooks)
-		end
+			local _, value = client_replicator.read_pair_value(client, relation, target, c, variants)
+			client_replicator.entity_set_pair(client, entity, relation, target, value)
 
-		local total_components = cursor.read_vlq(c)
-		for _ = 1, total_components do
-			local component, value = client_replicator.read_component(client, c, variants)
-			local component_hooks = changed_hooks[PAIR(components.reliable, component)]
-			client_replicator.entity_set(client, entity, component, value, component_hooks)
-		end
+			c.offset = jump_offset
+		else
+			local frozen_cursor = cursor.from_offset(c.buffer, c.offset)
 
-		local total_pairs = cursor.read_vlq(c)
-		for _ = 1, total_pairs do
-			client_replicator.process_entity_relations(client, entity, c, custom_ids)
-		end
+			local pointer_offset = cursor.read_vlq(c)
+			c.offset -= pointer_offset
 
-		local total_pairs_values = cursor.read_vlq(c)
-		for _ = 1, total_pairs_values do
-			client_replicator.process_entity_relation_values(client, entity, c, custom_ids, variants)
+			client_replicator.entity_set_postponed_pair(client, entity, relation, target, frozen_cursor, variants)
 		end
 	end)
 end
 
+function client_replicator.process_entity_pair(client: Client, entity: Entity, c: Cursor, custom_ids: CustomIdMap)
+	local relation = client_replicator.read_component_id(client, c)
+	client_replicator.process_entity_id(client, c, custom_ids, function(target)
+		-- TODO: respect hooks/overrides
+		client_replicator.entity_add_pair(client, entity, relation, target)
+	end)
+end
+
+function client_replicator.process_entity(
+	client: Client,
+	entity: Entity,
+	c: Cursor,
+	custom_ids: CustomIdMap,
+	variants: { any }?
+)
+	local mask = cursor.readu8(c)
+	local changed_hooks = client.network_hooks.changed
+	local components = client.components
+
+	local total_tags = read_vlq_bitmask(c, mask, 0)
+	for _ = 1, total_tags do
+		local tag = client_replicator.read_component_id(client, c)
+		local tag_hooks = changed_hooks[PAIR(components.reliable, tag)]
+		client_replicator.entity_add(client, entity, tag, tag_hooks)
+	end
+
+	local total_components = read_vlq_bitmask(c, mask, 1)
+	for _ = 1, total_components do
+		local component = client_replicator.read_component_id(client, c)
+		local value = client_replicator.read_component_value(client, component, c, variants)
+		local component_hooks = changed_hooks[PAIR(components.reliable, component)]
+		client_replicator.entity_set(client, entity, component, value, component_hooks)
+	end
+
+	local total_pairs = read_vlq_bitmask(c, mask, 2)
+	for _ = 1, total_pairs do
+		client_replicator.process_entity_pair(client, entity, c, custom_ids)
+	end
+
+	local total_pair_values = read_vlq_bitmask(c, mask, 3)
+	for _ = 1, total_pair_values do
+		client_replicator.process_entity_pair_value(client, entity, c, custom_ids, variants)
+	end
+
+	local total_relations = read_vlq_bitmask(c, mask, 4)
+	for _ = 1, total_relations do
+		client_replicator.process_entity_relations(client, entity, c, custom_ids)
+	end
+
+	local total_relation_values = read_vlq_bitmask(c, mask, 5)
+	for _ = 1, total_relation_values do
+		client_replicator.process_entity_relation_values(client, entity, c, custom_ids, variants)
+	end
+end
+
 function client_replicator.finish_replication(client: Client)
 	client.is_replicating = false
 	for _, callback in client.after_replication_callbacks do
@@ -588,32 +716,33 @@ end
 
 function client_replicator.resolve_dirty(client: Client)
 	if client.is_shared_dirty then
-		client.shared = utils.resolved_shared(client.world, client.components, client.registered_custom_ids)
-		client.is_shared_dirty = false :: true -- wtf
+		-- stylua: ignore
+		client.shared = utils.resolved_shared(
+			client.world,
+			client.components,
+			client.registered_custom_ids,
+			client.component_serdes
+		)
+		client.is_shared_dirty = false
 	end
 end
 
-local function check_packet_type(c: Cursor, type: string)
-	local byte_type = PACKET_TYPES[type]
-	local packet_type = cursor.readu8(c)
-	if packet_type ~= byte_type then
-		local got: string = nil :: any
-		for k, v in PACKET_TYPES do
-			if v == packet_type then
-				got = k :: string
-				break
+local function check_packet_type(c: Cursor, expected_byte: number)
+	local got_byte = cursor.readu8(c)
+	if got_byte ~= expected_byte then
+		local got_type: string? 		
+local expected_type: string? 
+		
+for packet_type, byte in PACKET_TYPES :: { [string]: number } do
+			if byte == got_byte then
+				got_type = packet_type
+			elseif byte == expected_byte then
+				expected_type = packet_type
 			end
 		end
-
-		error(`packet type mismatch, expected {type} got {got} instead`)
-	end
-end
-
-local function read_vlq_bitmask(c: Cursor, mask: number, bit: number): number
-	if utils.checkbit(mask, bit) then
-		return cursor.read_vlq(c)
-	else
-		return 0
+		common.log_error(
+			`packet type mismatch, expected: {expected_type or "(unknown)"} got: {got_type or "(unknown)"} instead`
+		)
 	end
 end
 
@@ -621,7 +750,7 @@ function client_replicator.apply_command_buffer(
 	client: Client,
 	entity: Entity,
 	command_buffer: CommandBuffer,
-	request: (e: Entity, ...any) -> Entity?
+	request: (e: Entity,...any) -> Entity?
 )
 	local components = client.components
 
@@ -641,36 +770,59 @@ function client_replicator.apply_command_buffer(
 		local component_hooks = client.network_hooks.removed[PAIR(components.reliable, component)]
 		client_replicator.entity_remove(client, entity, component, component_hooks)
 	end
-	for relation, targets in command_buffer.pairs do
-		local pair_hooks = client.network_hooks.changed[PAIR(components.pair, relation)]
+	for relation, targets in command_buffer.pairs_add do
+		local relation_hooks = client.network_hooks.changed[PAIR(components.relation, relation)]
 		for target in targets do
 			local client_target = request(target)
 			if client_target then
-				client_replicator.entity_add_pair(client, entity, relation, client_target, pair_hooks)
+				client_replicator.entity_add_pair(client, entity, relation, client_target, relation_hooks)
 			end
 		end
 	end
-	for relation, targets in command_buffer.pairs_values do
-		local pair_hooks = client.network_hooks.changed[PAIR(components.pair, relation)]
+	for relation, targets in command_buffer.pairs_set do
+		local relation_hooks = client.network_hooks.changed[PAIR(components.relation, relation)]
 		for target, value in targets do
 			local client_target = request(target)
 			if client_target then
-				client_replicator.entity_set_pair(client, entity, relation, client_target, value.value, pair_hooks)
+				client_replicator.entity_set_pair(client, entity, relation, client_target, value.value, relation_hooks)
 			end
 		end
 	end
+	for relation, targets in command_buffer.pairs_unprocessed do
+		-- TODO: respect hooks
+		for target, unprocessed in targets do
+			local client_target = request(target)
+			if client_target then
+				local processed_value = unprocessed.processed_value
+				if processed_value then
+					client_replicator.entity_set_pair(client, entity, relation, client_target, processed_value.value)
+				else
+					local value = client_replicator.entity_set_postponed_pair(
+						client,
+						entity,
+						relation,
+						client_target,
+						unprocessed.cursor,
+						unprocessed.variants
+					)
+					unprocessed.processed_value = { value = value }
+				end
+			end
+		end
+	end
+
 	for relation, targets in command_buffer.pairs_remove do
-		local pair_hooks = client.network_hooks.removed[PAIR(components.pair, relation)]
+		local relation_hooks = client.network_hooks.removed[PAIR(components.relation, relation)]
 		for target in targets do
 			local client_target = request(target)
 			if client_target then
-				client_replicator.entity_remove_pair(client, entity, relation, client_target, pair_hooks)
+				client_replicator.entity_remove_pair(client, entity, relation, client_target, relation_hooks)
 			end
 		end
 	end
-	for relation in command_buffer.pairs_clear do
-		local pair_hooks = client.network_hooks.removed[PAIR(components.pair, relation)]
-		client_replicator.entity_remove_relations(client, entity, relation, pair_hooks)
+	for relation in command_buffer.relations_clear do
+		local relation_hooks = client.network_hooks.removed[PAIR(components.relation, relation)]
+		client_replicator.entity_clear_relation(client, entity, relation, relation_hooks)
 	end
 end
 
@@ -683,32 +835,44 @@ function client_replicator.find_has_in_buffer(command_buffer: CommandBuffer, tag
 		or (command_buffer.components[tag] ~= nil)
 		or (command_buffer.unreliable_components[tag] ~= nil)
 end
+
 function client_replicator.find_pair_in_buffer(
 	command_buffer: CommandBuffer,
 	relation: Entity,
 	target: Entity,
 	find: (unprocessed_entity: Entity) -> (Entity?, Entity)
 ): (boolean, any)
-	local value_relations = command_buffer.pairs_values[relation]
-
+	local value_relations = command_buffer.pairs_set[relation]
 	if value_relations then
-		for unprocessed_target, value in value_relations do
-			local found = find(unprocessed_target)
+		for buffer_target, value in value_relations do
+			local found = find(buffer_target)
 			if found == target then
 				return true, value.value
 			end
 		end
 	end
 
-	local relations = command_buffer.pairs[relation]
+	local relations = command_buffer.pairs_add[relation]
 	if relations then
-		for unprocessed_target in relations do
-			local found = find(unprocessed_target)
+		for buffer_target in relations do
+			local found = find(buffer_target)
 			if found == target then
 				return true, nil
 			end
 		end
 	end
+
+	local unprocessed_relations = command_buffer.pairs_unprocessed[relation]
+	if unprocessed_relations then
+		for buffer_target, unprocessed in unprocessed_relations do
+			local found = find(buffer_target)
+			if found == target then
+				local processed_value = unprocessed.processed_value
+				return true, processed_value and processed_value.value
+			end
+		end
+	end
+
 	return false, nil
 end
 
@@ -719,7 +883,7 @@ function client_replicator.find_target_in_buffer(
 ): Entity?
 	local i = 0
 
-	local pairs = command_buffer.pairs[relation]
+	local pairs = command_buffer.pairs_add[relation]
 	if pairs then
 		for target in pairs do
 			if i == (index or 0) then
@@ -728,7 +892,8 @@ function client_replicator.find_target_in_buffer(
 			i += 1
 		end
 	end
-	local pairs_values = command_buffer.pairs_values[relation]
+
+	local pairs_values = command_buffer.pairs_set[relation]
 	if pairs_values then
 		for target in pairs_values do
 			if i == (index or 0) then
@@ -737,6 +902,17 @@ function client_replicator.find_target_in_buffer(
 			i += 1
 		end
 	end
+
+	local unprocessed_pairs = command_buffer.pairs_unprocessed[relation]
+	if unprocessed_pairs then
+		for target in unprocessed_pairs do
+			if i == (index or 0) then
+				return target
+			end
+			i += 1
+		end
+	end
+
 	return nil
 end
 
@@ -745,6 +921,7 @@ function client_replicator.finish_custom_ids(
 	custom_ids: CustomIdMap,
 	command_buffers: { [Entity]: CommandBuffer }
 )
+	local world = client.world
 	local funcs = {} -- this is so process can use create_context even if its defined after
 	local processed: { [Entity]: boolean } = {}
 
@@ -771,18 +948,18 @@ function client_replicator.finish_custom_ids(
 			return nil
 		end
 
-		local new_entity: Entity? = nil
-		local command_buffer = command_buffers[unprocessed_entity :: any]
+		local new_entity: Entity? 		
+local command_buffer = command_buffers[unprocessed_entity :: any]
 		custom_handler = custom_handler or custom_ids[server_entity]
 
 		if type(custom_handler) == "number" then
 			local component: Entity = custom_handler :: any
 
-			local handler = client.world:get(component, client.components.custom_handler)
+			local handler = WORLD_GET(world, component, client.components.custom_handler)
 			if not handler then
-				return utils.logerror(
-					`received a custom id for a non custom component, consider adding custom_handler to component: {utils.logcomponent(
-						client.world,
+				return common.log_error(
+					`received a custom id for a non custom component, consider adding custom_handler to component: {common.log_component(
+						world,
 						component
 					)}`
 				)
@@ -792,19 +969,17 @@ function client_replicator.finish_custom_ids(
 				if value then
 					new_entity = handler(value.value)
 				else
-					utils.logwarn(
-						`No component found for custom id handler: {utils.logcomponent(client.world, component)}`
-					)
+					common.log_warn(`No component found for custom id handler: {common.log_component(world, component)}`)
 					new_entity = handler(nil)
 				end
 			else
-				utils.logwarn(`No component found for custom id handler: {utils.logcomponent(client.world, component)}`)
+				common.log_warn(`No component found for custom id handler: {common.log_component(world, component)}`)
 				new_entity = handler(nil)
 			end
 		else
 			local handle_callback = (custom_handler :: CustomId).handle_callback
 			if not handle_callback then
-				return utils.logerror(
+				return common.log_error(
 					"no handler callback was set for custom id:",
 					(custom_handler :: CustomId).identifier
 				)
@@ -813,7 +988,11 @@ function client_replicator.finish_custom_ids(
 		end
 
 		if new_entity then
+			WORLD_ADD(world, new_entity, client.components.__alive_tracking__)
+
 			client.server_ids[server_entity :: any] = new_entity
+			client.client_ids[new_entity] = server_entity :: any
+
 			if command_buffer then
 				client_replicator.apply_command_buffer(client, new_entity, command_buffer, process)
 				command_buffers[unprocessed_entity] = nil
@@ -894,12 +1073,71 @@ function client_replicator.finish_custom_ids(
 	end
 end
 
-function client_replicator.apply_updates(client: Client, buf: buffer, all_variants: { { any } }?)
+function client_replicator.apply_full(client: Client, buf: buffer, all_variants: { { any } }?)
+	client_replicator.resolve_dirty(client)
+	client.is_replicating = true
+
 	local c = cursor.from(buf)
-	check_packet_type(c, "reliable")
+	check_packet_type(c, PACKET_TYPES.full)
+
+	local total_packets = cursor.read_vlq(c)
+	local variant_start = (all_variants and #all_variants + 1) :: number
+
+	local command_buffers: { [Entity]: CommandBuffer } = {}
+	local custom_ids: CustomIdMap = {}
+
+	client.command_buffers = command_buffers
+
+	for a = 1, total_packets do
+		local total_entities = cursor.read_vlq(c)
+		local variants = all_variants and all_variants[variant_start - a]
+
+		for _ = 1, total_entities do
+			client_replicator.process_entity_id(client, c, custom_ids, function(entity)
+				client_replicator.process_entity(client, entity, c, custom_ids, variants)
+			end)
+		end
+	end
+
+	client_replicator.finish_custom_ids(client, custom_ids, command_buffers)
+	client_replicator.finish_replication(client)
+end
+
+function client_replicator.apply_entity(client: Client, buf: buffer, all_variants: { { any } })
+	client_replicator.resolve_dirty(client)
+	client.is_replicating = true
+
+	local c = cursor.from(buf)
+	check_packet_type(c, PACKET_TYPES.entity)
+
+	local total_packets = cursor.read_vlq(c)
+	local variant_start = (all_variants and #all_variants + 1) :: number
+
+	local command_buffers: { [Entity]: CommandBuffer } = {}
+	local custom_ids: CustomIdMap = {}
+
+	client.command_buffers = command_buffers
+
+	for a = 1, total_packets do
+		local variants = all_variants and all_variants[variant_start - a]
+
+		client_replicator.process_entity_id(client, c, custom_ids, function(entity)
+			client_replicator.process_entity(client, entity, c, custom_ids, variants)
+		end)
+	end
+
+	client_replicator.finish_custom_ids(client, custom_ids, command_buffers)
+	client_replicator.finish_replication(client)
+end
+
+function client_replicator.apply_updates(client: Client, buf: buffer, all_variants: { { any } }?)
 	client_replicator.resolve_dirty(client)
 	client.is_replicating = true
 
+	local c = cursor.from(buf)
+	check_packet_type(c, PACKET_TYPES.updates)
+
+	local world = client.world
 	local components = client.components
 	local total_packets = cursor.read_vlq(c)
 	local variant_start = (all_variants and #all_variants + 1) :: number
@@ -918,7 +1156,9 @@ function client_replicator.apply_updates(client: Client, buf: buffer, all_varian
 
 		local total_added = read_vlq_bitmask(c, storage_mask, 0)
 		for _ = 1, total_added do
-			client_replicator.process_entity(client, c, custom_ids, variants)
+			client_replicator.process_entity_id(client, c, custom_ids, function(entity)
+				client_replicator.process_entity(client, entity, c, custom_ids, variants)
+			end)
 		end
 
 		local total_components_added = read_vlq_bitmask(c, storage_mask, 1)
@@ -935,18 +1175,29 @@ function client_replicator.apply_updates(client: Client, buf: buffer, all_varian
 
 				local total_components = read_vlq_bitmask(c, added_mask, 1)
 				for _ = 1, total_components do
-					local component, value = client_replicator.read_component(client, c, variants)
+					local component = client_replicator.read_component_id(client, c)
+					local value = client_replicator.read_component_value(client, component, c, variants)
 					local component_hooks = changed_hooks[PAIR(components.reliable, component)]
 					client_replicator.entity_set(client, entity, component, value, component_hooks)
 				end
 
 				local total_pairs = read_vlq_bitmask(c, added_mask, 2)
 				for _ = 1, total_pairs do
+					client_replicator.process_entity_pair(client, entity, c, custom_ids)
+				end
+
+				local total_pair_values = read_vlq_bitmask(c, added_mask, 3)
+				for _ = 1, total_pair_values do
+					client_replicator.process_entity_pair_value(client, entity, c, custom_ids, variants)
+				end
+
+				local total_relations = read_vlq_bitmask(c, added_mask, 4)
+				for _ = 1, total_relations do
 					client_replicator.process_entity_relations(client, entity, c, custom_ids)
 				end
 
-				local total_pairs_values = read_vlq_bitmask(c, added_mask, 3)
-				for _ = 1, total_pairs_values do
+				local total_relation_values = read_vlq_bitmask(c, added_mask, 5)
+				for _ = 1, total_relation_values do
 					client_replicator.process_entity_relation_values(client, entity, c, custom_ids, variants)
 				end
 			end)
@@ -966,7 +1217,8 @@ function client_replicator.apply_updates(client: Client, buf: buffer, all_varian
 
 				local total_components = read_vlq_bitmask(c, changed_mask, 1)
 				for _ = 1, total_components do
-					local component, value = client_replicator.read_component(client, c, variants)
+					local component = client_replicator.read_component_id(client, c)
+					local value = client_replicator.read_component_value(client, component, c, variants)
 					local component_hooks = changed_hooks[PAIR(components.reliable, component)]
 					client_replicator.entity_set(client, entity, component, value, component_hooks)
 				end
@@ -978,57 +1230,63 @@ function client_replicator.apply_updates(client: Client, buf: buffer, all_varian
 					client_replicator.entity_remove(client, entity, component, component_hooks)
 				end
 
-				local total_pairs = read_vlq_bitmask(c, changed_mask, 3)
-				for _ = 1, total_pairs do
+				local total_pairs_added = read_vlq_bitmask(c, changed_mask, 3)
+				for _ = 1, total_pairs_added do
+					client_replicator.process_entity_pair(client, entity, c, custom_ids)
+				end
+
+				local total_pairs_set = read_vlq_bitmask(c, changed_mask, 4)
+				for _ = 1, total_pairs_set do
+					client_replicator.process_entity_pair(client, entity, c, custom_ids)
+				end
+
+				local total_pairs_removed = read_vlq_bitmask(c, changed_mask, 5)
+				for _ = 1, total_pairs_removed do
+					local relation = client_replicator.read_component_id(client, c)
+					client_replicator.process_entity_id(client, c, custom_ids, function(target)
+						-- TODO: respect hooks/overrides
+						client_replicator.entity_remove_pair(client, entity, relation, target)
+					end)
+				end
+
+				local total_relations_added = read_vlq_bitmask(c, changed_mask, 6)
+				for _ = 1, total_relations_added do
 					local relation = client_replicator.read_component_id(client, c)
-					local pair_changed_hooks = changed_hooks[PAIR(components.pair, relation)]
-					local pair_removed_hooks = removed_hooks[PAIR(components.pair, relation)]
 					local total_targets = cursor.read_vlq(c)
+					local pair_changed_hooks = changed_hooks[PAIR(components.relation, relation)]
 
 					for _ = 1, total_targets do
-						local action_type = cursor.readi8(c)
-
-						if action_type == 1 then -- add pair
-							client_replicator.process_entity_id(client, c, custom_ids, function(target)
-								client_replicator.entity_add_pair(client, entity, relation, target, pair_changed_hooks)
-							end)
-						elseif action_type == -1 then -- remove pair
-							client_replicator.process_entity_id(client, c, custom_ids, function(target)
-								client_replicator.entity_remove_pair(
-									client,
-									entity,
-									relation,
-									target,
-									pair_removed_hooks
-								)
-							end)
-						end
+						client_replicator.process_entity_id(client, c, custom_ids, function(target)
+							client_replicator.entity_add_pair(client, entity, relation, target, pair_changed_hooks)
+						end)
 					end
 				end
 
-				local total_pairs_values_removed = read_vlq_bitmask(c, changed_mask, 4)
-				for _ = 1, total_pairs_values_removed do
+				local total_relation_values = read_vlq_bitmask(c, changed_mask, 7)
+				for _ = 1, total_relation_values do
 					local relation = client_replicator.read_component_id(client, c)
-					local pair_hooks = removed_hooks[PAIR(components.pair, relation)]
 					local total_targets = cursor.read_vlq(c)
+					local pair_changed_hooks = changed_hooks[PAIR(components.relation, relation)]
 
 					for _ = 1, total_targets do
+						local value = client_replicator.read_component_value(client, relation, c, variants)
 						client_replicator.process_entity_id(client, c, custom_ids, function(target)
-							client_replicator.entity_remove_pair(client, entity, relation, target, pair_hooks)
+							client_replicator.entity_set_pair(client, entity, relation, target, value, pair_changed_hooks)
 						end)
 					end
 				end
 
-				local total_pairs_values = read_vlq_bitmask(c, changed_mask, 5)
-				for _ = 1, total_pairs_values do
+				-- using a normal vlq here sadly
+				-- cause I ran out of bitmask space for this one :/
+				local total_relations_removed = cursor.read_vlq(c)
+				for _ = 1, total_relations_removed do
 					local relation = client_replicator.read_component_id(client, c)
-					local pair_hooks = changed_hooks[PAIR(components.pair, relation)]
 					local total_targets = cursor.read_vlq(c)
+					local pair_removed_hooks = removed_hooks[PAIR(components.relation, relation)]
 
 					for _ = 1, total_targets do
-						local value = client_replicator.read_component_value(client, relation, c, variants)
 						client_replicator.process_entity_id(client, c, custom_ids, function(target)
-							client_replicator.entity_set_pair(client, entity, relation, target, value, pair_hooks)
+							client_replicator.entity_remove_pair(client, entity, relation, target, pair_removed_hooks)
 						end)
 					end
 				end
@@ -1038,8 +1296,8 @@ function client_replicator.apply_updates(client: Client, buf: buffer, all_varian
 		local total_component_deletions = read_vlq_bitmask(c, storage_mask, 3)
 		for _ = 1, total_component_deletions do
 			client_replicator.process_entity_id(client, c, custom_ids, function(entity)
-				local total_removed = cursor.read_vlq(c)
-				for _ = 1, total_removed do
+				local total_components = cursor.read_vlq(c)
+				for _ = 1, total_components do
 					local component = client_replicator.read_component_id(client, c)
 					local component_hooks = removed_hooks[PAIR(components.reliable, component)]
 					client_replicator.entity_remove(client, entity, component, component_hooks)
@@ -1048,8 +1306,17 @@ function client_replicator.apply_updates(client: Client, buf: buffer, all_varian
 				local total_pairs = cursor.read_vlq(c)
 				for _ = 1, total_pairs do
 					local relation = client_replicator.read_component_id(client, c)
-					local pair_hooks = removed_hooks[PAIR(components.pair, relation)]
-					client_replicator.entity_remove_relations(client, entity, relation, pair_hooks)
+					client_replicator.process_entity_id(client, c, custom_ids, function(target)
+						-- TODO: respect hooks/overrides
+						client_replicator.entity_remove_pair(client, entity, relation, target)
+					end)
+				end
+
+				local total_relations = cursor.read_vlq(c)
+				for _ = 1, total_relations do
+					local relation = client_replicator.read_component_id(client, c)
+					local pair_hooks = removed_hooks[PAIR(components.relation, relation)]
+					client_replicator.entity_clear_relation(client, entity, relation, pair_hooks)
 				end
 			end)
 		end
@@ -1064,10 +1331,10 @@ function client_replicator.apply_updates(client: Client, buf: buffer, all_varian
 						callback(entity)
 					end
 					if not deleted_hook.overrides then
-						client.world:delete(entity)
+						WORLD_DELETE(world, entity)
 					end
 				else
-					client.world:delete(entity)
+					WORLD_DELETE(world, entity)
 				end
 			end
 			if server_id then
@@ -1081,11 +1348,12 @@ function client_replicator.apply_updates(client: Client, buf: buffer, all_varian
 end
 
 function client_replicator.apply_unreliable(client: Client, buf: buffer, all_variants: { { any } }?)
-	local c = cursor.from(buf)
-	check_packet_type(c, "unreliable")
 	client_replicator.resolve_dirty(client)
 	client.is_replicating = true
 
+	local c = cursor.from(buf)
+	check_packet_type(c, PACKET_TYPES.unreliable)
+
 	local components = client.components
 	local total_packets = cursor.read_vlq(c)
 	local variant_start = (all_variants and #all_variants + 1) :: number
@@ -1101,15 +1369,17 @@ function client_replicator.apply_unreliable(client: Client, buf: buffer, all_var
 
 			if entity then
 				for _ = 1, total_unreliable do
-					local component_id, value = client_replicator.read_component(client, c, variants)
-					local unreliable_hooks = changed_hooks[PAIR(components.unreliable, component_id)]
-					client_replicator.entity_set_unreliable(client, entity, component_id, value, unreliable_hooks)
+					local component = client_replicator.read_component_id(client, c)
+					local value = client_replicator.read_component_value(client, component, c, variants)
+					local unreliable_hooks = changed_hooks[PAIR(components.unreliable, component)]
+					client_replicator.entity_set_unreliable(client, entity, component, value, unreliable_hooks)
 				end
 			else
 				-- dont apply unreliable updates to entities that dont exist in the client yet
 				-- but we still need to process the values to keep the cursor in the right place
 				for _ = 1, total_unreliable do
-					client_replicator.read_component(client, c, variants)
+					local component = client_replicator.read_component_id(client, c)
+					client_replicator.read_component_value(client, component, c, variants)
 				end
 			end
 		end
@@ -1118,34 +1388,19 @@ function client_replicator.apply_unreliable(client: Client, buf: buffer, all_var
 	client_replicator.finish_replication(client)
 end
 
-function client_replicator.apply_full(client: Client, buf: buffer, all_variants: { { any } }?)
-	local c = cursor.from(buf)
-	check_packet_type(c, "full")
-	client_replicator.resolve_dirty(client)
-	client.is_replicating = true
-
-	local total_packets = cursor.read_vlq(c)
-	local variant_start = (all_variants and #all_variants + 1) :: number
-
-	local command_buffers: { [Entity]: CommandBuffer } = {}
-	local custom_ids: CustomIdMap = {}
-
-	client.command_buffers = command_buffers
-
-	for a = 1, total_packets do
-		local total_entities = cursor.read_vlq(c)
-		local variants = all_variants and all_variants[variant_start - a]
-
-		for _ = 1, total_entities do
-			client_replicator.process_entity(client, c, custom_ids, variants)
-		end
-	end
+function client_replicator.set_serdes(client: Client, component: Component, serdes: types.Serdes)
+	client.component_serdes[component] = serdes
+	client.is_shared_dirty = true
+end
 
-	client_replicator.finish_custom_ids(client, custom_ids, command_buffers)
-	client_replicator.finish_replication(client)
+function client_replicator.remove_serdes(client: Client, component: Component)
+	client.component_serdes[component] = nil
+	client.is_shared_dirty = true
 end
 
-function client_replicator.init(client: Client, _world: World?)
+-- TODO: Deserialize pairs in client
+
+function client_replicator.init(client: Client, wrd: World?)
 	if client.inited == true then
 		return warn "attempted to init a client twice"
 	end
@@ -1154,44 +1409,57 @@ function client_replicator.init(client: Client, _world: World?)
 	end
 	client.inited = true :: any
 
-	local world = _world or client.world
+	local world = wrd or client.world
 	client.world = world
 
 	if not world then
 		error "Providing a world is required to start replecs"
 	end
 
-	local hooks = {
-		added = (world :: any).added,
-		changed = (world :: any).changed,
-		removed = (world :: any).removed,
-	}
-	client.hooks = hooks
+	if not client.components then
+		client.components = utils.create_components(utils.tag_factory(world), utils.component_factory(world))
+		utils.add_component_names(client.components, function(component, name)
+			common.add_name(world, component, name)
+		end)
+	end
 
 	local components = client.components
 
-	client.shared = utils.resolved_shared(world, components, client.registered_custom_ids)
+	local function hook(unhook: () -> ())
+		table.insert(client.hooked, unhook)
+	end
 
-	local alive_unhook = hooks.removed(world, components.__alive_tracking__, function(entity)
+	hook(HOOK_REMOVED(world, components.__alive_tracking__, function(entity)
 		local server_id = client.client_ids[entity]
 		if server_id then
 			client.server_ids[server_id] = nil
 			client.client_ids[entity] = nil
 		end
 		client.network_hooks.deleted[entity] = nil
-	end)
-	table.insert(client.hooked, alive_unhook)
+	end))
+
+	hook(HOOK_ADDED(world, components.serdes, function(component, _, serdes)
+		client_replicator.set_serdes(client, component, serdes)
+	end))
+	hook(HOOK_CHANGED(world, components.serdes, function(component, _, serdes)
+		client_replicator.set_serdes(client, component, serdes)
+	end))
+	hook(HOOK_REMOVED(world, components.serdes, function(component)
+		client_replicator.remove_serdes(client, component)
+	end))
 
 	for _, component in client.requires_shared_lookup do
-		local added_hook = hooks.added(world, component, function()
+		hook(HOOK_ADDED(world, component, function()
 			client.is_shared_dirty = true
-		end)
-		local removed_hook = hooks.removed(world, component, function()
+		end))
+		hook(HOOK_REMOVED(world, component, function()
 			client.is_shared_dirty = true
-		end)
-		table.insert(client.hooked, added_hook)
-		table.insert(client.hooked, removed_hook)
+		end))
 	end
+
+	QUERY_CURRENT_COMPONENTS(client)
+
+	client.shared = utils.resolved_shared(world, components, client.registered_custom_ids, client.component_serdes)
 end
 
 function client_replicator.after_replication(client: Client, callback: () -> ())
@@ -1215,7 +1483,7 @@ end
 local function add_hook_entry(client: Client, action: string, ...): ({ overrides: boolean }, () -> ())
 	if action == "changed" or action == "removed" then
 		local relation = select(1, ...) :: Entity
-		local callback = select(2, ...) :: (entity: Entity, id: number, value: any) -> ()
+		local callback = select(2, ...) :: (entity: Entity, id: Component, value: any) -> ()
 		local hooks = action == "changed" and client.network_hooks.changed or client.network_hooks.removed
 		local entries = hooks[relation] :: ChangedHooksEntry
 
@@ -1281,6 +1549,31 @@ function client_replicator.override(client: Client, action: string, ...)
 	return disconnect
 end
 
+function client_replicator.encode_component(client: Client, component: Entity): number
+	client_replicator.resolve_dirty(client)
+	local encoded = client.shared.components.members[component]
+	if not encoded then
+		common.log_error(`attempted to encode a non-shared component `, common.log_component(client.world, component))
+		return 0
+	end
+	return encoded
+end
+
+function client_replicator.decode_component(client: Client, encoded: number): Entity
+	client_replicator.resolve_dirty(client)
+	local component = client.shared.components.indexes[encoded]
+	if not component then
+		print("NON SHARED COMPONENT", encoded, client.shared.components)
+		error "attemped to decode a non shared component"
+	end
+	return component
+end
+
+function client_replicator.get_shared_count(client: Client): number
+	client_replicator.resolve_dirty(client)
+	return #client.shared.components.keys
+end
+
 function client_replicator.get_server_entity(client: Client, client_entity: Entity): number?
 	return client.client_ids[client_entity]
 end
@@ -1292,7 +1585,7 @@ end
 function client_replicator.register_entity(client: Client, entity: Entity, server_entity: number)
 	client.server_ids[server_entity] = entity
 	client.client_ids[entity] = server_entity
-	client.world:add(entity, client.components.__alive_tracking__)
+	WORLD_ADD(client.world, entity, client.components.__alive_tracking__)
 end
 
 function client_replicator.unregister_entity(client: Client, entity: Entity)
@@ -1308,14 +1601,14 @@ function client_replicator.register_custom_id(client: Client, custom_id: CustomI
 	client.is_shared_dirty = true
 end
 
-function client_replicator.generate_handshake(client: Client): common.HandshakeInfo
+function client_replicator.generate_handshake(client: Client): types.HandshakeInfo
 	client_replicator.resolve_dirty(client)
-	return utils.generate_handshake(client.world, client.shared)
+	return utils.generate_handshake(client.shared)
 end
 
-function client_replicator.verify_handshake(client: Client, handshake: common.HandshakeInfo): (boolean, string?)
+function client_replicator.verify_handshake(client: Client, handshake: types.HandshakeInfo): (boolean, string?)
 	client_replicator.resolve_dirty(client)
-	return utils.verify_handshake(client.world, client.shared, handshake, "server", "client")
+	return utils.verify_handshake(client.shared, handshake, "server", "client")
 end
 
 function client_replicator.destroy(client: Client)
@@ -1332,18 +1625,25 @@ function client_replicator.handle_global(client: Client, handler: (id: number) -
 	client.global_handler = handler
 end
 
-local function create(world: World?, components: common.Components): Client
+local function create(world: World?, components: types.Components?): Client
 	local self = {} :: Client
 
-	self.components = components
-	self.ordered_creation = true
+	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.server_ids = {}
 	self.client_ids = {}
 	self.is_shared_dirty = false
+	self.component_serdes = {}
 	self.requires_shared_lookup = {
 		self.components.shared,
-		self.components.serdes,
-		jecs.Name,
+		ECS_NAME,
 	}
 	self.global_handler = nil
 	self.world = world :: any