@rbxts/tether 1.4.1 → 1.4.2

package/out/emitters/client-emitter.luau

@@ -4,6 +4,9 @@ local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
 local Players = _services.Players
 local RunService = _services.RunService
 local ContextualEmitter = TS.import(script, script.Parent, "contextual-emitter").ContextualEmitter
+if setLuneContext == nil then
+	setLuneContext = function() end
+end
 local ClientEmitter
 do
 	local super = ContextualEmitter
@@ -36,7 +39,7 @@ do
 			if dropRequest then
 				return nil
 			end
-			self.master:queueMessage(self.context, message, { player, message, newData, unreliable })
+			self.master.relayer:queueMessage(self.context, message, { player, message, newData, unreliable })
 		end)
 	end
 	function ClientEmitter:emitExcept(player, message, data, unreliable)
@@ -83,7 +86,7 @@ do
 			if dropRequest then
 				return nil
 			end
-			self.master:queueMessage(true, message, { message, newData, unreliable })
+			self.master.relayer:queueMessage(true, message, { message, newData, unreliable })
 		end)
 	end
 	function ClientEmitter:setCallback(message, returnMessage, callback)

package/out/emitters/message-emitter.d.ts

@@ -1,52 +1,41 @@
 import { Modding } from "@flamework/core";
+import { Trash } from "@rbxts/trash";
 import Destroyable from "@rbxts/destroyable";
 import { MiddlewareProvider } from "../middleware";
-import type { ClientMessageCallback, ServerMessageCallback, BaseMessage, MessageEmitterMetadata } from "../structs";
+import type { SerializedPacket, ClientMessageCallback, ServerMessageCallback, BaseMessage, MessageEmitterMetadata } from "../structs";
 import { ServerEmitter } from "./server-emitter";
 import { ClientEmitter } from "./client-emitter";
-interface MessageEmitterOptions<MessageData> {
+import { Relayer } from "../relayer";
+import { Serdes } from "../serdes";
+export interface MessageEmitterOptions<MessageData> {
     readonly batchRemotes: boolean;
     readonly batchRate: number;
     readonly doNotBatch: Set<keyof MessageData>;
 }
 export declare class MessageEmitter<MessageData> extends Destroyable {
-    private readonly options;
+    readonly options: MessageEmitterOptions<MessageData>;
     readonly server: ServerEmitter<MessageData>;
     readonly client: ClientEmitter<MessageData>;
     readonly middleware: MiddlewareProvider<MessageData>;
+    /** @hidden */ readonly trash: Trash;
+    /** @hidden */ readonly relayer: Relayer<MessageData>;
+    /** @hidden */ readonly serdes: Serdes<MessageData>;
     /** @hidden */ clientCallbacks: Map<keyof MessageData, Set<ClientMessageCallback>>;
     /** @hidden */ clientFunctions: Map<keyof MessageData, Set<(data: unknown) => void>>;
     /** @hidden */ serverCallbacks: Map<keyof MessageData, Set<ServerMessageCallback>>;
     /** @hidden */ serverFunctions: Map<keyof MessageData, Set<(data: unknown) => void>>;
     private readonly guards;
-    private serializers;
-    private serverQueue;
-    private clientBroadcastQueue;
-    private clientQueue;
     /** @metadata macro */
     static create<MessageData>(options?: Partial<MessageEmitterOptions<MessageData>>, meta?: Modding.Many<MessageEmitterMetadata<MessageData>>): MessageEmitter<MessageData>;
     private constructor();
     /** @hidden */
-    queueMessage<K extends keyof MessageData>(context: "client" | "server" | true, message: K & BaseMessage, data: (MessageEmitter<MessageData>["clientQueue"] | MessageEmitter<MessageData>["serverQueue"])[number]): void;
-    /** @hidden */
     runClientMiddlewares<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind], player?: Player | Player[]): [boolean, MessageData[Kind]];
     /** @hidden */
     runServerMiddlewares<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind]): [boolean, MessageData[Kind]];
-    /** Set up emitter connections */
-    private initialize;
-    /** Send all queued data across the network simultaneously */
-    private relay;
+    /** @hidden */
+    onRemoteFire(isServer: boolean, serializedPackets: SerializedPacket[], player?: Player): void;
     private validateData;
-    private onRemoteFire;
     private executeFunctions;
     private executeEventCallbacks;
-    private shouldBatch;
     private deserializeAndValidate;
-    private getPacket;
-    /** @metadata macro */
-    private addSerializer;
-    /** @metadata macro */
-    private createMessageSerializer;
-    private getSerializer;
 }
-export {};

package/out/emitters/message-emitter.luau

@@ -1,21 +1,17 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
-local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
-local Players = _services.Players
-local ReplicatedStorage = _services.ReplicatedStorage
-local RunService = _services.RunService
+local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
 local Destroyable = TS.import(script, TS.getModule(script, "@rbxts", "destroyable").out).default
 local Object = TS.import(script, TS.getModule(script, "@rbxts", "object-utils"))
-local createSerializer = TS.import(script, TS.getModule(script, "@rbxts", "serio").out).default
 local repr = TS.import(script, TS.getModule(script, "@rbxts", "repr").out)
 local _middleware = TS.import(script, script.Parent.Parent, "middleware")
 local DropRequest = _middleware.DropRequest
 local MiddlewareProvider = _middleware.MiddlewareProvider
 local ServerEmitter = TS.import(script, script.Parent, "server-emitter").ServerEmitter
 local ClientEmitter = TS.import(script, script.Parent, "client-emitter").ClientEmitter
-local _utility = TS.import(script, script.Parent.Parent, "utility")
-local readMessage = _utility.readMessage
-local writeMessage = _utility.writeMessage
+local Relayer = TS.import(script, script.Parent.Parent, "relayer").Relayer
+local Serdes = TS.import(script, script.Parent.Parent, "serdes").Serdes
+local readMessage = TS.import(script, script.Parent.Parent, "utility").readMessage
 if setLuneContext == nil then
 	setLuneContext = function() end
 end
@@ -28,26 +24,6 @@ local defaultMesssageEmitterOptions = {
 	batchRate = 1 / 24,
 	doNotBatch = {},
 }
-local sendMessage
-do
-	local name = "sendMessage"
-	local existing = ReplicatedStorage:FindFirstChild(name)
-	local remote = (existing or Instance.new("RemoteEvent", ReplicatedStorage))
-	if existing == nil then
-		remote.Name = name
-	end
-	sendMessage = remote
-end
-local sendUnreliableMessage
-do
-	local name = "unreliableMessage"
-	local existing = ReplicatedStorage:FindFirstChild(name)
-	local remote = (existing or Instance.new("UnreliableRemoteEvent", ReplicatedStorage))
-	if existing == nil then
-		remote.Name = name
-	end
-	sendUnreliableMessage = remote
-end
 local MessageEmitter
 do
 	local super = Destroyable
@@ -71,21 +47,20 @@ do
 		self.server = ServerEmitter.new(self)
 		self.client = ClientEmitter.new(self)
 		self.middleware = MiddlewareProvider.new()
+		self.relayer = Relayer.new(self)
+		self.serdes = Serdes.new()
 		self.clientCallbacks = {}
 		self.clientFunctions = {}
 		self.serverCallbacks = {}
 		self.serverFunctions = {}
 		self.guards = {}
-		self.serializers = {}
-		self.serverQueue = {}
-		self.clientBroadcastQueue = {}
-		self.clientQueue = {}
 		self.trash:add(function()
 			self.clientCallbacks = {}
 			self.serverCallbacks = {}
 			self.clientFunctions = {}
 			self.clientCallbacks = {}
-			self.serializers = {}
+			self.serdes.serializers = {}
+			self.relayer:relayAll()
 			setmetatable(self, nil)
 		end)
 	end
@@ -93,8 +68,9 @@ do
 		local emitter = MessageEmitter.new(Object.assign({}, defaultMesssageEmitterOptions, options))
 		if meta == nil then
 			warn("[tether::warning] Failed to generate message metadata - make sure you have the Flamework transformer and are using Flamework macro-friendly types in your schemas")
-			return emitter:initialize()
+			return emitter
 		end
+		-- lore
 		-- https://discord.com/channels/476080952636997633/506983834877689856/1363938149486821577
 		for kind, _binding in pairs(meta) do
 			local guard = _binding.guard
@@ -104,17 +80,9 @@ do
 			if serializerMetadata == nil then
 				continue
 			end
-			emitter:addSerializer(numberKind, serializerMetadata)
-		end
-		return emitter:initialize()
-	end
-	function MessageEmitter:queueMessage(context, message, data)
-		local queue = if context == "client" then self.clientQueue elseif context == true then self.clientBroadcastQueue else self.serverQueue
-		local _data = data
-		table.insert(queue, _data)
-		if not self:shouldBatch(message) then
-			self:relay()
+			emitter.serdes:addSerializer(numberKind, serializerMetadata)
 		end
+		return emitter
 	end
 	function MessageEmitter:runClientMiddlewares(message, data, player)
 		if not self:validateData(message, data) then
@@ -125,7 +93,7 @@ do
 			message = message,
 			data = data,
 			getRawData = function()
-				return self:getPacket(message, data)
+				return self.serdes:serializePacket(message, data)
 			end,
 		}
 		for _, globalMiddleware in self.middleware:getClientGlobal() do
@@ -161,7 +129,7 @@ do
 			message = message,
 			data = data,
 			getRawData = function()
-				return self:getPacket(message, data)
+				return self.serdes:serializePacket(message, data)
 			end,
 		}
 		for _, globalMiddleware in self.middleware:getServerGlobal() do
@@ -189,275 +157,14 @@ do
 		end
 		return { false, ctx.data }
 	end
-	function MessageEmitter:initialize()
-		setLuneContext("client")
-		if RunService:IsClient() then
-			self.trash:add(sendMessage.OnClientEvent:Connect(function(...)
-				local serializedPacket = { ... }
-				return self:onRemoteFire(false, serializedPacket)
-			end))
-			self.trash:add(sendUnreliableMessage.OnClientEvent:Connect(function(...)
-				local serializedPacket = { ... }
-				return self:onRemoteFire(false, serializedPacket)
-			end))
-		end
-		setLuneContext("server")
-		if RunService:IsServer() then
-			self.trash:add(sendMessage.OnServerEvent:Connect(function(player, ...)
-				local serializedPacket = { ... }
-				return self:onRemoteFire(true, serializedPacket, player)
-			end))
-			self.trash:add(sendUnreliableMessage.OnServerEvent:Connect(function(player, ...)
-				local serializedPacket = { ... }
-				return self:onRemoteFire(true, serializedPacket, player)
-			end))
-		end
-		local elapsed = 0
-		local _binding = self.options
-		local batchRemotes = _binding.batchRemotes
-		local batchRate = _binding.batchRate
-		if not batchRemotes then
-			return self
-		end
-		self.trash:add(RunService.Heartbeat:Connect(function(dt)
-			elapsed += dt
-			if elapsed < batchRate then
-				return nil
-			end
-			elapsed -= batchRate
-			self:relay()
-		end))
-		return self
-	end
-	function MessageEmitter:relay()
-		local getPacket = function(info)
-			return info.packet
-		end
-		if RunService:IsClient() then
-			if #self.serverQueue == 0 then
-				return nil
-			end
-			local _exp = self.serverQueue
-			-- ▼ ReadonlyArray.map ▼
-			local _newValue = table.create(#_exp)
-			local _callback = function(_param)
-				local message = _param[1]
-				local data = _param[2]
-				local unreliable = _param[3]
-				local packet = self:getPacket(message, data)
-				return {
-					packet = packet,
-					unreliable = unreliable,
-				}
-			end
-			for _k, _v in _exp do
-				_newValue[_k] = _callback(_v, _k - 1, _exp)
-			end
-			-- ▲ ReadonlyArray.map ▲
-			local serverPacketInfos = _newValue
-			-- ▼ ReadonlyArray.filter ▼
-			local _newValue_1 = {}
-			local _callback_1 = function(info)
-				return info.unreliable
-			end
-			local _length = 0
-			for _k, _v in serverPacketInfos do
-				if _callback_1(_v, _k - 1, serverPacketInfos) == true then
-					_length += 1
-					_newValue_1[_length] = _v
-				end
-			end
-			-- ▲ ReadonlyArray.filter ▲
-			-- ▼ ReadonlyArray.map ▼
-			local _newValue_2 = table.create(#_newValue_1)
-			for _k, _v in _newValue_1 do
-				_newValue_2[_k] = getPacket(_v, _k - 1, _newValue_1)
-			end
-			-- ▲ ReadonlyArray.map ▲
-			local unreliableServerPackets = _newValue_2
-			-- ▼ ReadonlyArray.filter ▼
-			local _newValue_3 = {}
-			local _callback_2 = function(info)
-				return not info.unreliable
-			end
-			local _length_1 = 0
-			for _k, _v in serverPacketInfos do
-				if _callback_2(_v, _k - 1, serverPacketInfos) == true then
-					_length_1 += 1
-					_newValue_3[_length_1] = _v
-				end
-			end
-			-- ▲ ReadonlyArray.filter ▲
-			-- ▼ ReadonlyArray.map ▼
-			local _newValue_4 = table.create(#_newValue_3)
-			for _k, _v in _newValue_3 do
-				_newValue_4[_k] = getPacket(_v, _k - 1, _newValue_3)
-			end
-			-- ▲ ReadonlyArray.map ▲
-			local serverPackets = _newValue_4
-			if not (#unreliableServerPackets == 0) then
-				sendUnreliableMessage:FireServer(unpack(unreliableServerPackets))
-			end
-			if not (#serverPackets == 0) then
-				sendMessage:FireServer(unpack(serverPackets))
-			end
-			self.serverQueue = {}
-			return nil
-		end
-		local clientPackets = {}
-		local addClientPacket = function(player, packetInfo)
-			local _player = player
-			local _condition = clientPackets[_player]
-			if _condition == nil then
-				_condition = {}
-			end
-			local packetList = _condition
-			local _packetInfo = packetInfo
-			table.insert(packetList, _packetInfo)
-			local _player_1 = player
-			clientPackets[_player_1] = packetList
-		end
-		for _, _binding in self.clientQueue do
-			local player = _binding[1]
-			local message = _binding[2]
-			local data = _binding[3]
-			local unreliable = _binding[4]
-			local packet = self:getPacket(message, data)
-			local info = {
-				packet = packet,
-				unreliable = unreliable,
-			}
-			if typeof(player) == "Instance" then
-				addClientPacket(player, info)
-			else
-				for _1, p in player do
-					addClientPacket(p, info)
-				end
-			end
-		end
-		if not (#self.clientBroadcastQueue == 0) then
-			local _exp = self.clientBroadcastQueue
-			-- ▼ ReadonlyArray.map ▼
-			local _newValue = table.create(#_exp)
-			local _callback = function(_param)
-				local message = _param[1]
-				local data = _param[2]
-				local unreliable = _param[3]
-				local packet = self:getPacket(message, data)
-				return {
-					packet = packet,
-					unreliable = unreliable,
-				}
-			end
-			for _k, _v in _exp do
-				_newValue[_k] = _callback(_v, _k - 1, _exp)
-			end
-			-- ▲ ReadonlyArray.map ▲
-			local clientBroadcastPackets = _newValue
-			-- ▼ ReadonlyArray.filter ▼
-			local _newValue_1 = {}
-			local _callback_1 = function(info)
-				return info.unreliable
-			end
-			local _length = 0
-			for _k, _v in clientBroadcastPackets do
-				if _callback_1(_v, _k - 1, clientBroadcastPackets) == true then
-					_length += 1
-					_newValue_1[_length] = _v
-				end
-			end
-			-- ▲ ReadonlyArray.filter ▲
-			-- ▼ ReadonlyArray.map ▼
-			local _newValue_2 = table.create(#_newValue_1)
-			for _k, _v in _newValue_1 do
-				_newValue_2[_k] = getPacket(_v, _k - 1, _newValue_1)
-			end
-			-- ▲ ReadonlyArray.map ▲
-			local unreliableBroadcastPackets = _newValue_2
-			-- ▼ ReadonlyArray.filter ▼
-			local _newValue_3 = {}
-			local _callback_2 = function(info)
-				return not info.unreliable
-			end
-			local _length_1 = 0
-			for _k, _v in clientBroadcastPackets do
-				if _callback_2(_v, _k - 1, clientBroadcastPackets) == true then
-					_length_1 += 1
-					_newValue_3[_length_1] = _v
-				end
-			end
-			-- ▲ ReadonlyArray.filter ▲
-			-- ▼ ReadonlyArray.map ▼
-			local _newValue_4 = table.create(#_newValue_3)
-			for _k, _v in _newValue_3 do
-				_newValue_4[_k] = getPacket(_v, _k - 1, _newValue_3)
-			end
-			-- ▲ ReadonlyArray.map ▲
-			local broadcastPackets = _newValue_4
-			if not (#unreliableBroadcastPackets == 0) then
-				sendUnreliableMessage:FireAllClients(unpack(unreliableBroadcastPackets))
-			end
-			if not (#broadcastPackets == 0) then
-				sendMessage:FireAllClients(unpack(broadcastPackets))
-			end
-			self.clientBroadcastQueue = {}
-		end
-		if not (#self.clientQueue == 0) then
-			for player, packetInfo in clientPackets do
-				if #packetInfo == 0 then
-					continue
-				end
-				if #packetInfo == 0 then
-					continue
-				end
-				-- ▼ ReadonlyArray.filter ▼
-				local _newValue = {}
-				local _callback = function(info)
-					return info.unreliable
-				end
-				local _length = 0
-				for _k, _v in packetInfo do
-					if _callback(_v, _k - 1, packetInfo) == true then
-						_length += 1
-						_newValue[_length] = _v
-					end
-				end
-				-- ▲ ReadonlyArray.filter ▲
-				-- ▼ ReadonlyArray.map ▼
-				local _newValue_1 = table.create(#_newValue)
-				for _k, _v in _newValue do
-					_newValue_1[_k] = getPacket(_v, _k - 1, _newValue)
-				end
-				-- ▲ ReadonlyArray.map ▲
-				local unreliablePackets = _newValue_1
-				-- ▼ ReadonlyArray.filter ▼
-				local _newValue_2 = {}
-				local _callback_1 = function(info)
-					return not info.unreliable
-				end
-				local _length_1 = 0
-				for _k, _v in packetInfo do
-					if _callback_1(_v, _k - 1, packetInfo) == true then
-						_length_1 += 1
-						_newValue_2[_length_1] = _v
-					end
-				end
-				-- ▲ ReadonlyArray.filter ▲
-				-- ▼ ReadonlyArray.map ▼
-				local _newValue_3 = table.create(#_newValue_2)
-				for _k, _v in _newValue_2 do
-					_newValue_3[_k] = getPacket(_v, _k - 1, _newValue_2)
-				end
-				-- ▲ ReadonlyArray.map ▲
-				local packets = _newValue_3
-				if not (#unreliablePackets == 0) then
-					sendUnreliableMessage:FireClient(player, unpack(unreliablePackets))
-				end
-				if not (#packets == 0) then
-					sendMessage:FireClient(player, unpack(packets))
-				end
+	function MessageEmitter:onRemoteFire(isServer, serializedPackets, player)
+		for _, packet in serializedPackets do
+			if buffer.len(packet.messageBuf) > 1 then
+				return warn("[tether::warning] Rejected packet because message buffer was larger than one byte")
 			end
-			self.clientQueue = {}
+			local message = readMessage(packet)
+			self:executeEventCallbacks(isServer, message, packet, player)
+			self:executeFunctions(isServer, message, packet)
 		end
 	end
 	function MessageEmitter:validateData(message, data, requestDropReason)
@@ -474,16 +181,6 @@ do
 		end
 		return guardPassed
 	end
-	function MessageEmitter:onRemoteFire(isServer, serializedPackets, player)
-		for _, packet in serializedPackets do
-			if buffer.len(packet.messageBuf) > 1 then
-				return warn("[tether::warning] Rejected packet because message buffer was larger than one byte")
-			end
-			local message = readMessage(packet)
-			self:executeEventCallbacks(isServer, message, packet, player)
-			self:executeFunctions(isServer, message, packet)
-		end
-	end
 	function MessageEmitter:executeFunctions(isServer, message, serializedPacket)
 		local functionsMap = if isServer then self.serverFunctions else self.clientFunctions
 		local _message = message
@@ -506,59 +203,19 @@ do
 		local packet = self:deserializeAndValidate(message, serializedPacket)
 		for callback in callbacks do
 			if isServer then
+				local _arg0 = player ~= nil
+				assert(_arg0)
 				callback(player, packet)
 			else
 				callback(packet)
 			end
 		end
 	end
-	function MessageEmitter:shouldBatch(message)
-		local _condition = self.options.batchRemotes
-		if _condition then
-			local _doNotBatch = self.options.doNotBatch
-			local _message = message
-			_condition = not (_doNotBatch[_message] ~= nil)
-		end
-		return _condition
-	end
 	function MessageEmitter:deserializeAndValidate(message, serializedPacket)
-		local serializer = self:getSerializer(message)
-		local _packet = serializer
-		if _packet ~= nil then
-			_packet = _packet.deserialize(serializedPacket)
-		end
-		local packet = _packet
+		local packet = self.serdes:deserializePacket(message, serializedPacket)
 		self:validateData(message, packet)
 		return packet
 	end
-	function MessageEmitter:getPacket(message, data)
-		local serializer = self:getSerializer(message)
-		local messageBuf = buffer.create(1)
-		writeMessage(messageBuf, message)
-		if serializer == nil then
-			return {
-				messageBuf = messageBuf,
-				buf = buffer.create(0),
-				blobs = {},
-			}
-		end
-		local _object = {
-			messageBuf = messageBuf,
-		}
-		for _k, _v in serializer.serialize(data) do
-			_object[_k] = _v
-		end
-		return _object
-	end
-	function MessageEmitter:addSerializer(message, meta)
-		self.serializers[message] = self:createMessageSerializer(meta)
-	end
-	function MessageEmitter:createMessageSerializer(meta)
-		return createSerializer(meta)
-	end
-	function MessageEmitter:getSerializer(message)
-		return self.serializers[message]
-	end
 end
 return {
 	MessageEmitter = MessageEmitter,

package/out/emitters/server-emitter.luau

@@ -2,6 +2,9 @@
 local TS = _G[script]
 local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
 local ContextualEmitter = TS.import(script, script.Parent, "contextual-emitter").ContextualEmitter
+if setLuneContext == nil then
+	setLuneContext = function() end
+end
 local ServerEmitter
 do
 	local super = ContextualEmitter
@@ -34,7 +37,7 @@ do
 			if dropRequest then
 				return nil
 			end
-			self.master:queueMessage(self.context, message, { message, newData, unreliable })
+			self.master.relayer:queueMessage(self.context, message, { message, newData, unreliable })
 		end)
 	end
 	function ServerEmitter:setCallback(message, returnMessage, callback)

package/out/relayer.d.ts

@@ -0,0 +1,16 @@
+import type { BaseMessage } from "./structs";
+import type { MessageEmitter } from "./emitters/message-emitter";
+export type ServerQueuedMessageData<MessageData> = [keyof MessageData & BaseMessage, MessageData[keyof MessageData], boolean];
+export type ClientQueuedMessageData<MessageData> = [Player | Player[], ...ServerQueuedMessageData<MessageData>];
+export type QueuedMessageData<MessageData> = ClientQueuedMessageData<MessageData> | ServerQueuedMessageData<MessageData>;
+export declare class Relayer<MessageData> {
+    private readonly emitter;
+    private serverQueue;
+    private clientBroadcastQueue;
+    private clientQueue;
+    constructor(emitter: MessageEmitter<MessageData>);
+    queueMessage<K extends keyof MessageData>(context: "client" | "server" | true, message: K & BaseMessage, data: QueuedMessageData<MessageData>): void;
+    /** Send all queued data across the network simultaneously */
+    relayAll(): void;
+    private relay;
+}

package/out/relayer.luau

@@ -0,0 +1,214 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local ReplicatedStorage = _services.ReplicatedStorage
+local RunService = _services.RunService
+local _utility = TS.import(script, script.Parent, "utility")
+local getAllPacketsWhich = _utility.getAllPacketsWhich
+local isReliable = _utility.isReliable
+local isUnreliable = _utility.isUnreliable
+local shouldBatch = _utility.shouldBatch
+if setLuneContext == nil then
+	setLuneContext = function() end
+end
+local sendMessage
+do
+	local name = "sendMessage"
+	local existing = ReplicatedStorage:FindFirstChild(name)
+	local remote = (existing or Instance.new("RemoteEvent", ReplicatedStorage))
+	if existing == nil then
+		remote.Name = name
+	end
+	sendMessage = remote
+end
+local sendUnreliableMessage
+do
+	local name = "unreliableMessage"
+	local existing = ReplicatedStorage:FindFirstChild(name)
+	local remote = (existing or Instance.new("UnreliableRemoteEvent", ReplicatedStorage))
+	if existing == nil then
+		remote.Name = name
+	end
+	sendUnreliableMessage = remote
+end
+local Relayer
+do
+	Relayer = setmetatable({}, {
+		__tostring = function()
+			return "Relayer"
+		end,
+	})
+	Relayer.__index = Relayer
+	function Relayer.new(...)
+		local self = setmetatable({}, Relayer)
+		return self:constructor(...) or self
+	end
+	function Relayer:constructor(emitter)
+		self.emitter = emitter
+		self.serverQueue = {}
+		self.clientBroadcastQueue = {}
+		self.clientQueue = {}
+		setLuneContext("client")
+		if RunService:IsClient() then
+			self.emitter.trash:add(sendMessage.OnClientEvent:Connect(function(...)
+				local serializedPacket = { ... }
+				return self.emitter:onRemoteFire(false, serializedPacket)
+			end))
+			self.emitter.trash:add(sendUnreliableMessage.OnClientEvent:Connect(function(...)
+				local serializedPacket = { ... }
+				return self.emitter:onRemoteFire(false, serializedPacket)
+			end))
+		end
+		setLuneContext("server")
+		if RunService:IsServer() then
+			self.emitter.trash:add(sendMessage.OnServerEvent:Connect(function(player, ...)
+				local serializedPacket = { ... }
+				return self.emitter:onRemoteFire(true, serializedPacket, player)
+			end))
+			self.emitter.trash:add(sendUnreliableMessage.OnServerEvent:Connect(function(player, ...)
+				local serializedPacket = { ... }
+				return self.emitter:onRemoteFire(true, serializedPacket, player)
+			end))
+		end
+		local elapsed = 0
+		local _binding = self.emitter.options
+		local batchRemotes = _binding.batchRemotes
+		local batchRate = _binding.batchRate
+		if not batchRemotes then
+			return self
+		end
+		self.emitter.trash:add(RunService.Heartbeat:Connect(function(dt)
+			elapsed += dt
+			if elapsed < batchRate then
+				return nil
+			end
+			elapsed -= batchRate
+			self:relayAll()
+		end))
+	end
+	function Relayer:queueMessage(context, message, data)
+		local queue = if context == "client" then self.clientQueue elseif context == true then self.clientBroadcastQueue else self.serverQueue
+		local _data = data
+		table.insert(queue, _data)
+		if not shouldBatch(message, self.emitter.options) then
+			self:relayAll()
+		end
+	end
+	function Relayer:relayAll()
+		if RunService:IsClient() then
+			return self:relay(function(...)
+				local packets = { ... }
+				return sendMessage:FireServer(unpack(packets))
+			end, function(...)
+				local packets = { ... }
+				return sendUnreliableMessage:FireServer(unpack(packets))
+			end, self.serverQueue, function()
+				self.serverQueue = {}
+				return self.serverQueue
+			end)
+		end
+		self:relay(function(...)
+			local packets = { ... }
+			return sendMessage:FireAllClients(unpack(packets))
+		end, function(...)
+			local packets = { ... }
+			return sendUnreliableMessage:FireAllClients(unpack(packets))
+		end, self.clientBroadcastQueue, function()
+			self.clientBroadcastQueue = {}
+			return self.clientBroadcastQueue
+		end)
+		local playerPacketInfos = {}
+		local addClientPacket = function(player, packetInfo)
+			local _player = player
+			local _condition = playerPacketInfos[_player]
+			if _condition == nil then
+				_condition = {}
+			end
+			local packetInfos = _condition
+			local _packetInfo = packetInfo
+			table.insert(packetInfos, _packetInfo)
+			local _player_1 = player
+			playerPacketInfos[_player_1] = packetInfos
+		end
+		for _, _binding in self.clientQueue do
+			local player = _binding[1]
+			local message = _binding[2]
+			local data = _binding[3]
+			local unreliable = _binding[4]
+			local packet = self.emitter.serdes:serializePacket(message, data)
+			local info = {
+				packet = packet,
+				unreliable = unreliable,
+			}
+			if typeof(player) == "Instance" then
+				addClientPacket(player, info)
+			else
+				for _1, p in player do
+					addClientPacket(p, info)
+				end
+			end
+		end
+		if not (#self.clientQueue == 0) then
+			for player, packetInfos in playerPacketInfos do
+				if #packetInfos == 0 then
+					continue
+				end
+				local unreliablePackets = getAllPacketsWhich(packetInfos, isUnreliable)
+				local packets = getAllPacketsWhich(packetInfos, isReliable)
+				if not (#unreliablePackets == 0) then
+					sendUnreliableMessage:FireClient(player, unpack(unreliablePackets))
+				end
+				if not (#packets == 0) then
+					sendMessage:FireClient(player, unpack(packets))
+				end
+			end
+			self.clientQueue = {}
+		end
+	end
+	function Relayer:relay(send, sendUnreliable, queue, clearQueue)
+		if #queue == 0 then
+			return nil
+		end
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#queue)
+		local _callback = function(messageData)
+			local message
+			local data
+			local unreliable
+			local _arg0 = messageData[1]
+			if typeof(_arg0) == "Instance" then
+				local _binding = messageData
+				message = _binding[2]
+				data = _binding[3]
+				unreliable = _binding[4]
+			else
+				local _binding = messageData
+				message = _binding[1]
+				data = _binding[2]
+				unreliable = _binding[3]
+			end
+			local packet = self.emitter.serdes:serializePacket(message, data)
+			return {
+				packet = packet,
+				unreliable = unreliable,
+			}
+		end
+		for _k, _v in queue do
+			_newValue[_k] = _callback(_v, _k - 1, queue)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local packetInfos = _newValue
+		local unreliablePackets = getAllPacketsWhich(packetInfos, isUnreliable)
+		local packets = getAllPacketsWhich(packetInfos, isReliable)
+		if not (#unreliablePackets == 0) then
+			sendUnreliable(unpack(unreliablePackets))
+		end
+		if not (#packets == 0) then
+			send(unpack(packets))
+		end
+		clearQueue()
+	end
+end
+return {
+	Relayer = Relayer,
+}

package/out/serdes.d.ts

@@ -0,0 +1,13 @@
+import type { Modding } from "@flamework/core";
+import type { Serializer, SerializerMetadata } from "@rbxts/serio";
+import type { BaseMessage, SerializedPacket } from "./structs";
+export declare class Serdes<MessageData> {
+    serializers: Partial<Record<keyof MessageData, Serializer<MessageData[keyof MessageData]>>>;
+    serializePacket<Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind]): SerializedPacket;
+    deserializePacket<K extends keyof MessageData>(message: K & BaseMessage, serializedPacket: SerializedPacket): MessageData[K] | undefined;
+    /** @metadata macro */
+    addSerializer<K extends keyof MessageData>(message: K & BaseMessage, meta?: Modding.Many<SerializerMetadata<MessageData[K]>>): void;
+    /** @metadata macro */
+    createMessageSerializer<Kind extends keyof MessageData>(meta?: Modding.Many<SerializerMetadata<MessageData[Kind]>>): Serializer<MessageData[Kind]>;
+    getSerializer<Kind extends keyof MessageData>(message: Kind & BaseMessage): Serializer<MessageData[Kind] | undefined> | undefined;
+}

package/out/serdes.luau

@@ -0,0 +1,58 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local createSerializer = TS.import(script, TS.getModule(script, "@rbxts", "serio").out).default
+local createMessageBuffer = TS.import(script, script.Parent, "utility").createMessageBuffer
+local Serdes
+do
+	Serdes = setmetatable({}, {
+		__tostring = function()
+			return "Serdes"
+		end,
+	})
+	Serdes.__index = Serdes
+	function Serdes.new(...)
+		local self = setmetatable({}, Serdes)
+		return self:constructor(...) or self
+	end
+	function Serdes:constructor()
+		self.serializers = {}
+	end
+	function Serdes:serializePacket(message, data)
+		local serializer = self:getSerializer(message)
+		local messageBuf = createMessageBuffer(message)
+		if serializer == nil then
+			return {
+				messageBuf = messageBuf,
+				buf = buffer.create(0),
+				blobs = {},
+			}
+		end
+		local _object = {
+			messageBuf = messageBuf,
+		}
+		for _k, _v in serializer.serialize(data) do
+			_object[_k] = _v
+		end
+		return _object
+	end
+	function Serdes:deserializePacket(message, serializedPacket)
+		local serializer = self:getSerializer(message)
+		local _result = serializer
+		if _result ~= nil then
+			_result = _result.deserialize(serializedPacket)
+		end
+		return _result
+	end
+	function Serdes:addSerializer(message, meta)
+		self.serializers[message] = self:createMessageSerializer(meta)
+	end
+	function Serdes:createMessageSerializer(meta)
+		return createSerializer(meta)
+	end
+	function Serdes:getSerializer(message)
+		return self.serializers[message]
+	end
+end
+return {
+	Serdes = Serdes,
+}

package/out/utility.d.ts

@@ -1,6 +1,13 @@
-import type { BaseMessage, SerializedPacket } from "./structs";
+import type { BaseMessage, PacketInfo, SerializedPacket } from "./structs";
+import type { MessageEmitterOptions } from "./emitters/message-emitter";
 export declare function bufferToString(buf?: buffer): string;
 export declare function encodeMessage(message: BaseMessage): number;
 export declare function decodeMessage(encoded: number): BaseMessage;
 export declare function writeMessage(buf: buffer, message: BaseMessage): void;
 export declare function readMessage(packet: SerializedPacket | buffer): BaseMessage;
+export declare function createMessageBuffer(message: BaseMessage): buffer;
+export declare function getAllPacketsWhich(infos: PacketInfo[], predicate: (info: PacketInfo) => boolean): SerializedPacket[];
+export declare function isUnreliable(info: PacketInfo): boolean;
+export declare function isReliable(info: PacketInfo): boolean;
+export declare function getPacket(info: PacketInfo): SerializedPacket;
+export declare function shouldBatch<MessageData>(message: keyof MessageData & BaseMessage, options: MessageEmitterOptions<MessageData>): boolean;

package/out/utility.luau

@@ -44,10 +44,61 @@ local function readMessage(packet)
 	local buf = if type(_packet) == "buffer" then packet else packet.messageBuf
 	return decodeMessage(buffer.readu8(buf, 0))
 end
+local function createMessageBuffer(message)
+	local messageBuf = buffer.create(1)
+	writeMessage(messageBuf, message)
+	return messageBuf
+end
+local getPacket
+local function getAllPacketsWhich(infos, predicate)
+	local _infos = infos
+	local _predicate = predicate
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _length = 0
+	for _k, _v in _infos do
+		if _predicate(_v, _k - 1, _infos) == true then
+			_length += 1
+			_newValue[_length] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue_1 = table.create(#_newValue)
+	for _k, _v in _newValue do
+		_newValue_1[_k] = getPacket(_v, _k - 1, _newValue)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	return _newValue_1
+end
+local function isUnreliable(info)
+	return info.unreliable
+end
+local function isReliable(info)
+	return not info.unreliable
+end
+function getPacket(info)
+	return info.packet
+end
+local function shouldBatch(message, options)
+	local _condition = options.batchRemotes
+	if _condition then
+		local _doNotBatch = options.doNotBatch
+		local _message = message
+		_condition = not (_doNotBatch[_message] ~= nil)
+	end
+	return _condition
+end
 return {
 	bufferToString = bufferToString,
 	encodeMessage = encodeMessage,
 	decodeMessage = decodeMessage,
 	writeMessage = writeMessage,
 	readMessage = readMessage,
+	createMessageBuffer = createMessageBuffer,
+	getAllPacketsWhich = getAllPacketsWhich,
+	isUnreliable = isUnreliable,
+	isReliable = isReliable,
+	getPacket = getPacket,
+	shouldBatch = shouldBatch,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "main": "out/init.luau",
   "scripts": {
     "setup-rokit": "rokit trust lune-org/lune && rokit trust rojo-rbx/rojo && rokit install",