@rbxts/replecs 0.2.3 → 0.2.4

package/out/replecs/masking/init.luau

@@ -1,11 +1,12 @@
 --!native
 --!optimize 2
 
-local jecs = require "../jecs"
-local utils = require "./utils"
-local mask_generator = require "@self/mask_generator"
+local common = require (script.Parent:WaitForChild('common'))
+local utils = require (script.Parent:WaitForChild('utils'))
+local mask_generator = require (script:WaitForChild('mask_generator'))
 
-type Entity<T = any> = jecs.Entity<T>
+type Entity = common.Entity
+type Component<T = any> = common.Component<T>
 
 type Bitmask = utils.Bitmask
 type MaskGenerator = mask_generator.MaskGenerator
@@ -25,33 +26,46 @@ export type FunctionFilter = (player: Player) -> boolean
 export type ComponentIndex<T> = {
 	[number]: { [Entity]: T },
 }
+
 export type EntityComponentIndex<T> = {
 	[Entity]: ComponentIndex<T>,
 }
 
-type Lookup = {
+export type Lookup = {
 	generator: MaskGenerator,
 	filter: MemberFilter?,
 	storage_group: StorageGroup,
 }
 
-type ComponentLookup = Lookup & {
+export type ComponentLookup = Lookup & {
 	band_generator: MaskGenerator,
 }
 
-type EntityLookup = Lookup & {
+export type EntityLookup = Lookup & {
 	filtered_components: ComponentIndex<ComponentLookup>,
 	components: ComponentIndex<true>,
 }
 
 export type EntityChanges = {
-	tagged: { [Entity]: boolean },
-	component: { [Entity]: any },
-	removed: { [Entity]: boolean },
-	pairs: { [Entity]: Set<Entity> },
-	pairs_values: {
-		changed: { [Entity]: Map<Entity, any> },
-		removed: { [Entity]: Set<Entity> },
+	tagged: Set<Component>,
+	component: Map<Component, any>,
+	removed: {
+		component: Set<Component>,
+		tag: Set<Component>,
+	},
+
+	pair_changed: Map<Component, any>,
+	pair_added: Set<Component>,
+	pair_removed: {
+		component: Set<Component>,
+		tag: Set<Component>,
+	},
+
+	relation_added: { [Component]: Set<Entity> },
+	relation_value: { [Component]: Map<Entity, any> },
+	relation_removed: {
+		component: { [Component]: Set<Entity> },
+		tag: { [Component]: Set<Entity> },
 	},
 }
 
@@ -84,7 +98,7 @@ type MaskInfo = {
 	members: Array<Member>,
 }
 
-type StorageGroup = {
+export type StorageGroup = {
 	mask: MaskInfo,
 	shared_with: EntityComponentIndex<boolean>,
 	is_empty: boolean,
@@ -109,7 +123,7 @@ type Storages = {
 	[MaskHash]: StorageGroup,
 }
 
-export type MaskingController = {
+export type MaskingControllerClass = {
 	member_count: number,
 
 	client_indexes: { [Member]: number },
@@ -125,103 +139,26 @@ export type MaskingController = {
 
 	storages: Storages,
 	lookups: LookupsList,
-
-	register_mask_group: (self: MaskingController, group: Member) -> (),
-	unregister_mask_group: (self: MaskingController, group: Member) -> (),
-	register_client: (self: MaskingController, member: Member) -> (),
-	unregister_client: (self: MaskingController, member: Member) -> (),
-	activate_client: (self: MaskingController, member: Member) -> (),
-	member_is_active: (self: MaskingController, member: Member) -> boolean,
-
-	register_stop_entity: (self: MaskingController, entity: Entity) -> (),
-	register_stop_component: (
-		self: MaskingController,
-		entity: Entity,
-		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,
-		entity: Entity,
-		component: Entity,
-		component_type: number
-	) -> (),
-
-	propagate_entity_addition: (self: MaskingController, entity: Entity) -> (),
-
-	start_entity: (self: MaskingController, entity: Entity, filter: GivenFilter?) -> (),
-	set_entity: (self: MaskingController, entity: Entity, filter: GivenFilter?) -> (),
-	stop_entity: (self: MaskingController, entity: Entity) -> (),
-	cleanup_entity: (self: MaskingController, entity: Entity) -> (),
-
-	start_component: (
-		self: MaskingController,
-		entity: Entity,
-		component: Entity,
-		component_type: number,
-		filter: GivenFilter?
-	) -> (),
-	set_component: (
-		self: MaskingController,
-		entity: Entity,
-		component: Entity,
-		component_type: number,
-		filter: GivenFilter?
-	) -> (),
-	stop_component: (self: MaskingController, entity: Entity, component: Entity, component_type: number) -> (),
-
-	allocate_entity_addition: (
-		self: MaskingController,
-		entity: Entity,
-		component: Entity,
-		component_type: number
-	) -> (),
-
-	allocate_component_change: (self: MaskingController, entity: Entity, component: Entity, value: any) -> (),
-	allocate_pair_value_change: (
-		self: MaskingController,
-		entity: Entity,
-		relation: Entity,
-		target: Entity,
-		value: any
-	) -> (),
-
-	allocate_tag_addition: (self: MaskingController, entity: Entity, tag: Entity) -> (),
-	allocate_pair_addition: (self: MaskingController, entity: Entity, relation: Entity, target: Entity) -> (),
-
-	allocate_component_removal: (self: MaskingController, entity: Entity, component: Entity) -> (),
-	allocate_pair_value_removal: (self: MaskingController, entity: Entity, relation: Entity, target: Entity) -> (),
-	allocate_tag_removal: (self: MaskingController, entity: Entity, tag: Entity) -> (),
-	allocate_pair_removal: (self: MaskingController, entity: Entity, relation: Entity, target: Entity) -> (),
 }
 
 local COMPONENT_TYPES = {
-	component = 1,
-	tag = 2,
-	pair = 3,
-	pair_value = 4,
-	unreliable = 5,
+	tag = 1,
+	component = 2,
+	pair_tag = 3,
+	pair_component = 4,
+	relation = 5,
+	relation_value = 6,
+	unreliable = 7,
 }
 
+local COMPONENT_TYPES_COUNT = COMPONENT_TYPES.unreliable
+
 local masking_controller = {}
 masking_controller.__index = masking_controller
 
-export type MaskingInternal = MaskingController & typeof(masking_controller)
+export type MaskingController = MaskingControllerClass & typeof(masking_controller)
 
-function masking_controller.get_clients_from_bitmask(controller: MaskingInternal, bitmask: Bitmask): Array<Member>
+function masking_controller.get_clients_from_bitmask(controller: MaskingController, bitmask: Bitmask): Array<Member>
 	local members: { Member } = {}
 	for player, index in controller.client_indexes do
 		if bitmask:get(index) then
@@ -243,25 +180,41 @@ local function get_usable_filter(filter: (MemberFilter | any)?): MemberFilter?
 	end
 end
 
-local function create_component_indexes<T>()
-	return { {}, {}, {}, {}, {} } :: ComponentIndex<any>
+local function create_component_indexes<T>(): ComponentIndex<T>
+	local indexes = {}
+	for i = 1, COMPONENT_TYPES_COUNT do
+		indexes[i] = {}
+	end
+	return indexes
 end
 
 local function create_entity_changes(): EntityChanges
 	return {
 		tagged = {},
 		component = {},
-		removed = {},
-		pairs = {},
-		pairs_values = {
-			changed = {},
-			removed = {},
+		removed = {
+			component = {},
+			tag = {},
+		},
+
+		pair_added = {},
+		pair_changed = {},
+		pair_removed = {
+			component = {},
+			tag = {},
+		},
+
+		relation_added = {},
+		relation_value = {},
+		relation_removed = {
+			component = {},
+			tag = {},
 		},
 	}
 end
 
 function masking_controller.create_new_storage(
-	controller: MaskingInternal,
+	controller: MaskingController,
 	bitmask: Bitmask,
 	hash: string?,
 	members: Array<Member>?
@@ -313,7 +266,7 @@ end
 local function get_component_index_entry<T>(
 	index: EntityComponentIndex<T>,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number
 ): T?
 	local entity_index = index[entity]
@@ -328,7 +281,7 @@ end
 local function set_component_index_entry<T>(
 	index: EntityComponentIndex<T>,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number,
 	value: T
 )
@@ -343,7 +296,7 @@ end
 local function remove_component_index_entry(
 	index: EntityComponentIndex<any>,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number
 )
 	local entity_index = index[entity]
@@ -415,10 +368,10 @@ local function remove_active(storage: StorageGroup, entity: Entity): ActiveEntit
 		-- todo: check if empty
 		return active
 	end
-	return utils.logerror "attempted to remove an entity that wasn't active"
+	return common.log_error "attempted to remove an entity that wasn't active"
 end
 
-local function get_or_set_component_active(active: ActiveEntity, component: Entity, component_type: number)
+local function get_or_set_component_active(active: ActiveEntity, component: Component, component_type: number)
 	local components = active.components[component_type]
 	if components[component] == nil then
 		components[component] = true
@@ -426,7 +379,12 @@ local function get_or_set_component_active(active: ActiveEntity, component: Enti
 	end
 end
 
-local function remove_component_active(storage: StorageGroup, entity: Entity, component: Entity, component_type: number)
+local function remove_component_active(
+	storage: StorageGroup,
+	entity: Entity,
+	component: Component,
+	component_type: number
+)
 	local active = storage.active[entity]
 	if not active then
 		return
@@ -443,7 +401,7 @@ local function remove_component_active(storage: StorageGroup, entity: Entity, co
 	end
 end
 
-function masking_controller.get_or_create_storage_group(masking: MaskingInternal, bitmask: Bitmask): StorageGroup
+function masking_controller.get_or_create_storage_group(masking: MaskingController, bitmask: Bitmask): StorageGroup
 	local hash = bitmask:tostring()
 	local storage = masking.storages[hash]
 
@@ -455,12 +413,16 @@ function masking_controller.get_or_create_storage_group(masking: MaskingInternal
 end
 
 function masking_controller.get_component_lookup(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number
 ): (ComponentLookup, EntityLookup)
 	local entity_lookup = masking.lookups.entities[entity]
+	if not entity_lookup then
+		return nil :: any
+	end
+
 	return entity_lookup.filtered_components[component_type][component], entity_lookup
 end
 
@@ -505,48 +467,127 @@ end
 local function dissect_component_changes(changes: EntityChanges, shared_index: ComponentIndex<boolean>)
 	local new_changes: EntityChanges
 
+	-- COMPONENTS
+
+	local shared_component = shared_index[COMPONENT_TYPES.component]
+	local shared_tag = shared_index[COMPONENT_TYPES.tag]
+
 	for component, change in changes.component do
-		local is_shared = shared_index[COMPONENT_TYPES.component] and shared_index[COMPONENT_TYPES.component][component]
+		local is_shared = shared_component and shared_component[component]
 		if is_shared then
 			new_changes = new_changes or create_entity_changes()
 			new_changes.component[component] = change
 			changes.component[component] = nil
 		end
 	end
-	for entity, entity_changes in changes.tagged do
-		local is_shared = shared_index[COMPONENT_TYPES.tag] and shared_index[COMPONENT_TYPES.tag][entity]
+	for tag in changes.tagged do
+		local is_shared = shared_tag and shared_tag[tag]
+		if is_shared then
+			new_changes = new_changes or create_entity_changes()
+			new_changes.tagged[tag] = true
+			changes.tagged[tag] = nil
+		end
+	end
+
+	local removed_changes = changes.removed
+	for component in removed_changes.component do
+		local is_shared = shared_component and shared_component[component]
+		if is_shared then
+			new_changes = new_changes or create_entity_changes()
+			new_changes.removed.component[component] = true
+			removed_changes.component[component] = nil
+		end
+	end
+	for component in removed_changes.tag do
+		local is_shared = shared_tag and shared_tag[component]
+		if is_shared then
+			new_changes = new_changes or create_entity_changes()
+			new_changes.removed.tag[component] = true
+			removed_changes.tag[component] = nil
+		end
+	end
+
+	-- PAIRS
+
+	local shared_pair_component = shared_index[COMPONENT_TYPES.pair_component]
+	local shared_pair_tag = shared_index[COMPONENT_TYPES.pair_tag]
+
+	for id, change in changes.pair_changed do
+		local is_shared = shared_pair_component and shared_pair_component[id]
+		if is_shared then
+			new_changes = new_changes or create_entity_changes()
+			new_changes.pair_changed[id] = change
+			changes.pair_changed[id] = nil
+		end
+	end
+	for id in changes.pair_added do
+		local is_shared = shared_pair_tag and shared_pair_tag[id]
+		if is_shared then
+			new_changes = new_changes or create_entity_changes()
+			new_changes.pair_added[id] = true
+			changes.pair_added[id] = nil
+		end
+	end
+
+	local removed_pairs = changes.pair_removed
+	for id in removed_pairs.component do
+		local is_shared = shared_pair_component and shared_pair_component[id]
+		if is_shared then
+			new_changes = new_changes or create_entity_changes()
+			new_changes.pair_removed.component[id] = true
+			removed_pairs.component[id] = nil
+		end
+	end
+	for id in removed_pairs.tag do
+		local is_shared = shared_pair_tag and shared_pair_tag[id]
+		if is_shared then
+			new_changes = new_changes or create_entity_changes()
+			new_changes.pair_removed.tag[id] = true
+			removed_pairs.tag[id] = nil
+		end
+	end
+
+	-- RELATIONS
+
+	local shared_relation_value = shared_index[COMPONENT_TYPES.relation_value]
+	local shared_relation = shared_index[COMPONENT_TYPES.relation]
+
+	for relation, target_values in changes.relation_value do
+		local is_shared = shared_relation_value and shared_relation_value[relation]
+
 		if is_shared then
 			new_changes = new_changes or create_entity_changes()
-			new_changes.tagged[entity] = entity_changes
-			changes.tagged[entity] = nil
+			new_changes.relation_value[relation] = target_values
+			changes.relation_value[relation] = nil
 		end
 	end
-	for relation, entity_changes in changes.pairs do
-		local is_shared = shared_index[COMPONENT_TYPES.pair] and shared_index[COMPONENT_TYPES.pair][relation]
+	for relation, targets_added in changes.relation_added do
+		local is_shared = shared_relation and shared_relation[relation]
+
 		if is_shared then
 			new_changes = new_changes or create_entity_changes()
-			new_changes.pairs[relation] = entity_changes
-			changes.pairs[relation] = nil
+			new_changes.relation_added[relation] = targets_added
+			changes.relation_added[relation] = nil
 		end
 	end
-	for relation, entity_changes in changes.pairs_values.changed do
-		local is_shared = shared_index[COMPONENT_TYPES.pair_value]
-			and shared_index[COMPONENT_TYPES.pair_value][relation]
+
+	local removed_relations = changes.relation_removed
+	for relation, targets_removed in removed_relations.component do
+		local is_shared = shared_relation and shared_relation[relation]
 
 		if is_shared then
 			new_changes = new_changes or create_entity_changes()
-			new_changes.pairs_values.changed[relation] = entity_changes
-			changes.pairs_values.changed[relation] = nil
+			new_changes.relation_removed.component[relation] = targets_removed
+			removed_relations.component[relation] = nil
 		end
 	end
-	for relation, entity_changes in changes.pairs_values.removed do
-		local is_shared = shared_index[COMPONENT_TYPES.pair_value]
-			and shared_index[COMPONENT_TYPES.pair_value][relation]
+	for relation, targets_removed in removed_relations.tag do
+		local is_shared = shared_relation and shared_relation[relation]
 
 		if is_shared then
 			new_changes = new_changes or create_entity_changes()
-			new_changes.pairs_values.removed[relation] = entity_changes
-			changes.pairs_values.removed[relation] = nil
+			new_changes.relation_removed.tag[relation] = targets_removed
+			removed_relations.tag[relation] = nil
 		end
 	end
 
@@ -569,27 +610,68 @@ local function merge_component_additions(current: ComponentIndex<boolean>, targe
 	end
 end
 
-local function merge_component_changes(current: EntityChanges, target: EntityChanges)
+local function merge_component_changes(current: EntityChanges, destination: EntityChanges)
+	-- COMPONENTS/TAGS
+
 	for component, change in current.component do
-		target.component[component] = change
+		destination.component[component] = change
 	end
-	for entity, entity_changes in current.tagged do
-		target.tagged[entity] = entity_changes
+	for tag in current.tagged do
+		destination.tagged[tag] = true
 	end
-	for entity, entity_changes in current.pairs do
-		target.pairs[entity] = entity_changes
+
+	local components_removed = current.removed
+	for tag in components_removed.component do
+		destination.removed.component[tag] = true
+	end
+	for tag in components_removed.tag do
+		destination.removed.tag[tag] = true
+	end
+
+	-- PAIRS
+
+	for id, change in current.pair_changed do
+		destination.pair_changed[id] = change
+	end
+	for id in current.pair_added do
+		destination.pair_added[id] = true
+	end
+
+	local pairs_removed = current.pair_removed
+	for id in pairs_removed.component do
+		destination.pair_removed.component[id] = true
+	end
+	for id in pairs_removed.tag do
+		destination.pair_removed.tag[id] = true
+	end
+
+	-- RELATIONS
+
+	for relation, target_values in current.relation_value do
+		destination.relation_value[relation] = target_values
+	end
+	for relation, added_targets in current.relation_added do
+		destination.relation_added[relation] = added_targets
+	end
+
+	local relation_removed = current.relation_removed
+	for relation, removed_targets in relation_removed.component do
+		destination.relation_removed.component[relation] = removed_targets
+	end
+	for relation, removed_targets in relation_removed.tag do
+		destination.relation_removed.tag[relation] = removed_targets
 	end
 end
 
 function masking_controller.merge_component_filter(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number
 )
 	local component_lookup, entity_lookup = masking:get_component_lookup(entity, component, component_type)
 	if not entity_lookup then
-		utils.logerror "attempted to merge a component filter to an unactive entity"
+		common.log_error "attempted to merge a component filter to an unactive entity"
 	end
 
 	if component_lookup ~= nil then
@@ -609,19 +691,19 @@ function masking_controller.merge_component_filter(
 end
 
 function masking_controller.move_entity_storage(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
 	storage: StorageGroup,
-	target: Bitmask
+	destination: Bitmask
 )
-	local target_storage = masking:get_or_create_storage_group(target)
-	if target_storage == storage then
+	local destination_storage = masking:get_or_create_storage_group(destination)
+	if destination_storage == storage then
 		return storage
 	end
 	local shared_with = storage.shared_with[entity]
 
 	local old_active = storage.active[entity]
-	local new_active = get_or_set_active(target_storage, entity, old_active)
+	local new_active = get_or_set_active(destination_storage, entity, old_active)
 
 	new_active.is_entity_mask = true
 
@@ -642,7 +724,7 @@ function masking_controller.move_entity_storage(
 
 	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)
+		local new_component_added = get_or_set_component_added(destination_storage, entity, old_component_added)
 
 		if shared_with then
 			local dissected_added = dissect_component_additions(old_component_added, shared_with)
@@ -660,7 +742,7 @@ function masking_controller.move_entity_storage(
 
 	local old_changes = storage.changes.changed[entity]
 	if old_changes then
-		local new_changes = get_or_set_changed(target_storage, entity, old_changes)
+		local new_changes = get_or_set_changed(destination_storage, entity, old_changes)
 
 		if shared_with then
 			local dissected_changes = dissect_component_changes(old_changes, shared_with)
@@ -677,78 +759,90 @@ function masking_controller.move_entity_storage(
 	end
 
 	if storage.changes.added[entity] then
-		target_storage.changes.added[entity] = true
+		destination_storage.changes.added[entity] = true
 		storage.changes.added[entity] = nil
 	end
 
-	return target_storage
+	return destination_storage
 end
 
 function masking_controller.move_component_storage(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number,
 	storage: StorageGroup,
-	target: Bitmask
+	destination: Bitmask
 )
-	local target_storage = masking:get_or_create_storage_group(target)
-	if target_storage == storage then
+	local destination_storage = masking:get_or_create_storage_group(destination)
+	if destination_storage == storage then
 		return storage
 	end
 
-	local new_active = get_or_set_active(target_storage, entity)
+	local new_active = get_or_set_active(destination_storage, entity)
 
 	remove_component_active(storage, entity, component, component_type)
 	get_or_set_component_active(new_active, component, component_type)
 
-	set_component_index_entry(target_storage.shared_with, entity, component, component_type, true)
+	set_component_index_entry(destination_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
 		remove_component_index_entry(storage.changes.added_components, entity, component, component_type)
-		set_component_index_entry(target_storage.changes.added_components, entity, component, component_type, true)
+		set_component_index_entry(destination_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)
+		local destination_changes = get_or_set_changed(destination_storage, entity)
 		if component_type == COMPONENT_TYPES.tag then
-			target_changes.tagged[component] = changes.tagged[component]
-			target_changes.removed[component] = changes.removed[component]
+			destination_changes.tagged[component] = changes.tagged[component]
+			destination_changes.removed.tag[component] = changes.removed.tag[component]
 
 			changes.tagged[component] = nil
-			changes.removed[component] = nil
+			changes.removed.tag[component] = nil
 		elseif component_type == COMPONENT_TYPES.component then
-			target_changes.component[component] = changes.component[component]
-			target_changes.removed[component] = changes.removed[component]
+			destination_changes.component[component] = changes.component[component]
+			destination_changes.removed.component[component] = changes.removed.component[component]
 
 			changes.component[component] = nil
-			changes.removed[component] = nil
-		elseif component_type == COMPONENT_TYPES.pair then
-			target_changes.pairs[component] = changes.pairs[component]
-			changes.pairs[component] = nil
-		elseif component_type == COMPONENT_TYPES.pair_value then
-			local target_pairs = target_changes.pairs_values
-			local pairs = changes.pairs_values
-
-			target_pairs.changed[component] = pairs.changed[component]
-			target_pairs.removed[component] = pairs.removed[component]
-
-			pairs.changed[component] = nil
-			pairs.removed[component] = nil
+			changes.removed.component[component] = nil
+		elseif component_type == COMPONENT_TYPES.pair_tag then
+			destination_changes.pair_added[component] = changes.pair_added[component]
+			destination_changes.pair_removed.tag[component] = changes.pair_removed.tag[component]
+
+			changes.pair_added[component] = nil
+			changes.pair_removed.tag[component] = nil
+		elseif component_type == COMPONENT_TYPES.pair_component then
+			destination_changes.pair_changed[component] = changes.pair_changed[component]
+			destination_changes.pair_removed.component[component] = changes.pair_removed.component[component]
+
+			changes.pair_changed[component] = nil
+			changes.pair_removed.component[component] = nil
+		elseif component_type == COMPONENT_TYPES.relation then
+			destination_changes.relation_added[component] = changes.relation_added[component]
+			destination_changes.relation_removed.tag[component] = changes.relation_removed.tag[component]
+
+			changes.relation_added[component] = nil
+			changes.relation_removed.tag[component] = nil
+		elseif component_type == COMPONENT_TYPES.relation_value then
+			destination_changes.relation_value[component] = changes.relation_value[component]
+			destination_changes.relation_removed.component[component] = changes.relation_removed.component[component]
+
+			changes.relation_value[component] = nil
+			changes.relation_removed.component[component] = nil
 		end
 	end
 
-	return target_storage
+	return destination_storage
 end
 
 function masking_controller.bind_component_generator(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number,
 	base_generator: MaskGenerator
 )
@@ -776,7 +870,7 @@ function masking_controller.bind_component_generator(
 	return generator
 end
 
-function masking_controller.rebind_component_generators(masking: MaskingInternal, entity: Entity)
+function masking_controller.rebind_component_generators(masking: MaskingController, entity: Entity)
 	local entity_lookup = masking.lookups.entities[entity]
 	if entity_lookup then
 		for component_type, lookups in entity_lookup.filtered_components do
@@ -793,9 +887,9 @@ function masking_controller.rebind_component_generators(masking: MaskingInternal
 end
 
 function masking_controller.get_or_postpone_entity_lookup(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number,
 	filter: MemberFilter?
 ): EntityLookup?
@@ -813,116 +907,8 @@ function masking_controller.get_or_postpone_entity_lookup(
 	return nil
 end
 
-function masking_controller.register_stop_entity(masking: MaskingInternal, entity: Entity)
-	local lookup = masking.lookups.entities[entity]
-	if not lookup then
-		return
-	end
-	local storage = lookup.storage_group
-
-	if storage.deletions.entities[entity] then
-		return
-	end
-	storage.deletions.entities[entity] = true
-end
-
-function masking_controller.register_stop_component(
-	masking: MaskingInternal,
-	entity: Entity,
-	component: Entity,
-	component_type: number
-)
-	local storage = masking:get_component_storage_group(entity, component, component_type) :: StorageGroup
-	if not storage then
-		return
-	end
-
-	local deletions = storage.deletions.components[entity]
-	if deletions == nil then
-		deletions = create_component_indexes() :: ComponentIndex<boolean>
-		deletions[component_type][component] = true
-		storage.deletions.components[entity] = deletions
-	else
-		if deletions[component_type][component] then
-			return
-		end
-		deletions[component_type][component] = true
-	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
-		return
-	end
-	local storage = deletion_lookup.storage_group
-
-	if storage.deletions.entities[entity] then
-		storage.deletions.entities[entity] = nil
-		storage.deletions_count -= 1
-	end
-end
-
-function masking_controller.unregister_stop_component(
-	masking: MaskingInternal,
-	entity: Entity,
-	component: Entity,
-	component_type: number
-)
-	local deletion_lookup =
-		get_component_index_entry(masking.lookups.deletions.components, entity, component, component_type)
-	if deletion_lookup == nil then
-		return
-	end
-	local storage = deletion_lookup.storage_group
-
-	local deletions = storage.deletions.components[entity]
-	if deletions then
-		if deletions[component_type][component] then
-			deletions[component_type][component] = nil
-		end
-	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
-		entity_lookup.storage_group.changes.added[entity] = true
-
-		for _, lookups in entity_lookup.filtered_components do
-			for _, lookup in lookups do
-				lookup.storage_group.changes.added[entity] = true
-			end
-		end
-	end
-end
-
 function masking_controller.update_entity_filter(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
 	filter: MemberFilter?
 ): MaskGenerator
@@ -948,7 +934,7 @@ function masking_controller.update_entity_filter(
 	return generator
 end
 
-function masking_controller.start_entity(masking: MaskingInternal, entity: Entity, given_filter: GivenFilter?)
+function masking_controller.start_entity(masking: MaskingController, entity: Entity, given_filter: GivenFilter?)
 	local filter = get_usable_filter(given_filter)
 	local generator = masking:update_entity_filter(entity, filter)
 
@@ -960,8 +946,8 @@ function masking_controller.start_entity(masking: MaskingInternal, entity: Entit
 		generator = generator,
 		filter = filter,
 		storage_group = storage_group,
-		filtered_components = create_component_indexes(),
-		components = create_component_indexes(),
+		filtered_components = create_component_indexes() :: ComponentIndex<ComponentLookup>,
+		components = create_component_indexes() :: ComponentIndex<true>,
 	}
 	masking.lookups.entities[entity] = new_lookup
 
@@ -976,11 +962,11 @@ function masking_controller.start_entity(masking: MaskingInternal, entity: Entit
 	end
 end
 
-function masking_controller.set_entity(masking: MaskingInternal, entity: Entity, given_filter: GivenFilter?)
+function masking_controller.set_entity(masking: MaskingController, entity: Entity, given_filter: GivenFilter?)
 	local filter = get_usable_filter(given_filter)
 	local lookup = masking.lookups.entities[entity]
 	if not lookup then
-		utils.logerror "attempted to modify the filter of an unactive entity"
+		common.log_error "attempted to modify the filter of an unactive entity"
 	end
 	lookup.generator:destroy()
 
@@ -993,10 +979,10 @@ function masking_controller.set_entity(masking: MaskingInternal, entity: Entity,
 	masking:rebind_component_generators(entity)
 end
 
-function masking_controller.stop_entity(masking: MaskingInternal, entity: Entity)
+function masking_controller.stop_entity(masking: MaskingController, entity: Entity)
 	local lookup = masking.lookups.entities[entity]
 	if not lookup then
-		utils.logerror "attemped to stop an unactive entity"
+		common.log_error "attemped to stop an unactive entity"
 	end
 
 	local postponed = masking.lookups.postponed[entity]
@@ -1039,7 +1025,7 @@ function masking_controller.stop_entity(masking: MaskingInternal, entity: Entity
 	masking.lookups.entities[entity] = nil
 end
 
-function masking_controller.cleanup_entity(masking: MaskingInternal, entity: Entity)
+function masking_controller.cleanup_entity(masking: MaskingController, entity: Entity)
 	masking.lookups.entities[entity] = nil
 	masking.lookups.postponed[entity] = nil
 	masking.lookups.deletions.entities[entity] = nil
@@ -1047,9 +1033,9 @@ function masking_controller.cleanup_entity(masking: MaskingInternal, entity: Ent
 end
 
 function masking_controller.update_component_filter(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number,
 	filter: MemberFilter
 )
@@ -1059,9 +1045,9 @@ function masking_controller.update_component_filter(
 end
 
 function masking_controller.start_component(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number,
 	given_filter: GivenFilter?
 )
@@ -1094,9 +1080,9 @@ function masking_controller.start_component(
 end
 
 function masking_controller.set_component(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number,
 	given_filter: GivenFilter?
 )
@@ -1156,9 +1142,9 @@ function masking_controller.set_component(
 end
 
 function masking_controller.stop_component(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number
 )
 	local component_lookup, entity_lookup = masking:get_component_lookup(entity, component, component_type)
@@ -1180,9 +1166,9 @@ function masking_controller.stop_component(
 end
 
 function masking_controller.get_component_storage_group(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number
 ): StorageGroup
 	local component_lookup, entity_lookup = masking:get_component_lookup(entity, component, component_type)
@@ -1196,10 +1182,23 @@ function masking_controller.get_component_storage_group(
 	end
 end
 
-function masking_controller.allocate_entity_addition(
-	masking: MaskingInternal,
+function masking_controller.allocate_propagated_entity_start(masking: MaskingController, entity: Entity)
+	local entity_lookup = masking.lookups.entities[entity]
+	if entity_lookup then
+		entity_lookup.storage_group.changes.added[entity] = true
+
+		for _, lookups in entity_lookup.filtered_components do
+			for _, lookup in lookups do
+				lookup.storage_group.changes.added[entity] = true
+			end
+		end
+	end
+end
+
+function masking_controller.allocate_shared_entity_start(
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	component_type: number
 )
 	local lookup = masking:get_component_lookup(entity, component, component_type)
@@ -1208,113 +1207,249 @@ function masking_controller.allocate_entity_addition(
 	end
 end
 
+function masking_controller.allocate_entity_stop(masking: MaskingController, entity: Entity)
+	local lookup = masking.lookups.entities[entity]
+	if not lookup then
+		return
+	end
+	local storage = lookup.storage_group
+
+	if storage.deletions.entities[entity] then
+		return
+	end
+	storage.deletions.entities[entity] = true
+end
+
+function masking_controller.allocate_component_start(
+	masking: MaskingController,
+	entity: Entity,
+	component: Component,
+	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.allocate_component_stop(
+	masking: MaskingController,
+	entity: Entity,
+	component: Component,
+	component_type: number
+)
+	local storage = masking:get_component_storage_group(entity, component, component_type) :: StorageGroup
+	if not storage then
+		return
+	end
+
+	local deletions = storage.deletions.components[entity]
+	if deletions == nil then
+		deletions = create_component_indexes() :: ComponentIndex<boolean>
+		deletions[component_type][component] = true
+		storage.deletions.components[entity] = deletions
+	else
+		deletions[component_type][component] = true
+	end
+end
+
+function masking_controller.deallocate_component_start(
+	masking: MaskingController,
+	entity: Entity,
+	component: Component,
+	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.deallocate_entity_stop(masking: MaskingController, entity: Entity)
+	local deletion_lookup = masking.lookups.deletions.entities[entity]
+	if not deletion_lookup then
+		return
+	end
+	local storage = deletion_lookup.storage_group
+
+	if storage.deletions.entities[entity] then
+		storage.deletions.entities[entity] = nil
+		storage.deletions_count -= 1
+	end
+end
+
+function masking_controller.deallocate_component_stop(
+	masking: MaskingController,
+	entity: Entity,
+	component: Component,
+	component_type: number
+)
+	local deletion_lookup =
+		get_component_index_entry(masking.lookups.deletions.components, entity, component, component_type)
+	if deletion_lookup == nil then
+		return
+	end
+	local storage = deletion_lookup.storage_group
+
+	local deletions = storage.deletions.components[entity]
+	if deletions then
+		if deletions[component_type][component] then
+			deletions[component_type][component] = nil
+		end
+	end
+end
+
 function masking_controller.allocate_component_change(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	entity: Entity,
-	component: Entity,
+	component: Component,
 	value: any
 )
 	local storage = masking:get_component_storage_group(entity, component, COMPONENT_TYPES.component)
 	local changes = get_or_set_changed(storage, entity)
+
 	changes.component[component] = value
-	changes.removed[component] = nil
+	changes.removed.component[component] = nil
 end
 
-function masking_controller.allocate_pair_value_change(
-	masking: MaskingInternal,
+function masking_controller.allocate_tag_addition(masking: MaskingController, entity: Entity, tag: Component)
+	local storage = masking:get_component_storage_group(entity, tag, COMPONENT_TYPES.tag)
+	local changes = get_or_set_changed(storage, entity)
+
+	changes.tagged[tag] = true
+	changes.removed.tag[tag] = nil
+end
+
+function masking_controller.allocate_pair_change(masking: MaskingController, entity: Entity, id: Component, value: any)
+	local storage = masking:get_component_storage_group(entity, id, COMPONENT_TYPES.pair_component)
+	local changes = get_or_set_changed(storage, entity)
+
+	changes.pair_removed.component[id] = nil
+	changes.pair_changed[id] = value
+end
+
+function masking_controller.allocate_pair_addition(masking: MaskingController, entity: Entity, id: Component)
+	local storage = masking:get_component_storage_group(entity, id, COMPONENT_TYPES.pair_tag)
+	local changes = get_or_set_changed(storage, entity)
+
+	changes.pair_removed.tag[id] = nil
+	changes.pair_added[id] = true
+end
+
+function masking_controller.allocate_relation_value_change(
+	masking: MaskingController,
 	entity: Entity,
-	relation: Entity,
+	relation: Component,
 	target: Entity,
 	value: any
 )
-	local storage = masking:get_component_storage_group(entity, relation, COMPONENT_TYPES.pair_value)
+	local storage = masking:get_component_storage_group(entity, relation, COMPONENT_TYPES.relation_value)
 	local changes = get_or_set_changed(storage, entity)
-	local values = changes.pairs_values.changed[relation]
+	local values = changes.relation_value[relation]
 	if values == nil then
 		values = {}
-		changes.pairs_values.changed[relation] = values
+		changes.relation_value[relation] = values
 	end
 	values[target] = value
 
-	local removed = changes.pairs_values.removed[relation]
+	local removed = changes.relation_removed.component[relation]
 	if removed ~= nil then
 		removed[target] = nil
 	end
 end
 
-function masking_controller.allocate_tag_addition(masking: MaskingInternal, entity: Entity, tag: Entity)
-	local storage = masking:get_component_storage_group(entity, tag, COMPONENT_TYPES.tag)
-	local changes = get_or_set_changed(storage, entity)
-	changes.tagged[tag] = true
-	changes.removed[tag] = nil
-end
-
-function masking_controller.allocate_pair_addition(
-	masking: MaskingInternal,
+function masking_controller.allocate_relation_addition(
+	masking: MaskingController,
 	entity: Entity,
-	relation: Entity,
+	relation: Component,
 	target: Entity
 )
-	local storage = masking:get_component_storage_group(entity, relation, COMPONENT_TYPES.pair)
+	local storage = masking:get_component_storage_group(entity, relation, COMPONENT_TYPES.relation)
 	local changes = get_or_set_changed(storage, entity)
-	local targets = changes.pairs[relation]
+	local targets = changes.relation_added[relation]
 	if targets == nil then
 		targets = {}
-		changes.pairs[relation] = targets
+		changes.relation_added[relation] = targets
 	end
 	targets[target] = true
+
+	local removed = changes.relation_removed.tag[relation]
+	if removed then
+		removed[target] = nil
+	end
 end
 
-function masking_controller.allocate_component_removal(masking: MaskingInternal, entity: Entity, component: Entity)
+function masking_controller.allocate_component_removal(masking: MaskingController, entity: Entity, component: Component)
 	local storage = masking:get_component_storage_group(entity, component, COMPONENT_TYPES.component)
 	local changes = get_or_set_changed(storage, entity)
 
 	changes.component[component] = nil
-	changes.removed[component] = true
+	changes.removed.component[component] = true
 end
 
-function masking_controller.allocate_tag_removal(masking: MaskingInternal, entity: Entity, tag: Entity)
+function masking_controller.allocate_tag_removal(masking: MaskingController, entity: Entity, tag: Component)
 	local storage = masking:get_component_storage_group(entity, tag, COMPONENT_TYPES.tag)
 	local changes = get_or_set_changed(storage, entity)
 
 	changes.tagged[tag] = nil
-	changes.removed[tag] = true
+	changes.removed.tag[tag] = true
 end
 
-function masking_controller.allocate_pair_removal(
-	masking: MaskingInternal,
+function masking_controller.allocate_pair_tag_removal(masking: MaskingController, entity: Entity, id: Component)
+	local storage = masking:get_component_storage_group(entity, id, COMPONENT_TYPES.pair_tag)
+	local changes = get_or_set_changed(storage, entity)
+
+	changes.pair_added[id] = nil
+	changes.pair_removed.tag[id] = true
+end
+
+function masking_controller.allocate_pair_component_removal(masking: MaskingController, entity: Entity, id: Component)
+	local storage = masking:get_component_storage_group(entity, id, COMPONENT_TYPES.pair_component)
+	local changes = get_or_set_changed(storage, entity)
+
+	changes.pair_changed[id] = nil
+	changes.pair_removed.component[id] = true
+end
+
+function masking_controller.allocate_relation_value_removal(
+	masking: MaskingController,
 	entity: Entity,
-	relation: Entity,
+	relation: Component,
 	target: Entity
 )
-	local storage = masking:get_component_storage_group(entity, relation, COMPONENT_TYPES.pair)
+	local storage = masking:get_component_storage_group(entity, relation, COMPONENT_TYPES.relation)
 	local changes = get_or_set_changed(storage, entity)
-	local targets = changes.pairs[relation]
+	local targets = changes.relation_removed.component[relation]
 	if targets == nil then
 		targets = {}
-		changes.pairs[relation] = targets
+		changes.relation_removed.component[relation] = targets
+	end
+	targets[target] = true
+
+	local values = changes.relation_value[relation]
+	if values then
+		values[target] = nil
 	end
-	targets[target] = false
 end
 
-function masking_controller.allocate_pair_value_removal(
-	masking: MaskingInternal,
+function masking_controller.allocate_relation_removal(
+	masking: MaskingController,
 	entity: Entity,
-	relation: Entity,
+	relation: Component,
 	target: Entity
 )
-	local storage = masking:get_component_storage_group(entity, relation, COMPONENT_TYPES.pair_value)
+	local storage = masking:get_component_storage_group(entity, relation, COMPONENT_TYPES.relation)
 	local changes = get_or_set_changed(storage, entity)
-	local removed = changes.pairs_values.removed[relation]
-	if removed == nil then
-		removed = {}
-		changes.pairs_values.removed[relation] = removed
+	local targets = changes.relation_removed.tag[relation]
+	if targets == nil then
+		targets = {}
+		changes.relation_removed.tag[relation] = targets
 	end
-	removed[target] = true
+	targets[target] = true
 
-	local values = changes.pairs_values.changed[relation]
-	if values ~= nil then
-		values[target] = nil
+	local added = changes.relation_added[relation]
+	if added then
+		added[target] = nil
 	end
 end
 
@@ -1339,12 +1474,12 @@ local function remap_bitmask(
 	return result
 end
 
-local function bitmask_from_set(masking: MaskingInternal, member_set: { [Member]: boolean }): utils.Bitmask
+local function bitmask_from_set(masking: MaskingController, member_set: { [Member]: boolean }): utils.Bitmask
 	local new_bitmask = utils.bitmask.create(masking.member_count)
 	for member: Member in member_set do
 		local index = masking.client_indexes[member]
 		if not index then
-			local alias = masking.client_indexes[masking.client_aliases[member]]
+			local alias = masking.client_indexes[masking.client_aliases[member] ]
 			if alias then
 				if utils.is_client_valid(alias) then
 					index = alias
@@ -1362,7 +1497,7 @@ local function bitmask_from_set(masking: MaskingInternal, member_set: { [Member]
 end
 
 function masking_controller.merge_storages(
-	masking: MaskingInternal,
+	masking: MaskingController,
 	old_storage: StorageGroup,
 	new_storage: StorageGroup
 )
@@ -1414,7 +1549,7 @@ function masking_controller.merge_storages(
 	end
 end
 
-function masking_controller.compact_members(masking: MaskingInternal)
+function masking_controller.compact_members(masking: MaskingController)
 	-- we dont recompute as nothing should've changed
 	-- so this should be hopefully quite cheap
 	local old_indexes = masking.client_indexes
@@ -1444,8 +1579,7 @@ function masking_controller.compact_members(masking: MaskingInternal)
 				if component_bitmask then
 					component_generator.bitmask = remap_bitmask(component_bitmask, old_indexes, new_indexes, new_count)
 				end
-				component_generator.result =
-					remap_bitmask(component_generator.result, old_indexes, new_indexes, new_count)
+				component_generator.result = remap_bitmask(component_generator.result, old_indexes, new_indexes, new_count)
 
 				local band_generator = component_lookup.band_generator
 				local band_bitmask = band_generator.bitmask
@@ -1486,7 +1620,10 @@ function masking_controller.compact_members(masking: MaskingInternal)
 	masking.storages = new_storages
 end
 
-function masking_controller.create_generator_from_filter(masking: MaskingInternal, filter: MemberFilter): MaskGenerator
+function masking_controller.create_generator_from_filter(
+	masking: MaskingController,
+	filter: MemberFilter
+): MaskGenerator
 	local is_include = is_include_filter(filter)
 	if is_include then
 		return masking:create_include_generator(filter) :: MaskGenerator
@@ -1495,7 +1632,7 @@ function masking_controller.create_generator_from_filter(masking: MaskingInterna
 	end
 end
 
-function masking_controller.create_exclude_generator(masking: MaskingInternal, exclude: MemberFilter)
+function masking_controller.create_exclude_generator(masking: MaskingController, exclude: MemberFilter)
 	local bitmask = bitmask_from_set(masking, exclude)
 	local active_members = masking.active_members_generator
 
@@ -1509,7 +1646,7 @@ function masking_controller.create_exclude_generator(masking: MaskingInternal, e
 end
 
 -- TODO: check for players existing and register them if they don't
-function masking_controller.create_include_generator(masking: MaskingInternal, include: MemberFilter): MaskGenerator
+function masking_controller.create_include_generator(masking: MaskingController, include: MemberFilter): MaskGenerator
 	local bitmask = bitmask_from_set(masking, include)
 	local active_members = masking.active_members_generator
 
@@ -1522,7 +1659,7 @@ function masking_controller.create_include_generator(masking: MaskingInternal, i
 	return new_generator
 end
 
-function masking_controller.create_all_members_generator(masking: MaskingInternal)
+function masking_controller.create_all_members_generator(masking: MaskingController)
 	local filter: MemberFilter = {}
 	for member in masking.client_indexes do
 		filter[member] = true
@@ -1547,11 +1684,11 @@ function masking_controller.create_active_generator(masking: MaskingController):
 	return new_generator
 end
 
---function masking_controller.register_mask_group(masking: MaskingInternal, group: Member) end
+--function masking_controller.register_mask_group(masking: MaskingController, group: Member) end
 
---function masking_controller.unregister_mask_group(masking: MaskingInternal, group: Member) end
+--function masking_controller.unregister_mask_group(masking: MaskingController, group: Member) end
 
-function masking_controller.register_client(masking: MaskingInternal, member: Member)
+function masking_controller.register_client(masking: MaskingController, member: Member)
 	if masking.client_indexes[member] then
 		return
 	end
@@ -1570,7 +1707,7 @@ function masking_controller.register_client(masking: MaskingInternal, member: Me
 	end
 end
 
-function masking_controller.unregister_client(masking: MaskingInternal, member: Member)
+function masking_controller.unregister_client(masking: MaskingController, member: Member)
 	local index = masking.client_indexes[member]
 	if index == nil then
 		return
@@ -1580,7 +1717,7 @@ function masking_controller.unregister_client(masking: MaskingInternal, member:
 	masking.active_members_generator:compute()
 end
 
-function masking_controller.activate_client(masking: MaskingInternal, member: Member)
+function masking_controller.activate_client(masking: MaskingController, member: Member)
 	local index = masking.client_indexes[member]
 
 	masking.unreplicated[member] = nil
@@ -1588,7 +1725,7 @@ function masking_controller.activate_client(masking: MaskingInternal, member: Me
 	masking.active_members_generator:compute()
 end
 
-function masking_controller.member_is_active(masking: MaskingInternal, member: Member): boolean
+function masking_controller.member_is_active(masking: MaskingController, member: Member): boolean
 	local index = masking.client_indexes[member]
 	if index == nil then
 		return false
@@ -1598,7 +1735,7 @@ function masking_controller.member_is_active(masking: MaskingInternal, member: M
 end
 
 local function create(): MaskingController
-	local self = {} :: MaskingInternal
+	local self = {} :: MaskingController
 
 	self.client_indexes = {}
 	self.group_indexes = {}