@rbxts/replecs 0.1.0-alpha2 → 0.1.0-alpha3

package/README.md

@@ -0,0 +1,123 @@
+# Replecs ⚡
+Replecs is a fast, fine controlled JECS replication library 
+
+Replecs is a feature rich, fast, flexible, powerful, and runtime/library agnostic replication library for ECS. 
+
+- Per-entity replication
+- Heavily optimized granular player filtering for entities and components
+- Entity ID remapping
+- Optional serdes for values
+- Luau runtime agnostic
+- Buffer-based replication
+- Bandwidth efficient
+- Supports tags and relationships
+- Unreliable replication, with automatic 1kb buffer size limit
+
+Demo place: https://www.roblox.com/games/132070456195381/
+# Getting Started
+### Roblox-TS
+Install `@rbxts/jecs-addons` `@rbxts/replecs` `@rbxts/jecs`. 
+
+**Make sure you install jecs as v0.8.3, not ^0.9.0** as they are not compatible. You can check the versioning by running `npm ls @rbxts/jecs`
+
+## 🔥Setting Up
+
+`shared/world.ts`
+```ts
+import { observer_add } from "@rbxts/jecs-addons"
+import { world } from "@rbxts/jecs"
+
+// you need to add the observer addon before passing it to the replicator!
+export const world = observer_add(world())
+```
+
+`server/runtime.server.ts`
+```ts
+import { world } from "shared/world"
+import { create_server } from "@rbxts/replecs"
+
+const replicator = create_server(world)
+
+//make sure you call replicator.init before you apply any operations
+replicator.init()
+
+//use whatever networking library you want, I am using @rbxts/remo
+InitialReplecsRemotes.requestInitialPackets.connect(player => {
+	if (replicator.is_player_ready(player)) return;
+	replicator.mark_player_ready(player);
+
+	const [buf, variants] = replicator.get_full(player);
+
+	InitialReplecsRemotes.sendInitialPackets(player, buf, variants);
+});
+```
+
+`client/runtime.client.ts`
+```ts
+import { world } from "shared/world"
+import { create_client } from "@rbxts/replecs"
+
+const replicator = create_server(world)
+
+//make sure you call replicator.init before you apply any operations
+replicator.init()
+
+InitialReplecsRemotes.requestInitialPackets();
+
+InitialReplecsRemotes.sendInitialPackets.connect((buf, variants) => {
+	const replicator = HANDLE.getClientReplicator();
+
+	replicator.apply_full(buf, variants);
+});
+```
+
+## Using in action
+Basic replicated component
+```ts
+const component1 = world.component<string>()
+//you must add shared or Shared component to components you want to replicate
+world.add(component1, shared)
+
+
+const replicatedEntity = world.entity()
+world.set(replicatedEntity, component1, "string")
+
+//you must add replicatedEntity as networked and add the components you want to replicate
+world.add(replicatedEntity, networked)
+
+//this makes components appear in collect_updates
+world.add(replicatedEntity, pair(reliable, component1))
+
+//this makes components appear in collect_unreliable
+world.add(replicatedEntity, pair(unreliable, component1))
+```
+
+Replication process
+```ts
+RunService.Heartbeat.Connect(() => {
+  //this collects reliable updates
+  for (const [player, buf, variants] of serverReplicator.collect_updates()) {
+    //here I am using yetanothernet
+    reliableRoute.send(buf, variants).to(player)
+  }
+
+  //this collects unrealible updates
+  for (const [player, buf, variants] serverReplicator.collect_updates()) {
+      //here I am using yetanothernet
+      unreliableRoute.send(buf, variants).to(player)
+  }
+})
+```
+
+This is the basics of Replecs. For deeper understanding check out the demo folder files here
+- [player first hydration](https://github.com/PepeElToro41/replecs/blob/main/demo/src/server/init.server.luau#L22)
+- [send replication](https://github.com/PepeElToro41/replecs/blob/main/demo/src/server/systems/replecs_server.luau#L12)
+- [receive replication](https://github.com/PepeElToro41/replecs/blob/main/demo/src/client/systems/replecs_client.luau)
+- [setup an entity to replicate](https://github.com/PepeElToro41/replecs/blob/main/demo/src/server/controllers/spawn_cubes.luau#L10)
+- custom ids: [client](https://github.com/PepeElToro41/replecs/blob/main/demo/src/shared/components/init.luau#L33) - [server](https://github.com/PepeElToro41/replecs/blob/main/demo/src/shared/players.luau#L16)
+- [serdes](https://github.com/PepeElToro41/replecs/blob/main/demo/src/shared/components/init.luau#L37)
+- [how you would add `shared` to all components](https://github.com/PepeElToro41/replecs/blob/main/demo/src/shared/components/init.luau#L52)
+- create the replicators: [client](https://github.com/PepeElToro41/replecs/blob/main/demo/src/client/replicator.luau) - [server](https://github.com/PepeElToro41/replecs/blob/main/demo/src/server/replicator.luau)
+- 
+### Luau
+TODO

package/out/replecs/client.luau

@@ -44,6 +44,11 @@ local ENTITY_ID_TYPES = {
 	shared = 3,
 	global = 4,
 }
+local PACKET_TYPES = {
+	full = 1,
+	unreliable = 2,
+	reliable = 3,
+}
 
 local ECS_NAME = jecs.Name
 
@@ -132,7 +137,7 @@ local function read_entity_id(client: Client, c: Cursor, variants: { any }?): (E
 	end
 end
 
-local function process_entity_id(client: Client, c: Cursor, variants: { any }?, v: boolean?)
+local function process_entity_id(client: Client, c: Cursor, variants: { any }?)
 	local entity, server_id = read_entity_id(client, c, variants)
 	if entity then
 		return entity
@@ -141,6 +146,16 @@ local function process_entity_id(client: Client, c: Cursor, variants: { any }?,
 	end
 end
 
+local function process_entity_relation(client: Client, entity: jecs.Entity, c: Cursor, variants: { any }?)
+	local relation = read_component_id(client, c)
+	local total_targets = cursor.read_vlq(c)
+
+	for _ = 1, total_targets do
+		local target = process_entity_id(client, c, variants)
+		client.world:add(entity, PAIR(relation, target))
+	end
+end
+
 local function process_entity(client: Client, c: Cursor, variants: { any }?)
 	local entity = process_entity_id(client, c, variants)
 
@@ -158,45 +173,91 @@ local function process_entity(client: Client, c: Cursor, variants: { any }?)
 
 	local total_pairs = cursor.read_vlq(c)
 	for _ = 1, total_pairs do
-		local relation = read_component_id(client, c)
-		local total_targets = cursor.read_vlq(c)
+		process_entity_relation(client, entity, c, variants)
+	end
+end
 
-		for _ = 1, total_targets do
-			local target = process_entity_id(client, c, variants)
-			client.world:add(entity, PAIR(relation, target))
+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
+				break
+			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
 	end
 end
 
 local function apply_updates(client: Client, buf: buffer, all_variants: { { any } }?)
 	local c = cursor.from(buf)
+	check_packet_type(c, "reliable")
+
 	local total_packets = cursor.read_vlq(c)
 	local variant_start = (all_variants and #all_variants + 1) :: number
 
 	for a = 1, total_packets do
 		local variants = all_variants and all_variants[variant_start - a]
-		local total_added = cursor.read_vlq(c)
+		local storage_mask = cursor.readu8(c)
 
-		for i = 1, total_added do
+		local total_added = read_vlq_bitmask(c, storage_mask, 0)
+		for _ = 1, total_added do
 			process_entity(client, c, variants)
 		end
 
-		local total_changed = cursor.read_vlq(c)
+		local total_components_added = read_vlq_bitmask(c, storage_mask, 1)
+		for _ = 1, total_components_added do
+			local entity = process_entity_id(client, c, variants)
+			local added_mask = cursor.readu8(c)
+
+			local total_tags = read_vlq_bitmask(c, added_mask, 0)
+			for _ = 1, total_tags do
+				local tag = read_component_id(client, c)
+				client.world:add(entity, tag)
+			end
+
+			local total_components = read_vlq_bitmask(c, added_mask, 1)
+			for _ = 1, total_components do
+				local component, value = read_component_value(client, c, variants)
+				client.world:set(entity, component, value)
+			end
+
+			local total_pairs = read_vlq_bitmask(c, added_mask, 2)
+			for _ = 1, total_pairs do
+				process_entity_relation(client, entity, c, variants)
+			end
+		end
+
+		local total_changed = read_vlq_bitmask(c, storage_mask, 2)
 		for _ = 1, total_changed do
 			local entity = process_entity_id(client, c, variants)
-			local total_tagged = cursor.read_vlq(c)
+			local changed_mask = cursor.readu8(c)
+
+			local total_tagged = read_vlq_bitmask(c, changed_mask, 0)
 			for _ = 1, total_tagged do
 				local tag = read_component_id(client, c)
 				client.world:add(entity, tag)
 			end
 
-			local total_components = cursor.read_vlq(c)
+			local total_components = read_vlq_bitmask(c, changed_mask, 1)
 			for _ = 1, total_components do
 				local component, value = read_component_value(client, c, variants)
 				client.world:set(entity, component, value)
 			end
 
-			local total_pairs = cursor.read_vlq(c)
+			local total_pairs = read_vlq_bitmask(c, changed_mask, 2)
 			for _ = 1, total_pairs do
 				local relation = read_component_id(client, c)
 				local total_targets = cursor.read_vlq(c)
@@ -218,37 +279,38 @@ local function apply_updates(client: Client, buf: buffer, all_variants: { { any
 				end
 			end
 
-			local total_removed = cursor.read_vlq(c)
+			local total_removed = read_vlq_bitmask(c, changed_mask, 3)
 			for _ = 1, total_removed do
 				local component = read_component_id(client, c)
 				client.world:remove(entity, component)
 			end
 		end
 
-		local total_component_deleted = cursor.read_vlq(c)
+		local total_component_deleted = read_vlq_bitmask(c, storage_mask, 3)
 		for _ = 1, total_component_deleted do
 			local entity = process_entity_id(client, c, variants)
+			local deleted_mask = cursor.readu8(c)
 
-			local total_tags = cursor.read_vlq(c)
+			local total_tags = read_vlq_bitmask(c, deleted_mask, 0)
 			for _ = 1, total_tags do
 				local tag = read_component_id(client, c)
 				client.world:remove(entity, tag)
 			end
 
-			local total_components = cursor.read_vlq(c)
+			local total_components = read_vlq_bitmask(c, deleted_mask, 1)
 			for _ = 1, total_components do
 				local component = read_component_id(client, c)
 				client.world:remove(entity, component)
 			end
 
-			local total_pairs = cursor.read_vlq(c)
+			local total_pairs = read_vlq_bitmask(c, deleted_mask, 2)
 			for _ = 1, total_pairs do
 				local relation = read_component_id(client, c)
 				utils.remove_all_relations(client.world, entity, relation)
 			end
 		end
 
-		local total_deleted = cursor.read_vlq(c)
+		local total_deleted = read_vlq_bitmask(c, storage_mask, 4)
 		for _ = 1, total_deleted do
 			local entity, server_id = read_entity_id(client, c, variants)
 			if entity then
@@ -263,6 +325,8 @@ end
 
 local function apply_unreliable(client: Client, buf: buffer, all_variants: { { any } }?)
 	local c = cursor.from(buf)
+	check_packet_type(c, "unreliable")
+
 	local total_packets = cursor.read_vlq(c)
 	local variant_start = (all_variants and #all_variants + 1) :: number
 
@@ -290,6 +354,8 @@ end
 
 local function apply_full(client: Client, buf: buffer, all_variants: { { any } }?)
 	local c = cursor.from(buf)
+	check_packet_type(c, "full")
+
 	local total_packets = cursor.read_vlq(c)
 	local variant_start = (all_variants and #all_variants + 1) :: number
 

package/out/replecs/masking/init.luau

@@ -91,6 +91,7 @@ type StorageGroup = {
 
 	changes: {
 		added: Map<Entity, boolean>,
+		added_components: EntityComponentIndex<boolean>,
 		changed: Map<Entity, EntityChanges>,
 	},
 }
@@ -124,6 +125,18 @@ export type MaskingController = {
 		component: Entity,
 		component_type: number
 	) -> (),
+	register_component_addition: (
+		self: MaskingController,
+		entity: Entity,
+		component: Entity,
+		component_type: number
+	) -> (),
+	unregister_component_addition: (
+		self: MaskingController,
+		entity: Entity,
+		component: Entity,
+		component_type: number
+	) -> (),
 	unregister_stop_entity: (self: MaskingController, entity: Entity) -> (),
 	unregister_stop_component: (
 		self: MaskingController,
@@ -245,6 +258,7 @@ function masking_controller.create_new_storage(
 
 		changes = {
 			added = {},
+			added_components = {},
 			changed = {},
 		},
 
@@ -352,6 +366,19 @@ local function get_or_set_active(storage: StorageGroup, entity: Entity, active:
 	return storage_active
 end
 
+local function get_or_set_component_added(
+	storage: StorageGroup,
+	entity: Entity,
+	added: ComponentIndex<boolean>?
+): ComponentIndex<boolean>
+	local storage_added = storage.changes.added_components[entity]
+	if storage_added == nil then
+		storage_added = added or create_component_indexes() :: ComponentIndex<boolean>
+		storage.changes.added_components[entity] = storage_added
+	end
+	return storage_added
+end
+
 local function remove_active(storage: StorageGroup, entity: Entity): ActiveEntity
 	local active = storage.active[entity]
 	if active then
@@ -430,7 +457,24 @@ local function dissect_component_actives(
 	end
 	return new_active
 end
-function dissect_component_changes(changes: EntityChanges, shared_index: ComponentIndex<boolean>)
+
+local function dissect_component_additions(added: ComponentIndex<boolean>, shared_index: ComponentIndex<boolean>)
+	local new_added: ComponentIndex<boolean>
+
+	for component_type, components in added do
+		for component in components do
+			local is_shared = shared_index[component_type] and shared_index[component_type][component]
+			if is_shared then
+				new_added = (new_added or create_component_indexes()) :: ComponentIndex<boolean>
+				new_added[component_type][component] = true
+				added[component_type][component] = nil
+			end
+		end
+	end
+	return new_added
+end
+
+local function dissect_component_changes(changes: EntityChanges, shared_index: ComponentIndex<boolean>)
 	local new_changes: EntityChanges
 
 	for component, change in changes.component do
@@ -468,6 +512,14 @@ local function merge_component_actives(current: ActiveEntity, target: ActiveEnti
 	end
 end
 
+local function merge_component_additions(current: ComponentIndex<boolean>, target: ComponentIndex<boolean>)
+	for component_type, components in current do
+		for component in components do
+			target[component_type][component] = true
+		end
+	end
+end
+
 local function merge_component_changes(current: EntityChanges, target: EntityChanges)
 	for component, change in current.component do
 		target.component[component] = change
@@ -538,9 +590,27 @@ function masking_controller.move_entity_storage(
 		merge_component_actives(old_active, new_active)
 	end
 
+	local old_component_added = storage.changes.added_components[entity]
+	if old_component_added then
+		local new_component_added = get_or_set_component_added(target_storage, entity, old_component_added)
+
+		if shared_with then
+			local dissected_added = dissect_component_additions(old_component_added, shared_with)
+			if dissected_added then
+				storage.changes.added_components[entity] = dissected_added
+			else
+				storage.changes.added_components[entity] = nil
+			end
+		end
+
+		if old_component_added ~= new_component_added then
+			merge_component_additions(old_component_added, new_component_added)
+		end
+	end
+
 	local old_changes = storage.changes.changed[entity]
 	if old_changes then
-		local new_changes = get_or_set_changed(target_storage, entity)
+		local new_changes = get_or_set_changed(target_storage, entity, old_changes)
 
 		if shared_with then
 			local dissected_changes = dissect_component_changes(old_changes, shared_with)
@@ -555,6 +625,12 @@ function masking_controller.move_entity_storage(
 			merge_component_changes(old_changes, new_changes)
 		end
 	end
+
+	if storage.changes.added[entity] then
+		target_storage.changes.added[entity] = true
+		storage.changes.added[entity] = nil
+	end
+
 	return target_storage
 end
 
@@ -579,6 +655,12 @@ function masking_controller.move_component_storage(
 	set_component_index_entry(target_storage.shared_with, entity, component, component_type, true)
 	remove_component_index_entry(storage.shared_with, entity, component, component_type)
 
+	local component_added =
+		get_component_index_entry(storage.changes.added_components, entity, component, component_type)
+	if component_added then
+		set_component_index_entry(target_storage.changes.added_components, entity, component, component_type, true)
+	end
+
 	local changes = storage.changes.changed[entity]
 	if changes then
 		local target_changes = get_or_set_changed(target_storage, entity)
@@ -706,6 +788,18 @@ function masking_controller.register_stop_component(
 		storage.deletions_count += 1
 	end
 end
+
+function masking_controller.register_component_addition(
+	masking: MaskingInternal,
+	entity: Entity,
+	component: Entity,
+	component_type: number
+)
+	local storage = masking:get_component_storage_group(entity, component, component_type)
+	local additions = get_or_set_component_added(storage, entity)
+	additions[component_type][component] = true
+end
+
 function masking_controller.unregister_stop_entity(masking: MaskingInternal, entity: Entity)
 	local deletion_lookup = masking.lookups.deletions.entities[entity]
 	if not deletion_lookup then
@@ -741,6 +835,19 @@ function masking_controller.unregister_stop_component(
 	end
 end
 
+function masking_controller.unregister_component_addition(
+	masking: MaskingInternal,
+	entity: Entity,
+	component: Entity,
+	component_type: number
+)
+	local storage: StorageGroup = masking:get_component_storage_group(entity, component, component_type)
+	local additions = storage.changes.added_components[entity]
+	if additions then
+		additions[component_type][component] = nil
+	end
+end
+
 function masking_controller.propagate_entity_addition(masking: MaskingInternal, entity: Entity)
 	local entity_lookup = masking.lookups.entities[entity]
 	if entity_lookup then
@@ -1115,6 +1222,9 @@ function masking_controller.merge_storages(
 	old_storage: StorageGroup,
 	new_storage: StorageGroup
 )
+	if new_storage == old_storage then
+		return
+	end
 	for entity, active in old_storage.active do
 		local new_active = get_or_set_active(new_storage, entity)
 		merge_component_actives(new_active, active)
@@ -1137,10 +1247,17 @@ function masking_controller.merge_storages(
 			end
 		end
 	end
+	for entity, added_components in old_storage.changes.added_components do
+		local new_added_components = get_or_set_component_added(new_storage, entity)
+		merge_component_additions(new_added_components, added_components)
+	end
 	for entity, changes in old_storage.changes.changed do
 		local new_changes = get_or_set_changes(new_storage, entity)
 		merge_component_changes(new_changes, changes)
 	end
+	for entity in old_storage.changes.added do
+		new_storage.changes.added[entity] = true
+	end
 	for entity in old_storage.deletions.entities do
 		new_storage.deletions.entities[entity] = true
 	end

package/out/replecs/server.luau

@@ -72,6 +72,11 @@ local TRACK_TYPES = {
 	tag = 2,
 	pair = 3,
 }
+local PACKET_TYPES = {
+	full = 1,
+	unreliable = 2,
+	reliable = 3,
+}
 local MAX_PACKET_SIZE = 900
 local ENTITY_ID_TYPES = {
 	entity = 1,
@@ -201,7 +206,7 @@ local function track_component(server: Server, component: Entity<any>)
 			allocate_tag_addition(server, entity, component)
 		else
 			if not IS_PAIR(id) then
-				utils.logerror "a non-pair tag was added to a pair tracked component"
+				return
 			end
 			allocate_pair_addition(server, entity, component, PAIR_SECOND(world, id))
 		end
@@ -226,7 +231,7 @@ local function track_component(server: Server, component: Entity<any>)
 			allocate_tag_removal(server, entity, component)
 		else
 			if not IS_PAIR(id) then
-				utils.logerror "a non-pair tag was removed for a pair tracked component"
+				return
 			end
 			allocate_pair_removal(server, entity, component, PAIR_SECOND(world, id))
 		end
@@ -354,7 +359,7 @@ local function write_component_value(server: Server, c: Cursor, component: Entit
 		end
 	else
 		if value == NIL_COMPONENT_VALUE then
-			-- this is zero for vlq
+			-- 128 is zero for vlq
 			cursor.writeu8(c, 128)
 		else
 			table.insert(variants, value :: any)
@@ -392,6 +397,24 @@ local function write_entity_id(server: Server, c: Cursor, entity: Entity, varian
 	end
 end
 
+local function write_entity_relations(
+	server: Server,
+	storage: EntityStorage,
+	c: Cursor,
+	relation: Entity,
+	variants: { any }
+)
+	local targets = storage.pairs[relation]
+	local total_targets = 0
+
+	for target in targets do
+		write_entity_id(server, c, target, variants)
+		total_targets += 1
+	end
+	cursor.write_vlq(c, total_targets)
+	write_component_id(server, c, relation)
+end
+
 local function write_entity(
 	server: Server,
 	c: Cursor,
@@ -403,15 +426,7 @@ local function write_entity(
 
 	local all_pairs = 0
 	for relation in active.components[COMPONENT_TYPES.pair] do
-		local targets = storage.pairs[relation]
-		local total_targets = 0
-
-		for target in targets do
-			write_entity_id(server, c, target, variants)
-			total_targets += 1
-		end
-		cursor.write_vlq(c, total_targets)
-		write_component_id(server, c, relation)
+		write_entity_relations(server, storage, c, relation, variants)
 		all_pairs += 1
 	end
 	cursor.write_vlq(c, all_pairs)
@@ -419,6 +434,10 @@ local function write_entity(
 	local components = 0
 	for component in active.components[COMPONENT_TYPES.component] do
 		local value = storage.values[component]
+		if value == nil then
+			continue
+		end
+
 		write_component_value(server, c, component, value, variants)
 		components += 1
 	end
@@ -477,8 +496,8 @@ local function append_packet(
 	end
 end
 
-local function combine_packet_outputs(outputs: Array<Packet>, total_size: number): (buffer, { { any } })
-	local combined = buffer.create(total_size + utils.vlq_span(#outputs))
+local function combine_packet_outputs(outputs: Array<Packet>, total_size: number, id: number): (buffer, { { any } })
+	local combined = buffer.create(total_size + utils.vlq_span(#outputs) + 1)
 	local offset = 0
 	local variants = table.create(#outputs) :: { { any } }
 
@@ -491,13 +510,14 @@ local function combine_packet_outputs(outputs: Array<Packet>, total_size: number
 		offset = offset,
 		buffer = combined,
 	}, #outputs)
+	buffer.writeu8(combined, buffer.len(combined) - 1, id)
 
 	return combined, variants
 end
 
 type PacketIterator = () -> (Player, buffer, { { any } })
 
-local function create_packet_iterator(packets: { [Player]: MemberPackets })
+local function create_packet_iterator(packets: { [Player]: MemberPackets }, id: number)
 	local iterated: Player? = nil
 	local function iterator()
 		local player, data = next(packets, iterated)
@@ -506,7 +526,7 @@ local function create_packet_iterator(packets: { [Player]: MemberPackets })
 		end
 		iterated = player
 
-		local combined, variants = combine_packet_outputs(data.packets, data.total_size)
+		local combined, variants = combine_packet_outputs(data.packets, data.total_size, id)
 		return player, combined, variants
 	end
 	return iterator :: PacketIterator
@@ -543,7 +563,7 @@ local function create_unreliable_packet_iterator(packets: { [Player]: MemberPack
 				end
 
 				if #sending > 0 then
-					coroutine.yield(player, combine_packet_outputs(sending, total_size))
+					coroutine.yield(player, combine_packet_outputs(sending, total_size, PACKET_TYPES.unreliable))
 				end
 			end
 		end
@@ -581,7 +601,16 @@ local function get_full(server: Server, member: Player): (buffer, { { any } })
 		total_size += buffer.len(output)
 	end
 
-	return combine_packet_outputs(packets, total_size)
+	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
+	end
 end
 
 local function collect_updates(server: Server)
@@ -589,7 +618,9 @@ local function collect_updates(server: Server)
 
 	for _, storage in server.masking.storages do
 		local c = cursor.new()
+
 		local variants = {}
+		local storage_mask = 0
 
 		local total_deleted = 0
 		local entity_deletions = storage.deletions.entities
@@ -598,47 +629,52 @@ local function collect_updates(server: Server)
 			total_deleted += 1
 		end
 		table.clear(entity_deletions)
-		cursor.write_vlq(c, total_deleted)
+		storage_mask = write_vlq_bitmask(c, total_deleted, storage_mask, 4)
 
 		local total_component_deleted = 0
 		local component_deletions = storage.deletions.components
 		for entity, deleted in component_deletions do
+			local deleted_mask = 0
+
 			local total_pairs = 0
 			for relation in deleted[COMPONENT_TYPES.pair] do
 				write_component_id(server, c, relation)
 				total_pairs += 1
 			end
-			cursor.write_vlq(c, total_pairs)
+			deleted_mask = write_vlq_bitmask(c, total_pairs, deleted_mask, 2)
 
 			local total_components = 0
 			for component in deleted[COMPONENT_TYPES.component] do
 				write_component_id(server, c, component)
 				total_components += 1
 			end
-			cursor.write_vlq(c, total_components)
+			deleted_mask = write_vlq_bitmask(c, total_components, deleted_mask, 1)
 
 			local total_tags = 0
 			for tag in deleted[COMPONENT_TYPES.tag] do
 				write_component_id(server, c, tag)
 				total_tags += 1
 			end
-			cursor.write_vlq(c, total_tags)
+			deleted_mask = write_vlq_bitmask(c, total_tags, deleted_mask, 0)
 
+			cursor.writeu8(c, deleted_mask)
 			write_entity_id(server, c, entity, variants)
 			total_component_deleted += 1
 		end
 		table.clear(component_deletions)
-		cursor.write_vlq(c, total_component_deleted)
+		storage_mask = write_vlq_bitmask(c, total_component_deleted, storage_mask, 3)
 
 		local storage_changes = storage.changes
 		local changed = 0
 		for entity, changes in storage_changes.changed do
+			local changed_mask = 0
+
 			local total_removed = 0
 			for component in changes.removed do
 				write_component_id(server, c, component)
 				total_removed += 1
 			end
-			cursor.write_vlq(c, total_removed)
+			changed_mask = write_vlq_bitmask(c, total_removed, changed_mask, 3)
 
 			local total_pairs = 0
 			for relation, targets in changes.pairs do
@@ -656,27 +692,68 @@ local function collect_updates(server: Server)
 				write_component_id(server, c, relation)
 				total_pairs += 1
 			end
-			cursor.write_vlq(c, total_pairs)
+			changed_mask = write_vlq_bitmask(c, total_pairs, changed_mask, 2)
 
 			local total_components = 0
 			for component, value in changes.component do
 				write_component_value(server, c, component, value, variants)
 				total_components += 1
 			end
-			cursor.write_vlq(c, total_components)
+			changed_mask = write_vlq_bitmask(c, total_components, changed_mask, 1)
 
 			local total_tagged = 0
 			for tag in changes.tagged do
 				write_component_id(server, c, tag)
 				total_tagged += 1
 			end
-			cursor.write_vlq(c, total_tagged)
+			changed_mask = write_vlq_bitmask(c, total_tagged, changed_mask, 0)
 
+			cursor.writeu8(c, changed_mask)
 			write_entity_id(server, c, entity, variants)
 			changed += 1
 		end
 		table.clear(storage_changes.changed)
-		cursor.write_vlq(c, changed)
+		storage_mask = write_vlq_bitmask(c, changed, storage_mask, 2)
+
+		local total_components_added = 0
+		for entity, components in storage_changes.added_components do
+			local entity_storage = server.storage[entity]
+			local added_mask = 0
+
+			local total_pairs = 0
+			for relation in components[COMPONENT_TYPES.pair] do
+				write_entity_relations(server, entity_storage, c, relation, variants)
+				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]
+				if value == nil then
+					continue
+				end
+				write_component_value(server, c, component, value, variants)
+				total_components += 1
+			end
+			added_mask = write_vlq_bitmask(c, total_components, added_mask, 1)
+
+			local total_tags = 0
+			for component in components[COMPONENT_TYPES.tag] do
+				local has_tag = entity_storage.tags[component]
+				if has_tag then
+					write_component_id(server, c, component)
+					total_tags += 1
+				end
+			end
+			added_mask = write_vlq_bitmask(c, total_tags, added_mask, 0)
+
+			cursor.writeu8(c, added_mask)
+			write_entity_id(server, c, entity, variants)
+			total_components_added += 1
+		end
+		table.clear(storage_changes.added_components)
+		storage_mask = write_vlq_bitmask(c, total_components_added, storage_mask, 1)
 
 		local total_added = 0
 		for entity in storage_changes.added do
@@ -689,14 +766,14 @@ local function collect_updates(server: Server)
 			total_added += 1
 		end
 		table.clear(storage_changes.added)
-		cursor.write_vlq(c, total_added)
+		storage_mask = write_vlq_bitmask(c, total_added, storage_mask, 0)
 
+		cursor.writeu8(c, storage_mask)
 		local output = cursor.close(c)
 		append_packet(packets, storage.mask.members, output, variants)
 	end
 	table.clear(server.additions)
-
-	return create_packet_iterator(packets)
+	return create_packet_iterator(packets, PACKET_TYPES.reliable)
 end
 
 local function collect_unreliable(server: Server)
@@ -854,6 +931,8 @@ function init(server: Server, _world: World?)
 		masking:start_component(entity, component, component_type, filter)
 		if server.additions[entity] then
 			masking:allocate_entity_addition(entity, component, component_type)
+		else
+			masking:register_component_addition(entity, component, component_type)
 		end
 	end))
 	hook(hooks.changed(world, components.reliable, function(entity, id, filter)
@@ -881,6 +960,7 @@ function init(server: Server, _world: World?)
 		if not component_type then
 			return
 		end
+		masking:unregister_component_addition(entity, component, component_type)
 		masking:register_stop_component(entity, component, component_type)
 		masking:stop_component(entity, component, component_type)
 	end))
@@ -895,6 +975,8 @@ function init(server: Server, _world: World?)
 		masking:start_component(entity, relation, COMPONENT_TYPES.pair, filter)
 		if server.additions[entity] then
 			masking:allocate_entity_addition(entity, relation, COMPONENT_TYPES.pair)
+		else
+			masking:register_component_addition(entity, relation, COMPONENT_TYPES.pair)
 		end
 	end))
 	hook(hooks.changed(world, components.pair, function(entity, id, filter)
@@ -914,6 +996,7 @@ function init(server: Server, _world: World?)
 
 		local relation = PAIR_SECOND(world, id)
 		untrack_entity_pair(server, entity, relation)
+		masking:unregister_component_addition(entity, relation, COMPONENT_TYPES.pair)
 		masking:register_stop_component(entity, relation, COMPONENT_TYPES.pair)
 		masking:stop_component(entity, relation, COMPONENT_TYPES.pair)
 	end))
@@ -965,13 +1048,14 @@ function init(server: Server, _world: World?)
 	hook(hooks.removed(world, components.custom_id, function(entity)
 		server.custom_ids[entity] = nil
 	end))
-	hook(hooks.added(world, components.global_id, function(entity, id, value)
+	hook(hooks.added(world, components.global_id, function(entity, _, value)
 		if value > 245 then
 			utils.logerror "global id size exceeded, max is 245"
 		end
 		server.global_ids[entity] = value
 	end))
-	hook(hooks.changed(world, components.global_id, function(entity, id, value)
+
+	hook(hooks.changed(world, components.global_id, function(entity, _, value)
 		if value > 245 then
 			utils.logerror "global id size exceeded, max is 245"
 		end

package/out/replecs/utils.luau

@@ -663,6 +663,13 @@ function utils.remove_all_relations(world: World, entity: Entity, relation: Enti
 	end
 end
 
+function utils.setbit(mask: number, bit: number)
+	return bit32.bor(mask, bit32.lshift(1, bit))
+end
+function utils.checkbit(mask: number, bit: number)
+	return bit32.band(mask, bit32.lshift(1, bit)) ~= 0
+end
+
 function utils.logerror(...: string): never
 	error("REPLECS ERROR - " .. table.concat({ ... }, " "))
 end

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@rbxts/replecs",
-   "version": "0.1.0-alpha2",
+   "version": "0.1.0-alpha3",
    "description": "Replication library for Jecs",
    "main": "out/init.lua",
    "types": "out/index.d.ts",
@@ -41,6 +41,6 @@
       "prettier": "^3.2.5"
    },
    "dependencies": {
-      "@rbxts/jecs": "^0.8.3"
+      "@rbxts/jecs": "^0.9.0-rc.7"
    }
 }