@rbxts/tether 1.2.7 → 1.2.8

package/README.md

@@ -1,4 +1,5 @@
 # Tether
+
 A message-based networking solution for Roblox with automatic binary serialization and type validation.
 
 > [!CAUTION]
@@ -7,15 +8,16 @@ A message-based networking solution for Roblox with automatic binary serializati
 ## Usage
 
 ### In `shared/messaging.ts`
+
 ```ts
-import type { DataType } from "@rbxts/flamework-binary-serializer";
 import { MessageEmitter } from "@rbxts/tether";
+import type { DataType } from "@rbxts/flamework-binary-serializer";
 
 export const messaging = MessageEmitter.create<MessageData>();
 
 export const enum Message {
   Test,
-  Packed
+  Packed,
 }
 
 export interface MessageData {
@@ -40,37 +42,43 @@ export interface MessageData {
 > Every single message kind must implement an interface for it's data (in the example that would be the object types in `MessageData`). Message serialization (as well as your message itself) will not work if you don't do this.
 
 ### Server
+
 ```ts
 import { Message, messaging } from "shared/messaging";
 
-messaging.server.on(Message.Test, (player, data) => print(player, "sent data:", data));
+messaging.server.on(Message.Test, (player, data) =>
+  print(player, "sent data:", data)
+);
 ```
 
 ### Client
+
 ```ts
 import { Message, messaging } from "shared/messaging";
 
 messaging.server.emit(Message.Test, {
   foo: "bar",
-  n: 69
+  n: 69,
 });
 ```
 
 ## Simulated Remote Functions
+
 Tether does not directly use RemoteFunctions since it's based on the MessageEmitter structure. However I have created a small framework to simulate remote functions, as shown below.
 
 For each function you will need two messages. One to invoke the function, and one to send the return value back (which is done automatically).
 
 ### In `shared/messaging.ts`
+
 ```ts
-import type { DataType } from "@rbxts/flamework-binary-serializer";
 import { MessageEmitter } from "@rbxts/tether";
+import type { DataType } from "@rbxts/flamework-binary-serializer";
 
 export const messaging = MessageEmitter.create<MessageData>();
 
 export const enum Message {
   Increment,
-  IncrementReturn
+  IncrementReturn,
 }
 
 export interface MessageData {
@@ -80,13 +88,19 @@ export interface MessageData {
 ```
 
 ### Server
+
 ```ts
 import { Message, messaging } from "shared/messaging";
 
-messaging.server.setCallback(Message.Increment, Message.IncrementReturn, (_, n) => n + 1);
+messaging.server.setCallback(
+  Message.Increment,
+  Message.IncrementReturn,
+  (_, n) => n + 1
+);
 ```
 
 ### Client
+
 ```ts
 import { Message, messaging } from "shared/messaging";
 
@@ -96,81 +110,98 @@ messaging.server
 
 // or use await style
 async function main(): Promise<void> {
-  const value = await messaging.server.invoke(Message.Increment, Message.IncrementReturn, 69);
-  print(value) // 70
+  const value = await messaging.server.invoke(
+    Message.Increment,
+    Message.IncrementReturn,
+    69
+  );
+  print(value); // 70
 }
 
 main();
 ```
 
 ## Middleware
+
 Drop, delay, or modify requests
 
 ### Creating middleware
 
 **Note:** These client/server middlewares can be implemented as shared middlewares. This is strictly an example.
+
 #### Client
+
 ```ts
 import type { ClientMiddleware } from "@rbxts/tether";
 
 export function logClient(): ClientMiddleware {
-  return message => (player, ctx) => print(`[LOG]: Sent message '${message}' to player ${player} with data:`, ctx.data);
+  return (player, ctx) =>
+    print(
+      `[LOG]: Sent message '${ctx.message}' to player ${player} with data:`,
+      ctx.data
+    );
 }
 ```
 
 #### Server
+
 ```ts
 import type { ServerMiddleware } from "@rbxts/tether";
 
 export function logServer(): ServerMiddleware {
-  return message => ctx => print(`[LOG]: Sent message '${message}' to server with data:`, ctx.data);
+  return (ctx) =>
+    print(
+      `[LOG]: Sent message '${ctx.message}' to server with data:`,
+      ctx.data
+    );
 }
 ```
 
 #### Shared
+
 ```ts
 import { type SharedMiddleware, DropRequest } from "@rbxts/tether";
 
 export function rateLimit(interval: number): SharedMiddleware {
   let lastRequest = 0;
 
-  return message => // message attempting to be sent
-    () => { // no data/player - it's a shared middleware
-      if (os.clock() - lastRequest < interval)
-        return DropRequest;
+  return () => {
+    if (os.clock() - lastRequest < interval) return DropRequest;
 
-      lastRequest = os.clock();
-    };
+    lastRequest = os.clock();
+  };
 }
 ```
 
 #### Transforming data
+
 ```ts
 import type { ServerMiddleware } from "@rbxts/tether";
 
 export function incrementNumberData(): ServerMiddleware<number> {
   // sets the data to be used by the any subsequent middlewares as well as sent through the remote
-  return () => ({ data, updateData }) => updateData(data + 1);
+  return ({ data, updateData }) => updateData(data + 1);
 }
 ```
 
 ### Using middleware
+
 ```ts
-import type { DataType } from "@rbxts/flamework-binary-serializer";
 import { MessageEmitter, BuiltinMiddlewares } from "@rbxts/tether";
+import type { DataType } from "@rbxts/flamework-binary-serializer";
 
 export const messaging = MessageEmitter.create<MessageData>();
 messaging.middleware
   // only allows requests to the server every 5 seconds,
   // drops any requests that occur within 5 seconds of each other
-  .useServer(Message.Test, BuiltinMiddlewares.rateLimit(5)) 
+  .useServer(Message.Test, BuiltinMiddlewares.rateLimit(5))
   // will be just one byte!
-  .useShared(Message.Packed, () => ctx => print("Packed object size:", buffer.len(ctx.getRawData().buffer)));
+  .useShared(Message.Packed, ctx => print("Packed object size:", buffer.len(ctx.getRawData().buffer)));
   // logs every message fired
   .useServerGlobal(logServer())
   .useClientGlobal(logClient())
   .useSharedGlobal(BuiltinMiddlewares.debug()); // verbosely logs every packet sent
-  .useServer(Message.Test, incrementNumberData()) // error! - data for Message.Test is not a number 
+  .useServer(Message.Test, incrementNumberData()) // error! - data for Message.Test is not a number
   .useServerGlobal(incrementNumberData()); // error! - global data type is always 'unknown', we cannot guarantee a number
 
 export const enum Message {
@@ -194,4 +225,4 @@ export interface MessageData {
     readonly boolean8: boolean;
   }>;
 }
-```
+```

package/out/builtin-middlewares.luau

@@ -18,10 +18,8 @@ do
 	]]
 	local function simulatePing(pingInMs)
 		return function()
-			return function()
-				task.wait(pingInMs / 1000)
-				return nil
-			end
+			task.wait(pingInMs / 1000)
+			return nil
 		end
 	end
 	_container.simulatePing = simulatePing
@@ -38,13 +36,11 @@ do
 		if throwError == nil then
 			throwError = true
 		end
-		return function(message)
-			return function(ctx)
-				local rawData = ctx.getRawData()
-				local totalSize = buffer.len(rawData.buffer) + #rawData.blobs * BLOB_SIZE
-				if totalSize > maxBytes then
-					return if throwError then error(`[@rbxts/tether]: Message '{message}' exceeded maximum packet size of {maxBytes} bytes`) else DropRequest
-				end
+		return function(ctx)
+			local rawData = ctx.getRawData()
+			local totalSize = buffer.len(rawData.buffer) + #rawData.blobs * BLOB_SIZE
+			if totalSize > maxBytes then
+				return if throwError then error(`[@rbxts/tether]: Message '{ctx.message}' exceeded maximum packet size of {maxBytes} bytes`) else DropRequest
 			end
 		end
 	end
@@ -60,12 +56,10 @@ do
 	local function rateLimit(interval)
 		local lastRequest = 0
 		return function()
-			return function()
-				if os.clock() - lastRequest < interval then
-					return DropRequest
-				end
-				lastRequest = os.clock()
+			if os.clock() - lastRequest < interval then
+				return DropRequest
 			end
+			lastRequest = os.clock()
 		end
 	end
 	_container.rateLimit = rateLimit
@@ -86,24 +80,23 @@ do
 		     
 	]]
 	local function debug(schema)
-		return function(message)
-			return function(_param)
-				local data = _param.data
-				local getRawData = _param.getRawData
-				local rawData = getRawData()
-				local bufferSize = buffer.len(rawData.buffer)
-				local blobsSize = #rawData.blobs * BLOB_SIZE
-				local schemaString = if schema ~= nil then " " .. table.concat(string.split(repr(schema[1], {
-					pretty = true,
-				}), "\n"), "\n ") else "unknown"
-				local text = { "\n", horizontalLine, "\n", "Packet sent to ", (if RunService:IsServer() then "client" else "server"), "!\n", " - Message: ", message, "\n", " - Data: ", repr(data, {
-					pretty = true,
-				}), "\n", " - Raw data:\n", "   - Buffer: ", bufferToString(rawData.buffer), "\n", "   - Blobs: ", repr(rawData.blobs, {
-					pretty = false,
-					robloxClassName = true,
-				}), "\n", " - Packet size: ", bufferSize + blobsSize, " bytes\n", "   - Buffer: ", bufferSize, " bytes\n", "   - Blobs: ", blobsSize, " bytes\n", " - Schema: ", schemaString, "\n", horizontalLine, "\n" }
-				print(table.concat(text, ""))
-			end
+		return function(_param)
+			local message = _param.message
+			local data = _param.data
+			local getRawData = _param.getRawData
+			local rawData = getRawData()
+			local bufferSize = buffer.len(rawData.buffer)
+			local blobsSize = #rawData.blobs * BLOB_SIZE
+			local schemaString = if schema ~= nil then " " .. table.concat(string.split(repr(schema[1], {
+				pretty = true,
+			}), "\n"), "\n ") else "unknown"
+			local text = { "\n", horizontalLine, "\n", "Packet sent to ", (if RunService:IsServer() then "client" else "server"), "!\n", " - Message: ", message, "\n", " - Data: ", repr(data, {
+				pretty = true,
+			}), "\n", " - Raw data:\n", "   - Buffer: ", bufferToString(rawData.buffer), "\n", "   - Blobs: ", repr(rawData.blobs, {
+				pretty = false,
+				robloxClassName = true,
+			}), "\n", " - Packet size: ", bufferSize + blobsSize, " bytes\n", "   - Buffer: ", bufferSize, " bytes\n", "   - Blobs: ", blobsSize, " bytes\n", " - Schema: ", schemaString, "\n", horizontalLine, "\n" }
+			print(table.concat(text, ""))
 		end
 	end
 	_container.debug = debug

package/out/message-emitter.d.ts

@@ -2,18 +2,26 @@ import { Modding } from "@flamework/core";
 import Destroyable from "@rbxts/destroyable";
 import { MiddlewareProvider } from "./middleware";
 import type { ClientMessageCallback, ServerMessageCallback, BaseMessage, MessageEmitterMetadata, ClientMessageFunctionCallback, ServerMessageFunctionCallback } from "./structs";
+interface MessageEmitterOptions {
+    readonly batchRemotes: boolean;
+    readonly batchRate: number;
+}
 export declare class MessageEmitter<MessageData> extends Destroyable {
+    private readonly options;
     readonly middleware: MiddlewareProvider<MessageData>;
     private readonly clientCallbacks;
     private readonly clientFunctions;
     private readonly serverCallbacks;
     private readonly serverFunctions;
+    private readonly clientQueue;
+    private readonly clientBroadcastQueue;
+    private readonly serverQueue;
     private readonly guards;
     private readonly serializers;
     private serverEvents;
     private clientEvents;
     /** @metadata macro */
-    static create<MessageData>(meta?: Modding.Many<MessageEmitterMetadata<MessageData>>): MessageEmitter<MessageData>;
+    static create<MessageData>(options?: Partial<MessageEmitterOptions>, meta?: Modding.Many<MessageEmitterMetadata<MessageData>>): MessageEmitter<MessageData>;
     private constructor();
     readonly server: {
         /**
@@ -101,11 +109,15 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
          */
         setCallback: <Kind extends keyof MessageData, ReturnKind extends keyof MessageData>(message: Kind & BaseMessage, returnMessage: ReturnKind & BaseMessage, callback: ClientMessageFunctionCallback<MessageData[Kind], MessageData[ReturnKind]>) => () => void;
     };
-    private validateData;
     private initialize;
+    private update;
+    private runClientMiddlewares;
+    private runServerMiddlewares;
+    private validateData;
     private onRemoteFire;
     private executeFunctions;
     private executeEventCallbacks;
+    private deserializeAndValidate;
     private once;
     private on;
     private getPacket;
@@ -115,3 +127,4 @@ export declare class MessageEmitter<MessageData> extends Destroyable {
     private createMessageSerializer;
     private getSerializer;
 }
+export {};

package/out/message-emitter.luau

@@ -11,12 +11,18 @@ local repr = TS.import(script, TS.getModule(script, "@rbxts", "repr").out)
 local _middleware = TS.import(script, script.Parent, "middleware")
 local DropRequest = _middleware.DropRequest
 local MiddlewareProvider = _middleware.MiddlewareProvider
--- TODO: error when trying to do something like server.emit() from the server
+local Object = TS.import(script, TS.getModule(script, "@rbxts", "object-utils"))
 local remotes = Networking.createEvent("@rbxts/tether:message-emitter@remotes")
+local noServerListen = "[@rbxts/tether]: Cannot listen to server message from client"
+local noClientListen = "[@rbxts/tether]: Cannot listen to client message from server"
 local metaGenerationFailed = "[@rbxts/tether]: Failed to generate message metadata - make sure you have the Flamework transformer and are using Flamework macro-friendly types in your schemas"
 local guardFailed = function(message, data)
 	return `[@rbxts/tether]: Type validation guard failed for message '{message}' - check your sent data\nSent data: {repr(data)}`
 end
+local defaultMesssageEmitterOptions = {
+	batchRemotes = true,
+	batchRate = 1 / 24,
+}
 local MessageEmitter
 do
 	local super = Destroyable
@@ -31,71 +37,61 @@ do
 		local self = setmetatable({}, MessageEmitter)
 		return self:constructor(...) or self
 	end
-	function MessageEmitter:constructor()
+	function MessageEmitter:constructor(options)
+		if options == nil then
+			options = defaultMesssageEmitterOptions
+		end
 		super.constructor(self)
+		self.options = options
 		self.middleware = MiddlewareProvider.new()
 		self.clientCallbacks = {}
 		self.clientFunctions = {}
 		self.serverCallbacks = {}
 		self.serverFunctions = {}
+		self.clientQueue = {}
+		self.clientBroadcastQueue = {}
+		self.serverQueue = {}
 		self.guards = {}
 		self.serializers = {}
 		self.server = {
 			on = function(message, callback)
+				if RunService:IsClient() then
+					error(noServerListen)
+				end
 				return self:on(message, callback, self.serverCallbacks)
 			end,
 			once = function(message, callback)
+				if RunService:IsClient() then
+					error(noServerListen)
+				end
 				return self:once(message, callback, self.serverCallbacks)
 			end,
 			emit = function(message, data, unreliable)
 				if unreliable == nil then
 					unreliable = false
 				end
-				local updateData = function(newData)
-					data = newData
-					return nil
-				end
-				local getPacket = function()
-					return self:getPacket(message, data)
-				end
-				if not self:validateData(message, data) then
-					return nil
+				if RunService:IsServer() then
+					error("[@rbxts/tether]: Cannot emit message to server from server")
 				end
 				task.spawn(function()
-					local ctx = {
-						data = data,
-						updateData = updateData,
-						getRawData = getPacket,
-					}
-					for _, globalMiddleware in self.middleware:getServerGlobal() do
-						if not self:validateData(message, data) then
-							return nil
-						end
-						local result = globalMiddleware(message)(ctx)
-						if result == DropRequest then
-							return nil
-						end
-					end
-					for _, middleware in self.middleware:getServer(message) do
-						if not self:validateData(message, data) then
-							return nil
-						end
-						local result = middleware(message)(ctx)
-						if result == DropRequest then
-							return nil
-						end
-					end
-					if not self:validateData(message, data) then
+					local _binding = self:runServerMiddlewares(message, data)
+					local dropRequest = _binding[1]
+					local newData = _binding[2]
+					if dropRequest then
 						return nil
 					end
-					local send = if unreliable then self.clientEvents.sendUnreliableServerMessage else self.clientEvents.sendServerMessage
-					send(getPacket())
+					local _serverQueue = self.serverQueue
+					local _arg0 = { message, newData, unreliable }
+					table.insert(_serverQueue, _arg0)
 				end)
 			end,
 			invoke = TS.async(function(message, returnMessage, data, unreliable)
 				if unreliable == nil then
 					unreliable = false
 				end
+				if RunService:IsServer() then
+					error("[@rbxts/tether]: Cannot invoke server function from server")
+				end
 				local _clientFunctions = self.clientFunctions
 				local _returnMessage = returnMessage
 				if not (_clientFunctions[_returnMessage] ~= nil) then
@@ -118,6 +114,9 @@ do
 				return returnValue
 			end),
 			setCallback = function(message, returnMessage, callback)
+				if RunService:IsClient() then
+					error(noServerListen)
+				end
 				return self.server.on(message, function(player, data)
 					local returnValue = callback(player, data)
 					self.client.emit(player, returnMessage, returnValue)
@@ -126,54 +125,34 @@ do
 		}
 		self.client = {
 			on = function(message, callback)
+				if RunService:IsServer() then
+					error(noClientListen)
+				end
 				return self:on(message, callback, self.clientCallbacks)
 			end,
 			once = function(message, callback)
+				if RunService:IsServer() then
+					error(noClientListen)
+				end
 				return self:once(message, callback, self.clientCallbacks)
 			end,
 			emit = function(player, message, data, unreliable)
 				if unreliable == nil then
 					unreliable = false
 				end
-				local updateData = function(newData)
-					data = newData
-					return nil
-				end
-				local getPacket = function()
-					return self:getPacket(message, data)
-				end
-				if not self:validateData(message, data) then
-					return nil
+				if RunService:IsClient() then
+					error("[@rbxts/tether]: Cannot emit message to client from client")
 				end
 				task.spawn(function()
-					local ctx = {
-						data = data,
-						updateData = updateData,
-						getRawData = getPacket,
-					}
-					for _, globalMiddleware in self.middleware:getClientGlobal() do
-						if not self:validateData(message, data) then
-							return nil
-						end
-						local result = globalMiddleware(message)(player, ctx)
-						if result == DropRequest then
-							return nil
-						end
-					end
-					for _, middleware in self.middleware:getClient(message) do
-						if not self:validateData(message, data) then
-							return nil
-						end
-						local result = middleware(message)(player, ctx)
-						if result == DropRequest then
-							return nil
-						end
-					end
-					if not self:validateData(message, data) then
+					local _binding = self:runClientMiddlewares(message, data)
+					local dropRequest = _binding[1]
+					local newData = _binding[2]
+					if dropRequest then
 						return nil
 					end
-					local send = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
-					send(player, getPacket())
+					local _clientQueue = self.clientQueue
+					local _arg0 = { player, message, newData, unreliable }
+					table.insert(_clientQueue, _arg0)
 				end)
 			end,
 			emitExcept = function(player, message, data, unreliable)
@@ -210,56 +189,28 @@ do
 				if unreliable == nil then
 					unreliable = false
 				end
-				local updateData = function(newData)
-					data = newData
-					return nil
-				end
-				local getPacket = function()
-					return self:getPacket(message, data)
-				end
-				if not self:validateData(message, data) then
-					return nil
+				if RunService:IsClient() then
+					error("[@rbxts/tether]: Cannot emit message to all clients from client")
 				end
 				task.spawn(function()
-					local ctx = {
-						data = data,
-						updateData = updateData,
-						getRawData = getPacket,
-					}
-					local players = Players:GetPlayers()
-					for _, globalMiddleware in self.middleware:getClientGlobal() do
-						for _1, player in players do
-							if not self:validateData(message, data) then
-								return nil
-							end
-							local result = globalMiddleware(message)(player, ctx)
-							if result == DropRequest then
-								return nil
-							end
-						end
-					end
-					for _, middleware in self.middleware:getClient(message) do
-						for _1, player in players do
-							if not self:validateData(message, data) then
-								return nil
-							end
-							local result = middleware(message)(player, ctx)
-							if result == DropRequest then
-								return nil
-							end
-						end
-					end
-					if not self:validateData(message, data) then
+					local _binding = self:runClientMiddlewares(message, data)
+					local dropRequest = _binding[1]
+					local newData = _binding[2]
+					if dropRequest then
 						return nil
 					end
-					local send = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
-					send:broadcast(getPacket())
+					local _clientBroadcastQueue = self.clientBroadcastQueue
+					local _arg0 = { message, newData, unreliable }
+					table.insert(_clientBroadcastQueue, _arg0)
 				end)
 			end,
 			invoke = TS.async(function(message, returnMessage, player, data, unreliable)
 				if unreliable == nil then
 					unreliable = false
 				end
+				if RunService:IsClient() then
+					error("[@rbxts/tether]: Cannot invoke client function from client")
+				end
 				local _serverFunctions = self.serverFunctions
 				local _returnMessage = returnMessage
 				if not (_serverFunctions[_returnMessage] ~= nil) then
@@ -282,6 +233,9 @@ do
 				return returnValue
 			end),
 			setCallback = function(message, returnMessage, callback)
+				if RunService:IsServer() then
+					error(noClientListen)
+				end
 				return self.client.on(message, function(data)
 					local returnValue = callback(data)
 					self.server.emit(returnMessage, returnValue)
@@ -347,8 +301,8 @@ do
 			})
 		end
 	end
-	function MessageEmitter:create(meta)
-		local emitter = MessageEmitter.new()
+	function MessageEmitter:create(options, meta)
+		local emitter = MessageEmitter.new(Object.assign({}, options, defaultMesssageEmitterOptions))
 		if meta == nil then
 			warn(metaGenerationFailed)
 			return emitter:initialize()
@@ -365,16 +319,6 @@ do
 		end
 		return emitter:initialize()
 	end
-	function MessageEmitter:validateData(message, data)
-		local _guards = self.guards
-		local _message = message
-		local guard = _guards[_message]
-		local guardPassed = guard(data)
-		if not guardPassed then
-			warn(guardFailed(message, data))
-		end
-		return guardPassed
-	end
 	function MessageEmitter:initialize()
 		if RunService:IsClient() then
 			self.janitor:Add(self.clientEvents.sendClientMessage:connect(function(serializedPacket)
@@ -391,8 +335,138 @@ do
 				return self:onRemoteFire(serializedPacket, player)
 			end))
 		end
+		local elapsed = 0
+		RunService.Heartbeat:Connect(function(dt)
+			elapsed += dt
+			if elapsed >= self.options.batchRate then
+				elapsed -= self.options.batchRate
+				self:update()
+			end
+		end)
 		return self
 	end
+	function MessageEmitter:update()
+		for _, _binding in self.clientQueue do
+			local player = _binding[1]
+			local message = _binding[2]
+			local data = _binding[3]
+			local unreliable = _binding[4]
+			local remote = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
+			remote(player, self:getPacket(message, data))
+		end
+		table.clear(self.clientQueue)
+		for _, _binding in self.clientBroadcastQueue do
+			local message = _binding[1]
+			local data = _binding[2]
+			local unreliable = _binding[3]
+			local remote = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
+			remote:broadcast(self:getPacket(message, data))
+		end
+		table.clear(self.clientBroadcastQueue)
+		for _, _binding in self.serverQueue do
+			local message = _binding[1]
+			local data = _binding[2]
+			local unreliable = _binding[3]
+			local remote = if unreliable then self.clientEvents.sendUnreliableServerMessage else self.clientEvents.sendServerMessage
+			remote(self:getPacket(message, data))
+		end
+		table.clear(self.serverQueue)
+	end
+	function MessageEmitter:runClientMiddlewares(message, data, player)
+		if not self:validateData(message, data) then
+			return { true, data }
+		end
+		local players = player or Players:GetPlayers()
+		local ctx = {
+			message = message,
+			data = data,
+			updateData = function(newData)
+				data = newData
+				return nil
+			end,
+			getRawData = function()
+				return self:getPacket(message, data)
+			end,
+		}
+		for _, globalMiddleware in self.middleware:getClientGlobal() do
+			local result = globalMiddleware(players, ctx)
+			if not self:validateData(message, data, "Invalid data after global client middleware") then
+				return { false, data }
+			end
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Global client middleware")
+				return { true, data }
+			end
+		end
+		for _, middleware in self.middleware:getClient(message) do
+			local result = middleware(players, ctx)
+			if not self:validateData(message, data, "Invalid data after client middleware") then
+				return { false, data }
+			end
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Client middleware")
+				return { true, data }
+			end
+		end
+		if not self:validateData(message, data) then
+			return { true, data }
+		end
+		return { false, data }
+	end
+	function MessageEmitter:runServerMiddlewares(message, data)
+		if not self:validateData(message, data) then
+			return { true, data }
+		end
+		local ctx = {
+			message = message,
+			data = data,
+			updateData = function(newData)
+				data = newData
+				return nil
+			end,
+			getRawData = function()
+				return self:getPacket(message, data)
+			end,
+		}
+		for _, globalMiddleware in self.middleware:getServerGlobal() do
+			if not self:validateData(message, data, "Invalid data after global server middleware") then
+				return { false, data }
+			end
+			local result = globalMiddleware(ctx)
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Global server middleware")
+				return { true, data }
+			end
+		end
+		for _, middleware in self.middleware:getServer(message) do
+			if not self:validateData(message, data, "Invalid data after server middleware") then
+				return { false, data }
+			end
+			local result = middleware(ctx)
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Server middleware")
+				return { true, data }
+			end
+		end
+		if not self:validateData(message, data) then
+			return { true, data }
+		end
+		return { false, data }
+	end
+	function MessageEmitter:validateData(message, data, requestDropReason)
+		if requestDropReason == nil then
+			requestDropReason = "Invalid data"
+		end
+		local _guards = self.guards
+		local _message = message
+		local guard = _guards[_message]
+		local guardPassed = guard(data)
+		if not guardPassed then
+			warn(guardFailed(message, data))
+			self.middleware:notifyRequestDropped(message, requestDropReason)
+		end
+		return guardPassed
+	end
 	function MessageEmitter:onRemoteFire(serializedPacket, player)
 		if buffer.len(serializedPacket.messageBuffer) > 1 then
 			return warn("[@rbxts/tether]: Rejected message because message buffer was larger than one byte")
@@ -409,12 +483,7 @@ do
 		if functions == nil then
 			return nil
 		end
-		local serializer = self:getSerializer(message)
-		local _packet = serializer
-		if _packet ~= nil then
-			_packet = _packet.deserialize(serializedPacket.buffer, serializedPacket.blobs)
-		end
-		local packet = _packet
+		local packet = self:deserializeAndValidate(message, serializedPacket)
 		for callback in functions do
 			callback(packet)
 		end
@@ -427,12 +496,7 @@ do
 		if callbacks == nil then
 			return nil
 		end
-		local serializer = self:getSerializer(message)
-		local _packet = serializer
-		if _packet ~= nil then
-			_packet = _packet.deserialize(serializedPacket.buffer, serializedPacket.blobs)
-		end
-		local packet = _packet
+		local packet = self:deserializeAndValidate(message, serializedPacket)
 		for callback in callbacks do
 			if isServer then
 				callback(player, packet)
@@ -441,6 +505,16 @@ do
 			end
 		end
 	end
+	function MessageEmitter:deserializeAndValidate(message, serializedPacket)
+		local serializer = self:getSerializer(message)
+		local _packet = serializer
+		if _packet ~= nil then
+			_packet = _packet.deserialize(serializedPacket.buffer, serializedPacket.blobs)
+		end
+		local packet = _packet
+		self:validateData(message, packet)
+		return packet
+	end
 	function MessageEmitter:once(message, callback, callbacksMap)
 		local destructor
 		destructor = self:on(message, function(player, data)

package/out/middleware.d.ts

@@ -5,22 +5,28 @@ type DropRequestSymbol = symbol & {
 export declare const DropRequest: DropRequestSymbol;
 export type ClientMiddleware<Data = unknown> = {
     _client?: void;
-} & ((message: BaseMessage) => (player: Player | Player[], ctx: MiddlewareContext<Data>) => DropRequestSymbol | void);
+} & ((player: Player | Player[], ctx: MiddlewareContext<Data>) => DropRequestSymbol | void);
 export type ServerMiddleware<Data = unknown> = {
     _server?: void;
 } & SharedMiddleware<Data>;
-export type SharedMiddleware<Data = unknown> = (message: BaseMessage) => (ctx: MiddlewareContext<Data>) => DropRequestSymbol | void;
+export type SharedMiddleware<Data = unknown> = (ctx: MiddlewareContext<Data>) => DropRequestSymbol | void;
 export type Middleware<Data = unknown> = ServerMiddleware<Data> & ClientMiddleware<Data> & SharedMiddleware<Data>;
-export interface MiddlewareContext<Data = unknown> {
+export interface MiddlewareContext<Data = unknown, Message extends BaseMessage = BaseMessage> {
+    readonly message: Message;
     readonly data: Readonly<Data>;
     updateData: (newData: Data) => void;
     getRawData: () => SerializedPacket;
 }
+type RequestDropCallback = (message: BaseMessage, reason?: string) => void;
 export declare class MiddlewareProvider<MessageData> {
     private readonly clientGlobalMiddlewares;
     private readonly serverGlobalMiddlewares;
     private readonly clientMiddlewares;
     private readonly serverMiddlewares;
+    private readonly requestDroppedCallbacks;
+    onRequestDropped(callback: RequestDropCallback): () => void;
+    /** @hidden */
+    notifyRequestDropped(message: BaseMessage, reason?: string): void;
     /** @hidden */
     getClient<Kind extends keyof MessageData>(message: Kind & BaseMessage): ClientMiddleware<MessageData[Kind]>[];
     /** @hidden */

package/out/middleware.luau

@@ -1,5 +1,6 @@
 -- Compiled with roblox-ts v3.0.0
 local DropRequest = newproxy()
+-- TODO: middlewares upon received message
 local MiddlewareProvider
 do
 	MiddlewareProvider = setmetatable({}, {
@@ -17,6 +18,26 @@ do
 		self.serverGlobalMiddlewares = {}
 		self.clientMiddlewares = {}
 		self.serverMiddlewares = {}
+		self.requestDroppedCallbacks = {}
+	end
+	function MiddlewareProvider:onRequestDropped(callback)
+		local _requestDroppedCallbacks = self.requestDroppedCallbacks
+		local _callback = callback
+		_requestDroppedCallbacks[_callback] = true
+		return function()
+			local _requestDroppedCallbacks_1 = self.requestDroppedCallbacks
+			local _callback_1 = callback
+			-- ▼ Set.delete ▼
+			local _valueExisted = _requestDroppedCallbacks_1[_callback_1] ~= nil
+			_requestDroppedCallbacks_1[_callback_1] = nil
+			-- ▲ Set.delete ▲
+			return _valueExisted
+		end
+	end
+	function MiddlewareProvider:notifyRequestDropped(message, reason)
+		for callback in self.requestDroppedCallbacks do
+			callback(message, reason)
+		end
 	end
 	function MiddlewareProvider:getClient(message)
 		if self.clientMiddlewares[message] == nil then
@@ -77,10 +98,8 @@ do
 		-- ▼ ReadonlyArray.map ▼
 		local _newValue = table.create(#_exp)
 		local _callback = function(middleware)
-			return function(message)
-				return function(_, ctx)
-					return middleware(message)(ctx)
-				end
+			return function(_, ctx)
+				return middleware(ctx)
 			end
 		end
 		for _k, _v in _exp do
@@ -89,8 +108,7 @@ do
 		-- ▲ ReadonlyArray.map ▲
 		local client = _newValue
 		self:useServer(message, server, order)
-		self:useClient(message, client, order)
-		return self
+		return self:useClient(message, client, order)
 	end
 	function MiddlewareProvider:useClientGlobal(middlewares, order)
 		local globalMiddleware = self:getClientGlobal()
@@ -132,10 +150,8 @@ do
 		-- ▼ ReadonlyArray.map ▼
 		local _newValue = table.create(#_exp)
 		local _callback = function(middleware)
-			return function(message)
-				return function(_, ctx)
-					return middleware(message)(ctx)
-				end
+			return function(_, ctx)
+				return middleware(ctx)
 			end
 		end
 		for _k, _v in _exp do
@@ -144,8 +160,7 @@ do
 		-- ▲ ReadonlyArray.map ▲
 		local client = _newValue
 		self:useClientGlobal(client, order)
-		self:useServerGlobal(middlewares, order)
-		return self
+		return self:useServerGlobal(middlewares, order)
 	end
 end
 return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",
@@ -42,6 +42,7 @@
     "@rbxts/destroyable": "^1.0.1",
     "@rbxts/flamework-binary-serializer": "^0.6.0",
     "@rbxts/flamework-meta-utils": "^1.0.4",
+    "@rbxts/object-utils": "^1.0.4",
     "@rbxts/repr": "^1.0.1",
     "@rbxts/services": "^1.5.5",
     "ts-toolbelt": "^9.6.0"