@rbxts/tether 1.0.4 → 1.0.6

package/README.md

@@ -1,19 +1,21 @@
 # Tether
-A message-based networking solution for Roblox with automatic binary serialization
+A message-based networking solution for Roblox with automatic binary serialization.
+
+## Usage
 
 ### In `shared/messaging.ts`
 ```ts
 import type { DataType } from "@rbxts/flamework-binary-serializer";
+import { MessageEmitter } from "@rbxts/tether";
 
-export const messageEmitter = MessageEmitter.create<MessageData>();
-messageEmitter.initialize();
+export const messaging = MessageEmitter.create<MessageData>();
 
 export const enum Message {
-  TEST
+  Test
 }
 
 export interface MessageData {
-  [Message.TEST]: {
+  [Message.Test]: {
     readonly foo: string;
     readonly n: DataType.u8;
   };
@@ -25,19 +27,61 @@ export interface MessageData {
 
 ### Server
 ```ts
-import { Message, messageEmitter } from "shared/messaging";
+import { Message, messaging } from "shared/messaging";
 
-messageEmitter.onServerMessage(Message.TEST, (player, data) => {
+messaging.onServerMessage(Message.TEST, (player, data) => {
   print(player, "sent data:", data);
 });
 ```
 
 ### Client
 ```ts
-import { Message, messageEmitter } from "shared/messaging";
+import { Message, messaging } from "shared/messaging";
 
-messageEmitter.emitServer(Message.TEST, {
+messaging.emitServer(Message.TEST, {
   foo: "bar",
   n: 69
 });
+```
+
+## Middleware
+
+### Creating middleware
+```ts
+import { type Middleware, DropRequest } from "@rbxts/tether";
+
+export function rateLimit(interval: number): Middleware {
+  let lastRequest = 0;
+
+  return () => {
+    if (os.clock() - lastRequest < interval)
+      return DropRequest;
+
+    lastRequest = os.clock();
+  };
+}
+```
+
+### Using middleware
+```ts
+import type { DataType } from "@rbxts/flamework-binary-serializer";
+import { MessageEmitter, BuiltinMiddlewares } from "@rbxts/tether";
+
+export const messaging = MessageEmitter.create<MessageData>();
+messaging.middleware
+  .useUniversal(Message.Test, [BuiltinMiddlewares.rateLimit(5)]) // only allows requests every 5 seconds, drops any
+                                                                 // requests that occur within 5 seconds of each other
+  .useClient(Message.Test, [BuiltinMiddlewares.validateClient()]); // automatically validates that data sent through the remote
+                                                                   // matches the data associated with the message at runtime
+
+export const enum Message {
+  Test
+}
+
+export interface MessageData {
+  [Message.Test]: {
+    readonly foo: string;
+    readonly n: DataType.u8;
+  };
+}
 ```

package/out/builtin-middlewares.d.ts

@@ -0,0 +1,30 @@
+import { Modding } from "@flamework/core";
+import { type UniversalMiddleware, type ServerMiddleware, type ClientMiddleware } from "./middleware";
+type Guard<T> = (value: unknown) => value is T;
+export declare namespace BuiltinMiddlewares {
+    /**
+     * Creates a universal middleware that will drop any message that occurs within the given interval of the previous message.
+     * @param interval The interval in seconds that the middleware should wait before allowing a new request.
+     * @returns A middleware that will drop any message that occurs within the given interval.
+     */
+    function rateLimit(interval: number): UniversalMiddleware;
+    /**
+     * Creates a server middleware that validates the data with the given guard (or a generated guard if none was provided).
+     * If the guard fails, the middleware will drop the message.
+     *
+     * @param guard The guard to use to validate the data.
+     * @returns A server middleware that validates the data with the given guard.
+     * @macro
+     */
+    function validateServer<T>(guard?: Guard<T> | Modding.Generic<T, "guard">): ServerMiddleware<T>;
+    /**
+     * Creates a server middleware that validates the data with the given guard (or a generated guard if none was provided).
+     * If the guard fails, the middleware will drop the message.
+     *
+     * @param guard The guard to use to validate the data.
+     * @returns A server middleware that validates the data with the given guard.
+     * @macro
+     */
+    function validateClient<T>(guard?: Guard<T> | Modding.Generic<T, "guard">): ClientMiddleware<T>;
+}
+export {};

package/out/builtin-middlewares.luau

@@ -0,0 +1,77 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local DropRequest = TS.import(script, script.Parent, "middleware").DropRequest
+local noOp = function() end
+local validationGuardGenerationFailed = function(context)
+	return `[Tether]: Failed to generate guard for validate{context}<T> builtin middleware - skipping validation`
+end
+local BuiltinMiddlewares = {}
+do
+	local _container = BuiltinMiddlewares
+	--[[
+		*
+		     * Creates a universal middleware that will drop any message that occurs within the given interval of the previous message.
+		     * @param interval The interval in seconds that the middleware should wait before allowing a new request.
+		     * @returns A middleware that will drop any message that occurs within the given interval.
+		     
+	]]
+	local function rateLimit(interval)
+		local lastRequest = 0
+		return function()
+			if os.clock() - lastRequest < interval then
+				return DropRequest
+			end
+			lastRequest = os.clock()
+		end
+	end
+	_container.rateLimit = rateLimit
+	--[[
+		*
+		     * Creates a server middleware that validates the data with the given guard (or a generated guard if none was provided).
+		     * If the guard fails, the middleware will drop the message.
+		     *
+		     * @param guard The guard to use to validate the data.
+		     * @returns A server middleware that validates the data with the given guard.
+		     * @macro
+		     
+	]]
+	local function validateServer(guard)
+		if guard == nil then
+			warn(validationGuardGenerationFailed("Server"))
+			return noOp
+		end
+		return function(data)
+			if guard(data) then
+				return nil
+			end
+			return DropRequest
+		end
+	end
+	_container.validateServer = validateServer
+	--[[
+		*
+		     * Creates a server middleware that validates the data with the given guard (or a generated guard if none was provided).
+		     * If the guard fails, the middleware will drop the message.
+		     *
+		     * @param guard The guard to use to validate the data.
+		     * @returns A server middleware that validates the data with the given guard.
+		     * @macro
+		     
+	]]
+	local function validateClient(guard)
+		if guard == nil then
+			warn(validationGuardGenerationFailed("Client"))
+			return noOp
+		end
+		return function(data)
+			if guard(data) then
+				return nil
+			end
+			return DropRequest
+		end
+	end
+	_container.validateClient = validateClient
+end
+return {
+	BuiltinMiddlewares = BuiltinMiddlewares,
+}

package/out/index.d.ts

@@ -1,29 +1,3 @@
-import { Modding } from "@flamework/core";
-import { type SerializerMetadata } from "@rbxts/flamework-binary-serializer";
-type ClientMessageCallback<T = unknown> = (data: T) => void;
-type ServerMessageCallback<T = unknown> = (player: Player, data: T) => void;
-export declare class MessageEmitter<MessageData> {
-    private readonly clientCallbacks;
-    private readonly serverCallbacks;
-    private readonly serializers;
-    private readonly serverEvents;
-    private readonly clientEvents;
-    /** @metadata macro */
-    static create<MessageData>(metaForEachMessage?: Modding.Many<{
-        [Kind in keyof MessageData]: Modding.Many<SerializerMetadata<MessageData[Kind]>>;
-    }>): MessageEmitter<MessageData>;
-    private constructor();
-    /** @metadata macro */
-    addSerializer<Kind extends keyof MessageData>(message: Kind, meta?: Modding.Many<SerializerMetadata<MessageData[Kind]>>): void;
-    initialize(): RBXScriptConnection;
-    onServerMessage<Kind extends keyof MessageData>(message: Kind, callback: ServerMessageCallback<MessageData[Kind]>): () => void;
-    onClientMessage<Kind extends keyof MessageData>(message: Kind, callback: ClientMessageCallback<MessageData[Kind]>): () => void;
-    emitServer<Kind extends keyof MessageData>(message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
-    emitClient<Kind extends keyof MessageData>(player: Player, message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
-    emitAllClients<Kind extends keyof MessageData>(message: Kind, data: MessageData[Kind], unreliable?: boolean): void;
-    private getPacket;
-    /** @metadata macro */
-    private createMessageSerializer;
-    private getSerializer;
-}
-export {};
+export { MessageEmitter } from "./message-emitter";
+export { BuiltinMiddlewares } from "./builtin-middlewares";
+export { DropRequest, type ClientMiddleware, type ServerMiddleware, type Middleware } from "./middleware";

package/out/init.luau

@@ -1,212 +1,7 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
-local t = TS.import(script, TS.getModule(script, "@rbxts", "t").lib.ts).t
-local Networking = TS.import(script, TS.getModule(script, "@flamework", "networking").out).Networking
-local createBinarySerializer = TS.import(script, TS.getModule(script, "@rbxts", "flamework-binary-serializer").out).createBinarySerializer
-local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
-local GlobalEvents = Networking.createEvent("@rbxts/tether:init@GlobalEvents")
-local MessageEmitter
-do
-	MessageEmitter = setmetatable({}, {
-		__tostring = function()
-			return "MessageEmitter"
-		end,
-	})
-	MessageEmitter.__index = MessageEmitter
-	function MessageEmitter.new(...)
-		local self = setmetatable({}, MessageEmitter)
-		return self:constructor(...) or self
-	end
-	function MessageEmitter:constructor()
-		self.clientCallbacks = {}
-		self.serverCallbacks = {}
-		self.serializers = {}
-		if RunService:IsServer() then
-			self.serverEvents = GlobalEvents:createServer({}, {
-				incomingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
-				incoming = {
-					sendServerMessage = { { t.union(t.string, t.number), t.interface({
-						buffer = t.typeof("buffer"),
-						blobs = t.array(t.any),
-					}) }, nil },
-					sendUnreliableServerMessage = { { t.union(t.string, t.number), t.interface({
-						buffer = t.typeof("buffer"),
-						blobs = t.array(t.any),
-					}) }, nil },
-				},
-				incomingUnreliable = {
-					sendUnreliableServerMessage = true,
-				},
-				outgoingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
-				outgoingUnreliable = {
-					sendUnreliableClientMessage = true,
-				},
-				namespaceIds = {},
-				namespaces = {},
-			})
-		else
-			self.clientEvents = GlobalEvents:createClient({}, {
-				incomingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
-				incoming = {
-					sendClientMessage = { { t.union(t.string, t.number), t.interface({
-						buffer = t.typeof("buffer"),
-						blobs = t.array(t.any),
-					}) }, nil },
-					sendUnreliableClientMessage = { { t.union(t.string, t.number), t.interface({
-						buffer = t.typeof("buffer"),
-						blobs = t.array(t.any),
-					}) }, nil },
-				},
-				incomingUnreliable = {
-					sendUnreliableClientMessage = true,
-				},
-				outgoingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
-				outgoingUnreliable = {
-					sendUnreliableServerMessage = true,
-				},
-				namespaceIds = {},
-				namespaces = {},
-			})
-		end
-	end
-	function MessageEmitter:create(metaForEachMessage)
-		if metaForEachMessage == nil then
-			warn("[Tether]: Failed to generate serializer metadata for MessageEmitter")
-		end
-		local emitter = MessageEmitter.new()
-		if metaForEachMessage == nil then
-			return emitter
-		end
-		for kind, meta in pairs(metaForEachMessage) do
-			emitter:addSerializer(kind, meta)
-		end
-		return emitter
-	end
-	function MessageEmitter:addSerializer(message, meta)
-		self.serializers[message] = self:createMessageSerializer(meta)
-	end
-	function MessageEmitter:initialize()
-		if RunService:IsClient() then
-			return self.clientEvents.sendClientMessage:connect(function(sentMessage, _param)
-				local buffer = _param.buffer
-				local blobs = _param.blobs
-				local _clientCallbacks = self.clientCallbacks
-				local _sentMessage = sentMessage
-				local _condition = _clientCallbacks[_sentMessage]
-				if _condition == nil then
-					_condition = {}
-				end
-				local messageCallbacks = _condition
-				if #messageCallbacks == 0 then
-					return nil
-				end
-				local serializer = self:getSerializer(sentMessage)
-				local data = serializer.deserialize(buffer, blobs)
-				for _, callback in messageCallbacks do
-					callback(data)
-				end
-			end)
-		else
-			return self.serverEvents.sendServerMessage:connect(function(player, sentMessage, _param)
-				local buffer = _param.buffer
-				local blobs = _param.blobs
-				local _serverCallbacks = self.serverCallbacks
-				local _sentMessage = sentMessage
-				local _condition = _serverCallbacks[_sentMessage]
-				if _condition == nil then
-					_condition = {}
-				end
-				local messageCallbacks = _condition
-				if #messageCallbacks == 0 then
-					return nil
-				end
-				local serializer = self:getSerializer(sentMessage)
-				local data = serializer.deserialize(buffer, blobs)
-				for _, callback in messageCallbacks do
-					callback(player, data)
-				end
-			end)
-		end
-	end
-	function MessageEmitter:onServerMessage(message, callback)
-		local _serverCallbacks = self.serverCallbacks
-		local _message = message
-		if not (_serverCallbacks[_message] ~= nil) then
-			local _serverCallbacks_1 = self.serverCallbacks
-			local _message_1 = message
-			_serverCallbacks_1[_message_1] = {}
-		end
-		local _serverCallbacks_1 = self.serverCallbacks
-		local _message_1 = message
-		local callbacks = _serverCallbacks_1[_message_1]
-		local _callback = callback
-		table.insert(callbacks, _callback)
-		local _serverCallbacks_2 = self.serverCallbacks
-		local _message_2 = message
-		_serverCallbacks_2[_message_2] = callbacks
-		return function()
-			local _callback_1 = callback
-			local _arg0 = (table.find(callbacks, _callback_1) or 0) - 1
-			return table.remove(callbacks, _arg0 + 1)
-		end
-	end
-	function MessageEmitter:onClientMessage(message, callback)
-		local _clientCallbacks = self.clientCallbacks
-		local _message = message
-		if not (_clientCallbacks[_message] ~= nil) then
-			local _clientCallbacks_1 = self.clientCallbacks
-			local _message_1 = message
-			_clientCallbacks_1[_message_1] = {}
-		end
-		local _clientCallbacks_1 = self.clientCallbacks
-		local _message_1 = message
-		local callbacks = _clientCallbacks_1[_message_1]
-		local _callback = callback
-		table.insert(callbacks, _callback)
-		local _clientCallbacks_2 = self.clientCallbacks
-		local _message_2 = message
-		_clientCallbacks_2[_message_2] = callbacks
-		return function()
-			local _callback_1 = callback
-			local _arg0 = (table.find(callbacks, _callback_1) or 0) - 1
-			return table.remove(callbacks, _arg0 + 1)
-		end
-	end
-	function MessageEmitter:emitServer(message, data, unreliable)
-		if unreliable == nil then
-			unreliable = false
-		end
-		local send = if unreliable then self.clientEvents.sendUnreliableServerMessage else self.clientEvents.sendServerMessage
-		send(message, self:getPacket(message, data))
-	end
-	function MessageEmitter:emitClient(player, message, data, unreliable)
-		if unreliable == nil then
-			unreliable = false
-		end
-		local send = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
-		send(player, message, self:getPacket(message, data))
-	end
-	function MessageEmitter:emitAllClients(message, data, unreliable)
-		if unreliable == nil then
-			unreliable = false
-		end
-		local send = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
-		send:broadcast(message, self:getPacket(message, data))
-	end
-	function MessageEmitter:getPacket(message, data, unreliable)
-		if unreliable == nil then
-			unreliable = false
-		end
-		local serializer = self:getSerializer(message)
-		return serializer.serialize(data)
-	end
-	function MessageEmitter:createMessageSerializer(meta)
-		return createBinarySerializer(meta)
-	end
-	function MessageEmitter:getSerializer(message)
-		return self.serializers[tostring(message)]
-	end
-end
-return {
-	MessageEmitter = MessageEmitter,
-}
+local exports = {}
+exports.MessageEmitter = TS.import(script, script, "message-emitter").MessageEmitter
+exports.BuiltinMiddlewares = TS.import(script, script, "builtin-middlewares").BuiltinMiddlewares
+exports.DropRequest = TS.import(script, script, "middleware").DropRequest
+return exports

package/out/message-emitter.d.ts

@@ -0,0 +1,59 @@
+import { Modding } from "@flamework/core";
+import { type SerializerMetadata } from "@rbxts/flamework-binary-serializer";
+import Destroyable from "@rbxts/destroyable";
+import { MiddlewareProvider } from "./middleware";
+import type { ClientMessageCallback, ServerMessageCallback } from "./structs";
+export declare class MessageEmitter<MessageData> extends Destroyable {
+    readonly middleware: MiddlewareProvider<MessageData>;
+    private readonly clientCallbacks;
+    private readonly serverCallbacks;
+    private serializers;
+    private serverEvents;
+    private clientEvents;
+    /** @metadata macro */
+    static create<MessageData>(metaForEachMessage?: Modding.Many<{
+        [Kind in keyof MessageData]: MessageData[Kind] extends undefined ? undefined : Modding.Many<SerializerMetadata<MessageData[Kind]>>;
+    }>): MessageEmitter<MessageData>;
+    private constructor();
+    /**.
+     * @returns A destructor function that disconnects the callback from the message.
+     */
+    onServerMessage<Kind extends keyof MessageData>(message: Kind, callback: ServerMessageCallback<MessageData[Kind]>): () => void;
+    /**.
+     * @returns A destructor function that disconnects the callback from the message.
+     */
+    onClientMessage<Kind extends keyof MessageData>(message: Kind, callback: ClientMessageCallback<MessageData[Kind]>): () => void;
+    private on;
+    /**
+     * Emits a message to all connected clients.
+     *
+     * @param message - The message kind to be sent.
+     * @param data - The data associated with the message.
+     * @param unreliable - Optional flag indicating if the message should be sent unreliably.
+     */
+    emitServer<Kind extends keyof MessageData>(message: Kind, data?: MessageData[Kind], unreliable?: boolean): void;
+    /**
+     * Emits a message to a specific client.
+     *
+     * @param player - The player to whom the message is sent.
+     * @param message - The message kind to be sent.
+     * @param data - The data associated with the message.
+     * @param unreliable - Optional flag indicating if the message should be sent unreliably.
+     */
+    emitClient<Kind extends keyof MessageData>(player: Player, message: Kind, data?: MessageData[Kind], unreliable?: boolean): void;
+    /**
+     * Emits a message to all connected clients.
+     *
+     * @param message - The message kind to be sent.
+     * @param data - The data associated with the message.
+     * @param unreliable - Optional flag indicating if the message should be sent unreliably.
+     */
+    emitAllClients<Kind extends keyof MessageData>(message: Kind, data?: MessageData[Kind], unreliable?: boolean): void;
+    private initialize;
+    private getPacket;
+    /** @metadata macro */
+    private addSerializer;
+    /** @metadata macro */
+    private createMessageSerializer;
+    private getSerializer;
+}

package/out/message-emitter.luau

@@ -0,0 +1,246 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local t = TS.import(script, TS.getModule(script, "@rbxts", "t").lib.ts).t
+local Networking = TS.import(script, TS.getModule(script, "@flamework", "networking").out).Networking
+local createBinarySerializer = TS.import(script, TS.getModule(script, "@rbxts", "flamework-binary-serializer").out).createBinarySerializer
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local Players = _services.Players
+local RunService = _services.RunService
+local Destroyable = TS.import(script, TS.getModule(script, "@rbxts", "destroyable").out).default
+local _middleware = TS.import(script, script.Parent, "middleware")
+local DropRequest = _middleware.DropRequest
+local MiddlewareProvider = _middleware.MiddlewareProvider
+local GlobalEvents = Networking.createEvent("@rbxts/tether:message-emitter@GlobalEvents")
+local MessageEmitter
+do
+	local super = Destroyable
+	MessageEmitter = setmetatable({}, {
+		__tostring = function()
+			return "MessageEmitter"
+		end,
+		__index = super,
+	})
+	MessageEmitter.__index = MessageEmitter
+	function MessageEmitter.new(...)
+		local self = setmetatable({}, MessageEmitter)
+		return self:constructor(...) or self
+	end
+	function MessageEmitter:constructor()
+		super.constructor(self)
+		self.middleware = MiddlewareProvider.new()
+		self.clientCallbacks = {}
+		self.serverCallbacks = {}
+		self.serializers = {}
+		self.janitor:Add(function()
+			table.clear(self.clientCallbacks)
+			table.clear(self.serverCallbacks)
+			self.serializers = nil
+			self.serverEvents = nil
+			self.clientEvents = nil
+		end)
+		if RunService:IsServer() then
+			self.serverEvents = GlobalEvents:createServer({}, {
+				incomingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
+				incoming = {
+					sendServerMessage = { { t.union(t.string, t.number), t.optional(t.interface({
+						buffer = t.typeof("buffer"),
+						blobs = t.array(t.any),
+					})) }, nil },
+					sendUnreliableServerMessage = { { t.union(t.string, t.number), t.optional(t.interface({
+						buffer = t.typeof("buffer"),
+						blobs = t.array(t.any),
+					})) }, nil },
+				},
+				incomingUnreliable = {
+					sendUnreliableServerMessage = true,
+				},
+				outgoingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
+				outgoingUnreliable = {
+					sendUnreliableClientMessage = true,
+				},
+				namespaceIds = {},
+				namespaces = {},
+			})
+		else
+			self.clientEvents = GlobalEvents:createClient({}, {
+				incomingIds = { "sendClientMessage", "sendUnreliableClientMessage" },
+				incoming = {
+					sendClientMessage = { { t.union(t.string, t.number), t.optional(t.interface({
+						buffer = t.typeof("buffer"),
+						blobs = t.array(t.any),
+					})) }, nil },
+					sendUnreliableClientMessage = { { t.union(t.string, t.number), t.optional(t.interface({
+						buffer = t.typeof("buffer"),
+						blobs = t.array(t.any),
+					})) }, nil },
+				},
+				incomingUnreliable = {
+					sendUnreliableClientMessage = true,
+				},
+				outgoingIds = { "sendServerMessage", "sendUnreliableServerMessage" },
+				outgoingUnreliable = {
+					sendUnreliableServerMessage = true,
+				},
+				namespaceIds = {},
+				namespaces = {},
+			})
+		end
+	end
+	function MessageEmitter:create(metaForEachMessage)
+		local emitter = MessageEmitter.new()
+		if metaForEachMessage == nil then
+			warn("[Tether]: Failed to generate serializer metadata for MessageEmitter")
+			return emitter:initialize()
+		end
+		for kind, meta in pairs(metaForEachMessage) do
+			if meta == nil then
+				continue
+			end
+			emitter:addSerializer(kind, meta)
+		end
+		return emitter:initialize()
+	end
+	function MessageEmitter:onServerMessage(message, callback)
+		return self:on(message, callback)
+	end
+	function MessageEmitter:onClientMessage(message, callback)
+		return self:on(message, callback)
+	end
+	function MessageEmitter:on(message, callback)
+		local callbacksMap = if RunService:IsServer() then self.serverCallbacks else self.clientCallbacks
+		local _message = message
+		if not (callbacksMap[_message] ~= nil) then
+			local _message_1 = message
+			callbacksMap[_message_1] = {}
+		end
+		local _message_1 = message
+		local callbacks = callbacksMap[_message_1]
+		local _callback = callback
+		callbacks[_callback] = true
+		local _message_2 = message
+		callbacksMap[_message_2] = callbacks
+		return function()
+			local _callback_1 = callback
+			-- ▼ Set.delete ▼
+			local _valueExisted = callbacks[_callback_1] ~= nil
+			callbacks[_callback_1] = nil
+			-- ▲ Set.delete ▲
+			return _valueExisted
+		end
+	end
+	function MessageEmitter:emitServer(message, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if self.middleware ~= nil then
+			for _, middleware in self.middleware:getServer(message) do
+				local result = middleware(data)
+				if result == DropRequest then
+					return nil
+				end
+			end
+		end
+		local send = if unreliable then self.clientEvents.sendUnreliableServerMessage else self.clientEvents.sendServerMessage
+		send(message, self:getPacket(message, data))
+	end
+	function MessageEmitter:emitClient(player, message, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if self.middleware ~= nil then
+			for _, middleware in self.middleware:getClient(message) do
+				local result = middleware(player, data)
+				if result == DropRequest then
+					return nil
+				end
+			end
+		end
+		local send = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
+		send(player, message, self:getPacket(message, data))
+	end
+	function MessageEmitter:emitAllClients(message, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if self.middleware ~= nil then
+			for _, middleware in self.middleware:getClient(message) do
+				for _1, player in Players:GetPlayers() do
+					local result = middleware(player, data)
+					if result == DropRequest then
+						return nil
+					end
+				end
+			end
+		end
+		local send = if unreliable then self.serverEvents.sendUnreliableClientMessage else self.serverEvents.sendClientMessage
+		send:broadcast(message, self:getPacket(message, data))
+	end
+	function MessageEmitter:initialize()
+		if RunService:IsClient() then
+			self.janitor:Add(self.clientEvents.sendClientMessage:connect(function(sentMessage, packet)
+				local _clientCallbacks = self.clientCallbacks
+				local _sentMessage = sentMessage
+				local _condition = _clientCallbacks[_sentMessage]
+				if _condition == nil then
+					_condition = {}
+				end
+				local messageCallbacks = _condition
+				-- ▼ ReadonlySet.size ▼
+				local _size = 0
+				for _ in messageCallbacks do
+					_size += 1
+				end
+				-- ▲ ReadonlySet.size ▲
+				if _size == 0 then
+					return nil
+				end
+				local serializer = self:getSerializer(sentMessage)
+				local data = if packet ~= nil then serializer.deserialize(packet.buffer, packet.blobs) else nil
+				for callback in messageCallbacks do
+					callback(data)
+				end
+			end))
+		else
+			self.janitor:Add(self.serverEvents.sendServerMessage:connect(function(player, sentMessage, packet)
+				local _serverCallbacks = self.serverCallbacks
+				local _sentMessage = sentMessage
+				local _condition = _serverCallbacks[_sentMessage]
+				if _condition == nil then
+					_condition = {}
+				end
+				local messageCallbacks = _condition
+				-- ▼ ReadonlySet.size ▼
+				local _size = 0
+				for _ in messageCallbacks do
+					_size += 1
+				end
+				-- ▲ ReadonlySet.size ▲
+				if _size == 0 then
+					return nil
+				end
+				local serializer = self:getSerializer(sentMessage)
+				local data = if packet ~= nil then serializer.deserialize(packet.buffer, packet.blobs) else nil
+				for callback in messageCallbacks do
+					callback(player, data)
+				end
+			end))
+		end
+		return self
+	end
+	function MessageEmitter:getPacket(message, data)
+		local serializer = self:getSerializer(message)
+		return if data == nil then nil else serializer.serialize(data)
+	end
+	function MessageEmitter:addSerializer(message, meta)
+		self.serializers[message] = self:createMessageSerializer(meta)
+	end
+	function MessageEmitter:createMessageSerializer(meta)
+		return createBinarySerializer(meta)
+	end
+	function MessageEmitter:getSerializer(message)
+		return self.serializers[tostring(message)]
+	end
+end
+return {
+	MessageEmitter = MessageEmitter,
+}

package/out/middleware.d.ts

@@ -0,0 +1,20 @@
+type DropRequestSymbol = symbol & {
+    _skip_middleware?: undefined;
+};
+export declare const DropRequest: DropRequestSymbol;
+export type ClientMiddleware<Data = unknown> = (player: Player, data: Readonly<Data> | undefined) => DropRequestSymbol | void;
+export type ServerMiddleware<Data = unknown> = (data: Readonly<Data> | undefined) => DropRequestSymbol | void;
+export type UniversalMiddleware = () => DropRequestSymbol | void;
+export type Middleware<Data = unknown> = ServerMiddleware<Data> & ClientMiddleware<Data>;
+export declare class MiddlewareProvider<MessageData> {
+    private readonly clientMiddlewares;
+    private readonly serverMiddlewares;
+    /** @hidden */
+    getClient<Kind extends keyof MessageData>(message: Kind): ClientMiddleware<MessageData[Kind]>[];
+    /** @hidden */
+    getServer<Kind extends keyof MessageData>(message: Kind): ServerMiddleware<MessageData[Kind]>[];
+    useClient<Kind extends keyof MessageData>(message: Kind, middlewares: ClientMiddleware<MessageData[Kind]> | ClientMiddleware<MessageData[Kind]>[], order?: number): this;
+    useServer<Kind extends keyof MessageData>(message: Kind, middlewares: ServerMiddleware<MessageData[Kind]> | ServerMiddleware<MessageData[Kind]>[], order?: number): this;
+    useUniversal<Kind extends keyof MessageData>(message: Kind, middlewares: UniversalMiddleware | UniversalMiddleware[], order?: number): this;
+}
+export {};

package/out/middleware.luau

@@ -0,0 +1,74 @@
+-- Compiled with roblox-ts v3.0.0
+local DropRequest = newproxy()
+local MiddlewareProvider
+do
+	MiddlewareProvider = setmetatable({}, {
+		__tostring = function()
+			return "MiddlewareProvider"
+		end,
+	})
+	MiddlewareProvider.__index = MiddlewareProvider
+	function MiddlewareProvider.new(...)
+		local self = setmetatable({}, MiddlewareProvider)
+		return self:constructor(...) or self
+	end
+	function MiddlewareProvider:constructor()
+		self.clientMiddlewares = {}
+		self.serverMiddlewares = {}
+	end
+	function MiddlewareProvider:getClient(message)
+		if self.clientMiddlewares[message] == nil then
+			self.clientMiddlewares[message] = {}
+		end
+		return self.clientMiddlewares[message]
+	end
+	function MiddlewareProvider:getServer(message)
+		if self.serverMiddlewares[message] == nil then
+			self.serverMiddlewares[message] = {}
+		end
+		return self.serverMiddlewares[message]
+	end
+	function MiddlewareProvider:useClient(message, middlewares, order)
+		local messageMiddleware = self:getClient(message)
+		local _middlewares = middlewares
+		if typeof(_middlewares) == "function" then
+			local _condition = order
+			if _condition == nil then
+				_condition = #messageMiddleware - 1
+			end
+			local _middlewares_1 = middlewares
+			table.insert(messageMiddleware, _condition + 1, _middlewares_1)
+		else
+			for _, middleware in middlewares do
+				self:useClient(message, middleware)
+			end
+		end
+		return self
+	end
+	function MiddlewareProvider:useServer(message, middlewares, order)
+		local messageMiddleware = self:getServer(message)
+		local _middlewares = middlewares
+		if typeof(_middlewares) == "function" then
+			local _condition = order
+			if _condition == nil then
+				_condition = #messageMiddleware - 1
+			end
+			local _middlewares_1 = middlewares
+			table.insert(messageMiddleware, _condition + 1, _middlewares_1)
+		else
+			for _, middleware in middlewares do
+				self:useServer(message, middleware)
+			end
+		end
+		return self
+	end
+	function MiddlewareProvider:useUniversal(message, middlewares, order)
+		self:useClient(message, middlewares, order)
+		self:useServer(message, middlewares, order)
+		return self
+	end
+end
+return {
+	DropRequest = DropRequest,
+	MiddlewareProvider = MiddlewareProvider,
+}

package/out/structs.d.ts

@@ -0,0 +1,19 @@
+import type { Networking } from "@flamework/networking";
+export type MessageCallback<T = unknown> = ServerMessageCallback<T> | ClientMessageCallback<T>;
+export type ClientMessageCallback<T = unknown> = (data: T) => void;
+export type ServerMessageCallback<T = unknown> = (player: Player, data: T) => void;
+export type BaseMessage = number | string | symbol;
+export interface SerializedPacket {
+    readonly buffer: buffer;
+    readonly blobs: defined[];
+}
+export type MessageEvent = (kind: BaseMessage, packet?: SerializedPacket) => void;
+export type UnreliableMessageEvent = Networking.Unreliable<MessageEvent>;
+export interface ServerEvents {
+    sendServerMessage: MessageEvent;
+    sendUnreliableServerMessage: UnreliableMessageEvent;
+}
+export interface ClientEvents {
+    sendClientMessage: MessageEvent;
+    sendUnreliableClientMessage: UnreliableMessageEvent;
+}

package/out/structs.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",
@@ -37,6 +37,7 @@
   "dependencies": {
     "@flamework/core": "^1.2.3",
     "@flamework/networking": "^1.2.3",
+    "@rbxts/destroyable": "^1.0.1",
     "@rbxts/flamework-binary-serializer": "^0.6.0",
     "@rbxts/services": "^1.5.5"
   }