@rbxts/replecs 0.1.0-alpha5 → 0.1.0-alpha8

package/README.md

@@ -1,7 +1,8 @@
 # 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. 
+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
@@ -14,110 +15,3 @@ Replecs is a feature rich, fast, flexible, powerful, and runtime/library agnosti
 - 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

@@ -14,12 +14,13 @@ type World = jecs.World
 export type Client = {
 	world: World,
 	inited: boolean?,
+
 	is_replicating: boolean,
 	after_replication_callbacks: { () -> () },
 
 	components: common.Components,
 	shared: common.Shared,
-	global_id_parser: ((id: number) -> Entity)?,
+	global_handler: ((id: number) -> Entity)?,
 	server_ids: { [number]: Entity },
 	client_ids: { [Entity]: number },
 	ordered_creation: boolean,
@@ -28,10 +29,13 @@ export type Client = {
 	init: (self: Client, world: World?) -> (),
 	destroy: (self: Client) -> (),
 	after_replication: (self: Client, callback: () -> ()) -> (),
-	parse_global_id: (self: Client, parser: (id: number) -> Entity) -> (),
+	handle_global: (self: Client, handler: (id: number) -> Entity) -> (),
 	get_server_entity: (self: Client, client_entity: Entity) -> number?,
 	get_client_entity: (self: Client, server_entity: number) -> Entity?,
 
+	encode_component: (self: Client, component: Entity) -> number,
+	decode_component: (self: Client, component: number) -> Entity,
+
 	apply_updates: (self: Client, buf: buffer, all_variants: { { any } }?) -> (),
 	apply_unreliable: (self: Client, buf: buffer, all_variants: { { any } }?) -> (),
 	apply_full: (self: Client, buf: buffer, all_variants: { { any } }?) -> (),
@@ -68,6 +72,23 @@ local function get_or_create_entity(client: Client, server_id: number): Entity
 	end
 end
 
+local function encode_component(client: Client, component: Entity): number
+	local encoded = client.shared.ids[component]
+	if not encoded then
+		utils.logerror(`attempted to encode a non-shared component `, utils.logcomponent(client.world, component))
+		return 0
+	end
+	return encoded
+end
+local function decode_component(client: Client, encoded: number): Entity
+	local component = client.shared.components[encoded]
+	if not component then
+		print("NON SHARED COMPONENT", encoded, client.shared.components)
+		error "attemped to decode a non shared component"
+	end
+	return component
+end
+
 local function read_component_id(client: Client, c: Cursor)
 	local shared_id = cursor.readu8(c)
 	local component = client.shared.components[shared_id]
@@ -86,7 +107,18 @@ local function read_component_value(client: Client, c: Cursor, variants: { any }
 		local bytespan = client.shared.bytespan[component] or cursor.read_vlq(c)
 
 		local appended = cursor.read_buffer(c, bytespan)
-		local output = serdes.deserialize(appended)
+		local serdes_variants: { any }? = nil
+
+		if serdes.includes_variants then
+			local start_variant = cursor.read_vlq(c)
+
+			if start_variant > 0 then
+				local size = cursor.read_vlq(c)
+				serdes_variants = table.move(variants :: { any }, start_variant, start_variant + size - 1, 1, {})
+			end
+		end
+
+		local output = serdes.deserialize(appended, serdes_variants)
 		return component, output
 	else
 		local variant_id = cursor.read_vlq(c)
@@ -98,11 +130,11 @@ local function read_component_value(client: Client, c: Cursor, variants: { any }
 	end
 end
 
-local function resolve_global_id(client: Client, global_id: number): Entity
-	if not client.global_id_parser then
-		error "global id parser not set, consider using client:parse_global_id()"
+local function resolve_global(client: Client, global_id: number): Entity
+	if not client.global_handler then
+		error "global id parser not set, consider using client:handle_global()"
 	end
-	local parsed = client.global_id_parser(global_id)
+	local parsed = client.global_handler(global_id)
 	return parsed
 end
 
@@ -129,11 +161,11 @@ local function read_entity_id(client: Client, c: Cursor, variants: { any }?): (E
 			return read_component_id(client, c), nil
 		elseif id_type == ENTITY_ID_TYPES.global then
 			local global_id = cursor.readu8(c) - GLOBAL_ID_OFFSET
-			return resolve_global_id(client, global_id), nil
+			return resolve_global(client, global_id), nil
 		end
 		error(`malformed entity id {id_type} ` .. cursor.readu32(c))
 	else
-		return resolve_global_id(client, id_type - GLOBAL_ID_OFFSET), nil
+		return resolve_global(client, id_type - GLOBAL_ID_OFFSET), nil
 	end
 end
 
@@ -184,7 +216,7 @@ local function check_packet_type(c: Cursor, type: string)
 		local got: string = nil :: any
 		for k, v in PACKET_TYPES do
 			if v == packet_type then
-				got = k
+				got = k :: string
 				break
 			end
 		end
@@ -389,8 +421,8 @@ local function init(client: Client, _world: World?)
 
 	client.shared = utils.create_shared_lookup(world, components)
 
-	for component, custom_id_get in world:query(components.custom_id):with(components.shared, ECS_NAME) do
-		client.custom_ids[component] = custom_id_get
+	for component, custom_get in world:query(components.custom_handler):with(components.shared, ECS_NAME) do
+		client.custom_ids[component] = custom_get
 	end
 end
 
@@ -419,8 +451,8 @@ local function destroy(client: Client)
 	-- right now this is kind of useless
 end
 
-local function parse_global_id(client: Client, parser: (id: number) -> Entity)
-	client.global_id_parser = parser
+local function handle_global(client: Client, handler: (id: number) -> Entity)
+	client.global_handler = handler
 end
 
 local client = {}
@@ -431,9 +463,11 @@ client.after_replication = after_replication
 client.apply_updates = apply_updates
 client.apply_unreliable = apply_unreliable
 client.apply_full = apply_full
+client.encode_component = encode_component
+client.decode_component = decode_component
 client.get_server_entity = get_server_entity
 client.get_client_entity = get_client_entity
-client.parse_global_id = parse_global_id
+client.handle_global = handle_global
 
 local function create(world: World?, components: common.Components): Client
 	local self = {} :: Client
@@ -443,7 +477,7 @@ local function create(world: World?, components: common.Components): Client
 	self.custom_ids = {}
 	self.server_ids = {}
 	self.client_ids = {}
-	self.global_id_parser = nil
+	self.global_handler = nil
 	self.world = world :: any
 	self.inited = false
 	self.is_replicating = false

package/out/replecs/common.luau

@@ -5,8 +5,9 @@ export type PlayerFilter = {
 }
 
 export type Serdes = {
-	serialize: (value: any) -> buffer,
-	deserialize: (buffer) -> any,
+	includes_variants: boolean?,
+	serialize: (value: any) -> (buffer, { any }?),
+	deserialize: (buffer, { any }?) -> any,
 }
 
 export type Components = {
@@ -18,8 +19,9 @@ export type Components = {
 
 	serdes: jecs.Entity<Serdes>,
 	bytespan: jecs.Entity<number>,
-	custom_id: jecs.Entity<(value: any) -> jecs.Entity>,
-	global_id: jecs.Entity<number>,
+	custom: jecs.Entity,
+	custom_handler: jecs.Entity<(value: any) -> jecs.Entity>,
+	global: jecs.Entity<number>,
 	__alive_tracking__: jecs.Entity,
 }
 

package/out/replecs/index.d.ts

@@ -1,28 +1,17 @@
-import type { Entity, Id, Tag, World } from "@rbxts/jecs";
+import type { Entity, Tag, World } from "@rbxts/jecs";
 
 declare namespace Replecs {
-   export interface SerdesTable {
-      serialize: (value: any) => buffer;
-      deserialize: (buffer: buffer) => any;
-   }
-
-   export interface ObserverWorld extends World {
-      added<T>(
-         this: ObserverWorld,
-         component: Id<T>,
-         callback: (e: Entity, id: Id<T>, value: T) => void
-      ): () => void;
-      removed<T>(
-         this: ObserverWorld,
-         component: Id<T>,
-         callback: (e: Entity, id: Id<T>) => void
-      ): () => void;
-      changed<T>(
-         this: ObserverWorld,
-         component: Id<T>,
-         callback: (e: Entity, id: Id<T>, value: T) => void
-      ): () => void;
-   }
+   export type SerdesTable =
+      | {
+           includes_variants?: false;
+           serialize: (value: any) => buffer;
+           deserialize: (buffer: buffer) => any;
+        }
+      | {
+           includes_variants: true;
+           serialize: (value: any) => LuaTuple<[buffer, defined[] | undefined]>;
+           deserialize: (buffer: buffer, blobs: defined[] | undefined) => any;
+        };
 
    type MemberFilterMap = Map<Player, boolean>;
    type MemberFilter = Player | MemberFilterMap | undefined;
@@ -44,8 +33,9 @@ declare namespace Replecs {
 
       serdes: Entity<SerdesTable>;
       bytespan: Entity<number>;
-      custom_id: Entity<((value: any) => Entity) | undefined>;
-      global_id: Entity<number>;
+      custom: Entity;
+      custom_handler: Entity<(value: any) => Entity>;
+      global: Entity<number>;
 
       Shared: Tag;
       Networked: Entity<MemberFilter>;
@@ -55,39 +45,50 @@ declare namespace Replecs {
 
       Serdes: Entity<SerdesTable>;
       Bytespan: Entity<number>;
-      CustomId: Entity<(value: any) => Entity>;
-      GlobalId: Entity<number>;
+      Custom: Entity;
+      CustomHandler: Entity<(value: any) => Entity>;
+      Global: Entity<number>;
    }
 
    export interface Client {
-      world: ObserverWorld;
+      world: World;
       inited?: boolean;
 
-      init(world?: ObserverWorld): void;
+      init(world?: World): void;
       destroy(): void;
       after_replication(callback: () => void): void;
 
-      apply_updates(buf: buffer, all_variants?: any[][]): void;
-      apply_unreliable(buf: buffer, all_variants?: any[][]): void;
-      apply_full(buf: buffer, all_variants?: any[][]): void;
-      parse_global_id(parser: (id: number) => Entity): void;
+      apply_updates(buf: buffer, all_variants?: unknown[][]): void;
+      apply_unreliable(buf: buffer, all_variants?: unknown[][]): void;
+      apply_full(buf: buffer, all_variants?: unknown[][]): void;
+
+      encode_component(component: Entity): number;
+      decode_component(encoded: number): Entity;
+
+      handle_global(handler: (id: number) => Entity): void;
 
       get_server_entity(client_entity: Entity): number | undefined;
       get_client_entity(server_entity: number): Entity | undefined;
    }
 
    export interface Server {
-      world: ObserverWorld;
+      world: World;
       inited?: boolean;
 
-      init(world?: ObserverWorld): void;
+      init(world?: World): void;
       destroy(): void;
 
-      get_full(player: Player): LuaTuple<[buffer, any[][]]>;
-      collect_updates(): IterableFunction<LuaTuple<[Player, buffer, any[][]]>>;
+      get_full(player: Player): LuaTuple<[buffer, unknown[][]]>;
+      collect_updates(): IterableFunction<
+         LuaTuple<[Player, buffer, unknown[][]]>
+      >;
       collect_unreliable(): IterableFunction<
-         LuaTuple<[Player, buffer, any[][]]>
+         LuaTuple<[Player, buffer, unknown[][]]>
       >;
+
+      encode_component(component: Entity): number;
+      decode_component(encoded: number): Entity;
+
       mark_player_ready(player: Player): void;
       is_player_ready(player: Player): boolean;
 
@@ -102,9 +103,9 @@ declare namespace Replecs {
    }
 
    export interface Replecs extends Components {
-      create: (world?: ObserverWorld) => ReplecsLib;
-      create_server: (world?: ObserverWorld) => Server;
-      create_client: (world?: ObserverWorld) => Client;
+      create: (world?: World) => ReplecsLib;
+      create_server: (world?: World) => Server;
+      create_client: (world?: World) => Client;
    }
 }
 

package/out/replecs/init.luau

@@ -27,30 +27,37 @@ local replecs = {
 
 	serdes = jecs.component() :: jecs.Entity<common.Serdes>,
 	bytespan = jecs.component() :: jecs.Entity<number>,
-	custom_id = jecs.component() :: jecs.Entity<(any) -> jecs.Entity>,
-	global_id = jecs.component() :: jecs.Entity<number>,
+	custom = jecs.tag() :: jecs.Entity,
+	custom_handler = jecs.component() :: jecs.Entity<(any) -> jecs.Entity>,
+	global = jecs.component() :: jecs.Entity<number>,
 	__alive_tracking__ = jecs.tag(),
 }
 
 replecs.__index = replecs
 replecs.Serdes = replecs.serdes
 replecs.Bytespan = replecs.bytespan
-replecs.CustomId = replecs.custom_id
+replecs.Custom = replecs.custom
+replecs.CustomHandler = replecs.custom_handler
 replecs.Networked = replecs.networked
 replecs.Reliable = replecs.reliable
 replecs.Unreliable = replecs.unreliable
 replecs.Pair = replecs.pair
 replecs.Shared = replecs.shared
-replecs.GlobalId = replecs.global_id
+replecs.Global = replecs.global
 
 jecs.meta(replecs.serdes, jecs.Name, "replecs.serdes")
 jecs.meta(replecs.bytespan, jecs.Name, "replecs.bytespan")
-jecs.meta(replecs.custom_id, jecs.Name, "replecs.custom_id")
+jecs.meta(replecs.custom, jecs.Name, "replecs.custom")
+jecs.meta(replecs.custom_handler, jecs.Name, "replecs.custom_handler")
 jecs.meta(replecs.networked, jecs.Name, "replecs.networked")
 jecs.meta(replecs.reliable, jecs.Name, "replecs.reliable")
 jecs.meta(replecs.unreliable, jecs.Name, "replecs.unreliable")
 jecs.meta(replecs.pair, jecs.Name, "replecs.pair")
 jecs.meta(replecs.shared, jecs.Name, "replecs.shared")
+jecs.meta(replecs.global, jecs.Name, "replecs.global")
+
+jecs.meta(replecs.custom, jecs.Exclusive)
+jecs.meta(replecs.global, jecs.Exclusive)
 
 function replecs.create_server(world: jecs.World?): Server
 	return server.create(world, replecs)

package/out/replecs/masking/init.luau

@@ -1136,12 +1136,14 @@ function masking_controller.allocate_component_change(
 	local storage = masking:get_component_storage_group(entity, component, COMPONENT_TYPES.component)
 	local changes = get_or_set_changes(storage, entity)
 	changes.component[component] = value
+	changes.removed[component] = nil
 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_changes(storage, entity)
 	changes.tagged[tag] = true
+	changes.removed[tag] = nil
 end
 
 function masking_controller.allocate_pair_addition(
@@ -1164,9 +1166,7 @@ function masking_controller.allocate_component_removal(masking: MaskingInternal,
 	local storage = masking:get_component_storage_group(entity, component, COMPONENT_TYPES.component)
 	local changes = get_or_set_changes(storage, entity)
 
-	if changes.component[component] then
-		changes.component[component] = nil
-	end
+	changes.component[component] = nil
 	changes.removed[component] = true
 end
 
@@ -1174,9 +1174,7 @@ function masking_controller.allocate_tag_removal(masking: MaskingInternal, entit
 	local storage = masking:get_component_storage_group(entity, tag, COMPONENT_TYPES.tag)
 	local changes = get_or_set_changes(storage, entity)
 
-	if changes.tagged[tag] then
-		changes.tagged[tag] = nil
-	end
+	changes.tagged[tag] = nil
 	changes.removed[tag] = true
 end
 

package/out/replecs/server.luau

@@ -54,6 +54,9 @@ export type Server = {
 	init: (self: Server, world: World?) -> (),
 	destroy: (self: Server) -> (),
 
+	encode_component: (self: Server, component: Entity) -> number,
+	decode_component: (self: Server, component: number) -> Entity,
+
 	get_full: (self: Server, player: Player) -> (buffer, { { any } }),
 	collect_updates: (self: Server) -> () -> (Player, buffer, { { any } }),
 	collect_unreliable: (self: Server) -> () -> (Player, buffer, { { any } }),
@@ -330,6 +333,24 @@ local function untrack_entity_pair(server: Server, entity: Entity, relation: Ent
 	end
 end
 
+local function encode_component(server: Server, component: Entity): number
+	local encoded = server.shared.ids[component]
+	if not encoded then
+		utils.logerror(`attempted to encode a non-shared component `, utils.logcomponent(server.world, component))
+		return 0
+	end
+	return encoded
+end
+
+local function decode_component(server: Server, encoded: number): Entity
+	local component = server.shared.components[encoded]
+	if not component then
+		print("NON SHARED COMPONENTS", encoded, server.shared.components)
+		error "attemped to decode a non shared component"
+	end
+	return component
+end
+
 local function write_component_id(server: Server, c: Cursor, component: Entity)
 	local encoded = server.shared.ids[component]
 	if not encoded then
@@ -342,7 +363,26 @@ end
 local function write_component_value(server: Server, c: Cursor, component: Entity, value: any, variants: { any })
 	local serdes = server.shared.serdes[component]
 	if serdes then
-		local output = serdes.serialize(if value == NIL_COMPONENT_VALUE then nil else value)
+		local output, serdes_variants = serdes.serialize(if value == NIL_COMPONENT_VALUE then nil else value)
+
+		if serdes.includes_variants then
+			if serdes_variants == nil then
+				-- 128 is zero for vlq
+				cursor.writeu8(c, 128)
+			else
+				local start_variants = #variants
+				if #serdes_variants > 0 then
+					table.move(serdes_variants, 1, #serdes_variants, #variants + 1, variants)
+				end
+				cursor.write_vlq(c, #serdes_variants)
+				cursor.write_vlq(c, start_variants + 1)
+			end
+		elseif serdes_variants ~= nil then
+			utils.logerror(
+				"serdes: serializer provided variants yet includes_variants is not set to true for component",
+				utils.logcomponent(server.world, component)
+			)
+		end
 
 		local bytespan = server.shared.bytespan[component]
 		cursor.write_buffer(c, output)
@@ -1033,9 +1073,9 @@ function init(server: Server, _world: World?)
 		masking:stop_component(entity, component, COMPONENT_TYPES.unreliable)
 	end))
 
-	hook(hooks.added(world, components.custom_id, function(entity, id)
+	hook(hooks.added(world, components.custom, function(entity, id)
 		if not IS_PAIR(id) then
-			utils.logerror "custom_id should be used with a relationship in the server"
+			utils.logerror "replecs.custom should be used with a relationship in the server"
 		end
 		local target = PAIR_SECOND(world, id)
 		if server.custom_ids[entity] then
@@ -1045,23 +1085,23 @@ function init(server: Server, _world: World?)
 
 		server.custom_ids[entity] = target
 	end))
-	hook(hooks.removed(world, components.custom_id, function(entity)
+	hook(hooks.removed(world, components.custom, function(entity)
 		server.custom_ids[entity] = nil
 	end))
-	hook(hooks.added(world, components.global_id, function(entity, _, value)
+	hook(hooks.added(world, components.global, 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, _, value)
+	hook(hooks.changed(world, components.global, 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.removed(world, components.global_id, function(entity)
+	hook(hooks.removed(world, components.global, function(entity)
 		server.global_ids[entity] = nil
 	end))
 
@@ -1116,6 +1156,8 @@ server.destroy = destroy
 server.get_full = get_full
 server.collect_updates = collect_updates
 server.collect_unreliable = collect_unreliable
+server.encode_component = encode_component
+server.decode_component = decode_component
 server.mark_player_ready = mark_player_ready
 server.is_player_ready = is_player_ready
 

package/out/replecs/utils.luau

@@ -678,7 +678,7 @@ function utils.logwarn(...: string)
 end
 
 function utils.logcomponent(world: World, component: Entity)
-	return ` name: {world:get(component, ECS_NAME) or "(no name)"} id: {component}`
+	return ` name: {world:get(component, ECS_NAME) or "(no name)"}, id: {component}`
 end
 
 return utils

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@rbxts/replecs",
-   "version": "0.1.0-alpha5",
+   "version": "0.1.0-alpha8",
    "description": "Replication library for Jecs",
    "main": "out/init.lua",
    "types": "out/index.d.ts",
@@ -40,7 +40,7 @@
       "typescript": "=5.5.3",
       "prettier": "^3.2.5"
    },
-   "dependencies": {
-      "@rbxts/jecs": "^0.9.0-rc.8"
+   "peerDependencies": {
+      "@rbxts/jecs": "^0.9.0-rc.9"
    }
 }