@rbxts/tether 1.0.3 → 1.0.5

package/README.md

@@ -3,42 +3,40 @@ A message-based networking solution for Roblox with automatic binary serializati
 
 ### In `shared/messaging.ts`
 ```ts
-import { DataType } from "@rbxts/flamework-binary-serializer";
+import type { DataType } from "@rbxts/flamework-binary-serializer";
+import { MessageEmitter } from "@rbxts/tether";
 
-export const messageEmitter = new MessageEmitter<Message, 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;
   };
 }
-
-messageEmitter.addSerializer<Message.TEST>(Message.TEST);
 ```
 
 > [!CAUTION]
-> Every single message kind must implement an interface for it's data (in the example that would be the object with the `foo` and `bar` fields) as well as call `MessageEmitter.addSerializer()`. Messages will not work if you don't do this.
+> Every single message kind must implement an interface for it's data (in the example that would be the object with the `foo` and `bar` fields). Message serialization (as well as your message itself) will not work if you don't do this.
 
 ### 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
 });

package/out/builtin-middlewares.d.ts

@@ -0,0 +1,4 @@
+import { Middleware } from "./middleware";
+export declare namespace BuiltinMiddlewares {
+    function rateLimit<Data>(interval: number): Middleware<Data>;
+}

package/out/builtin-middlewares.luau

@@ -0,0 +1,20 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local DropRequest = TS.import(script, script.Parent, "middleware").DropRequest
+local BuiltinMiddlewares = {}
+do
+	local _container = BuiltinMiddlewares
+	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
+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;
-/** @metadata macro */
-export declare function createMessageEmitter<MessageData>(metaForEachMessage?: Modding.Many<{
-    [Kind in keyof MessageData]: Modding.Many<SerializerMetadata<MessageData[Kind]>>;
-}>): MessageEmitter<MessageData> | undefined;
-declare class MessageEmitter<MessageData> {
-    private readonly clientCallbacks;
-    private readonly serverCallbacks;
-    private readonly serializers;
-    private readonly serverEvents;
-    private readonly clientEvents;
-    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 { MiddlewareProvider, DropRequest, type ClientMiddleware, type ServerMiddleware, type Middleware } from "./middleware";

package/out/init.luau

@@ -1,166 +1,9 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
-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()
---* @metadata macro 
-local MessageEmitter
-local function createMessageEmitter(metaForEachMessage)
-	if metaForEachMessage == nil then
-		return nil
-	end
-	local emitter = MessageEmitter.new()
-	for kind, meta in pairs(metaForEachMessage) do
-		emitter:addSerializer(kind, meta)
-	end
-end
-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({})
-		else
-			self.clientEvents = GlobalEvents:createClient({})
-		end
-	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[message]
-	end
-end
-return {
-	createMessageEmitter = createMessageEmitter,
-}
+local exports = {}
+exports.MessageEmitter = TS.import(script, script, "message-emitter").MessageEmitter
+exports.BuiltinMiddlewares = TS.import(script, script, "builtin-middlewares").BuiltinMiddlewares
+local _middleware = TS.import(script, script, "middleware")
+exports.MiddlewareProvider = _middleware.MiddlewareProvider
+exports.DropRequest = _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 {
+    private readonly middleware?;
+    private readonly clientCallbacks;
+    private readonly serverCallbacks;
+    private serializers;
+    private serverEvents;
+    private clientEvents;
+    /** @metadata macro */
+    static create<MessageData>(middleware?: MiddlewareProvider<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,244 @@
+-- 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 DropRequest = TS.import(script, script.Parent, "middleware").DropRequest
+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(middleware)
+		super.constructor(self)
+		self.middleware = middleware
+		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(middleware, metaForEachMessage)
+		local emitter = MessageEmitter.new(middleware)
+		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,18 @@
+type DropRequestSymbol = symbol & {
+    _skip_middleware?: undefined;
+};
+export declare const DropRequest: DropRequestSymbol;
+export type ClientMiddleware<Data = unknown> = (player: Player, data: Data | undefined) => DropRequestSymbol | void;
+export type ServerMiddleware<Data = unknown> = (data: Data | undefined) => 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;
+}
+export {};

package/out/middleware.luau

@@ -0,0 +1,77 @@
+-- Compiled with roblox-ts v3.0.0
+local function createSymbol(name)
+	local symbol = newproxy(true)
+	local mt = getmetatable(symbol)
+	mt.__tostring = function()
+		return name
+	end
+	return symbol
+end
+local DropRequest = createSymbol("DropRequest")
+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
+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.3",
+  "version": "1.0.5",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",
@@ -14,7 +14,7 @@
     "message"
   ],
   "repository": {
-    "url": "https://github.com/R-unic/tether.git"
+    "url": "git+https://github.com/R-unic/tether.git"
   },
   "author": "runicly",
   "license": "ISC",
@@ -30,12 +30,14 @@
   "devDependencies": {
     "@rbxts/compiler-types": "^3.0.0-types.0",
     "@rbxts/types": "^1.0.835",
+    "rbxts-transformer-flamework": "latest",
     "roblox-ts": "^3.0.0",
-    "typescript": "^5.7.3"
+    "typescript": "^5.5.3"
   },
   "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"
   }