@rbxts/replecs 0.4.0-rc.3 → 0.4.0-rc.5

package/out/replecs/client/init.luau

@@ -777,13 +777,18 @@ local function process_full_entity(
 	end
 end
 
+-- removals resolve their target with find_entity: a target this client never
+-- saw (filtered out, or deleted earlier in the same packet) has nothing to
+-- remove, and creating a placeholder for it would leak a ghost entity
+
 -- pair tag removal: [target id, relation]
 local function process_entity_pair_removal(self: Client, entity: Entity, c: Cursor, custom_ids: CustomIdMap)
 	local relation = read_component_id(self, c)
 	local relation_hooks = self.network_hooks.removed[PAIR(self.components.relation, relation)]
-	process_entity(self, c, custom_ids, function(target)
+	local target = find_entity(self, c)
+	if target then
 		entity_remove_pair(self, entity, relation, target, relation_hooks)
-	end)
+	end
 end
 
 -- relation target removals: [target ids..., vlq count, relation]
@@ -793,9 +798,10 @@ local function process_entity_relation_removals(self: Client, entity: Entity, c:
 	local relation_hooks = self.network_hooks.removed[PAIR(self.components.relation, relation)]
 
 	for _ = 1, total_targets do
-		process_entity(self, c, custom_ids, function(target)
+		local target = find_entity(self, c)
+		if target then
 			entity_remove_pair(self, entity, relation, target, relation_hooks)
-		end)
+		end
 	end
 end
 
@@ -1532,8 +1538,8 @@ local function prune_component_serialization(self: Client, component: Component,
 	end
 end
 
--- serdes take part in the handshake, preprocessors and delta serializers are
--- local to each side and never mark shared dirty
+-- serdes and preprocessors take part in the handshake and mark shared dirty,
+-- delta serializers are local to each side and never do
 function client.set_serdes(self: Client, component: Component, serdes: types.Serdes)
 	ensure_component_serialization(self, component).serdes = serdes
 	self.is_shared_dirty = true
@@ -1551,6 +1557,7 @@ end
 
 function client.set_preprocessor(self: Client, component: Component, preprocessor: types.Preprocessor)
 	ensure_component_serialization(self, component).preprocessor = preprocessor
+	self.is_shared_dirty = true
 end
 
 function client.remove_preprocessor(self: Client, component: Component)
@@ -1560,6 +1567,7 @@ function client.remove_preprocessor(self: Client, component: Component)
 	end
 	options.preprocessor = nil
 	prune_component_serialization(self, component, options)
+	self.is_shared_dirty = true
 end
 
 function client.set_delta_serializer(self: Client, component: Component, delta_serializer: types.DeltaSerializer)
@@ -1575,21 +1583,25 @@ function client.remove_delta_serializer(self: Client, component: Component)
 	prune_component_serialization(self, component, options)
 end
 
--- rebuilds the shared lookups (component ids, custom ids, serdes) when
--- flagged; cheap no-op otherwise, so every deserialize entry point calls it
+-- rebuilds the shared lookups (component ids, custom ids, serdes, preprocessors)
+-- when flagged; cheap no-op otherwise, so every deserialize entry point calls it
 function client.resolve_dirty(self: Client)
 	if not self.is_shared_dirty then
 		return
 	end
 
 	local serdes: { [Component]: types.Serdes } = {}
+	local preprocessors: { [Component]: true } = {}
 	for component, options in self.component_serialization do
 		if options.serdes then
 			serdes[component] = options.serdes
 		end
+		if options.preprocessor then
+			preprocessors[component] = true
+		end
 	end
 
-	self.shared = shared.resolve_shared(self.world, self.components, self.registered_custom_ids, serdes)
+	self.shared = shared.resolve_shared(self.world, self.components, self.registered_custom_ids, serdes, preprocessors)
 	self.is_shared_dirty = false
 end
 
@@ -1752,6 +1764,8 @@ return {
 
 	process_entity_pair = process_entity_pair,
 	process_entity_pair_value = process_entity_pair_value,
+	process_entity_pair_removal = process_entity_pair_removal,
+	process_entity_relation_removals = process_entity_relation_removals,
 	process_entity_relations = process_entity_relations,
 	process_entity_relation_values = process_entity_relation_values,
 	process_full_entity = process_full_entity,

package/out/replecs/handshake.luau

@@ -13,6 +13,7 @@ function handshake.generate_handshake(shared: types.Shared): types.HandshakeInfo
 		components = {},
 		custom_ids = {},
 		serdes = {},
+		preprocessors = {},
 	}
 
 	for component_name, component in shared.components.lookup do
@@ -36,6 +37,16 @@ function handshake.generate_handshake(shared: types.Shared): types.HandshakeInfo
 		}
 	end
 
+	-- preprocessors are functions, so only their presence is shared
+	for component in shared.preprocessors do
+		local name = component_to_name[component]
+		if not name then
+			continue
+		end
+
+		handshake.preprocessors[name] = true
+	end
+
 	return handshake
 end
 
@@ -102,6 +113,30 @@ function handshake.verify_handshake(
 		end
 	end
 
+	for component_name in handshake.preprocessors do
+		local component = shared.components.lookup[component_name]
+		if not component then
+			common.log_warn(
+				`{handshake_side} registered a preprocessor for "{component_name}" that {verify_side} doesn't have`
+			)
+			continue
+		end
+
+		if not shared.preprocessors[component] then
+			return false, `missing preprocessor for component "{component_name}" in {verify_side}`
+		end
+	end
+	for component in shared.preprocessors do
+		local component_name = component_to_name[component]
+		if not component_name then
+			continue
+		end
+
+		if not handshake.preprocessors[component_name] then
+			return false, `missing preprocessor for component "{component_name}" in {handshake_side}`
+		end
+	end
+
 	return true, nil
 end
 

package/out/replecs/index.d.ts

@@ -34,10 +34,42 @@ declare namespace Replecs {
     | Player
     | MemberFilterMap
     | MemberFilterPredicate
+    | FilterNode
     | Record<string, never>
     | undefined;
   type Member = unknown;
 
+  /** What a filter combinator accepts: another node or a raw player / set. */
+  export type FilterOperand = FilterNode | Player | MemberFilterMap;
+
+  /**
+   * One node of the reactive filter graph. Sources own a player set; derived
+   * nodes combine their inputs and re-evaluate lazily on the next collect.
+   * Structure is fixed at construction, only the value is reactive.
+   */
+  export interface FilterNode {
+    /** Replaces the member set. A map of `false` values makes a blacklist. Sources only. */
+    set(filter: Player | MemberFilterMap): void;
+    /** Adds to the member set (on a blacklist source this excludes the player). Sources only. */
+    add(player: Player): void;
+    /** Sources only. */
+    remove(player: Player): void;
+    /** Sources only. */
+    clear(): void;
+
+    /** Players in this node and in every operand. */
+    filter(...operands: FilterOperand[]): FilterNode;
+    /** Players in this node or in any operand. */
+    extend(...operands: FilterOperand[]): FilterNode;
+    /** Players in this node and in no operand. */
+    exclude(...operands: FilterOperand[]): FilterNode;
+
+    /** Resolves the node and returns its current players. Errors if the node is not bound to a server yet. */
+    members(): Map<Player, true>;
+    /** Resolves the node and tests one player (aliases accepted). */
+    contains(player: Player): boolean;
+  }
+
   export interface SharedInfo<T> {
     lookup: Record<string, T>;
     keys: string[];
@@ -64,6 +96,7 @@ declare namespace Replecs {
     components: SharedInfo<Entity>;
     custom_ids: SharedInfo<CustomId>;
     serdes: Map<Id, SerdesTable>;
+    preprocessors: Map<Id, true>;
   }
   interface HandshakeSerdesInfo {
     includes_variants?: boolean;
@@ -74,6 +107,7 @@ declare namespace Replecs {
     components: Record<string, boolean>;
     custom_ids: Record<string, boolean>;
     serdes: Record<string, HandshakeSerdesInfo>;
+    preprocessors: Record<string, boolean>;
   }
 
   export interface Components {
@@ -194,6 +228,13 @@ declare namespace Replecs {
   }
 
   export interface ServerImp extends SerializationOptions {
+    /** A source filter bound to this server. */
+    filter(initial?: Player | MemberFilterMap): FilterNode;
+    /** A filter driven by a predicate over registered players, re-evaluated once per collect. */
+    filter_predicator(predicate: MemberFilterPredicate): FilterNode;
+    /** Every registered player; the base for blacklists. */
+    everyone(): FilterNode;
+
     set_networked(entity: Entity, filter?: MemberFilter): void;
     set_reliable(
       entity: Entity,
@@ -289,6 +330,8 @@ declare namespace Replecs {
       identifier: string,
       handler?: (ctx: HandleContext) => Entity,
     ) => CustomId;
+    /** An unbound source filter; it attaches to a server the first time a `set_*` call receives it. */
+    filter: (initial?: Player | MemberFilterMap) => FilterNode;
   }
 }
 

package/out/replecs/init.luau

@@ -10,6 +10,7 @@ local VERSION = require (script:WaitForChild('ver'))
 
 export type Server = server.Server
 export type Client = client.Client
+export type FilterNode = server.FilterNode
 
 type Entity = common.Entity
 type World = common.World
@@ -46,6 +47,7 @@ type Replecs = types.Components & {
 	create_server: (world: World?) -> Server,
 	create_client: (world: World?) -> Client,
 	create_custom_id: (identifier: string, handler: (ctx: HandleContext) -> Entity?) -> CustomId,
+	filter: (initial: types.FilterSimple?) -> FilterNode,
 }
 
 local replecs = {}
@@ -103,6 +105,12 @@ function replecs.create_custom_id(identifier: string, handler: (ctx: HandleConte
 	return customid.create(identifier, handler)
 end
 
+-- an unbound source filter: usable from any module, it attaches to the server
+-- the first time a set_* call receives it (directly or through a derived node)
+function replecs.filter(initial: types.FilterSimple?): FilterNode
+	return server.create_filter(initial)
+end
+
 function replecs.after_replication(lib: ReplecsLib, callback: () -> ())
 	local lib_client = lib.client
 	if lib_client then