@rbxts/tether 1.4.0 → 1.4.1

package/README.md

@@ -64,7 +64,7 @@ messaging.server.emit(Message.Test, {
 });
 ```
 
-## Simulated Remote Functions
+## Function Messages
 
 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.
 

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

@@ -0,0 +1,49 @@
+import { ContextualEmitter } from "./contextual-emitter";
+import type { BaseMessage, ClientMessageCallback, ClientFunctionMessageCallback } from "../structs";
+export declare class ClientEmitter<MessageData> extends ContextualEmitter<MessageData> {
+    readonly context = "client";
+    readonly on: <K extends keyof MessageData>(this: ClientEmitter<MessageData>, message: K & BaseMessage, callback: ClientMessageCallback<MessageData[K]>) => () => void;
+    readonly once: <K extends keyof MessageData>(this: ClientEmitter<MessageData>, message: K & BaseMessage, callback: ClientMessageCallback<MessageData[K]>) => () => void;
+    /**
+     * Emits a message to a specific client or multiple clients
+     *
+     * @param player The player(s) to whom the message is sent
+     * @param message The message kind to be sent
+     * @param data The data associated with the message
+     * @param unreliable Whether the message should be sent unreliably
+     */
+    emit<K extends keyof MessageData>(player: Player | Player[], message: K & BaseMessage, data?: MessageData[K], unreliable?: boolean): void;
+    /**
+     * Emits a message to all clients except the specified client(s)
+     *
+     * @param player The player(s) to whom the message is not sent
+     * @param message The message kind to be sent
+     * @param data The data associated with the message
+     * @param unreliable Whether the message should be sent unreliably
+     */
+    emitExcept<K extends keyof MessageData>(player: Player | Player[], message: K & BaseMessage, data?: MessageData[K], 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 Whether the message should be sent unreliably
+   */
+    emitAll<K extends keyof MessageData>(message: K & BaseMessage, data?: MessageData[K], unreliable?: boolean): void;
+    /**
+     * Sets a callback for a simulated remote function
+     *
+     * @returns A destructor function that disconnects the callback from the message
+     */
+    setCallback<K extends keyof MessageData, R extends keyof MessageData>(message: K & BaseMessage, returnMessage: R & BaseMessage, callback: ClientFunctionMessageCallback<MessageData[K], MessageData[R]>): () => void;
+    /**
+     * Simulates a remote function invocation
+     *
+     * @param message The message kind to be sent
+     * @param returnMessage The message kind to be returned
+     * @param player The player to whom the function is sent
+     * @param data The data associated with the message
+     * @param unreliable Whether the message should be sent unreliably
+     */
+    invoke<K extends keyof MessageData, R extends keyof MessageData>(message: K & BaseMessage, returnMessage: R & BaseMessage, player: Player, data?: MessageData[K], unreliable?: boolean): Promise<MessageData[R]>;
+}

package/out/emitters/client-emitter.luau

@@ -0,0 +1,153 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local Players = _services.Players
+local RunService = _services.RunService
+local ContextualEmitter = TS.import(script, script.Parent, "contextual-emitter").ContextualEmitter
+local ClientEmitter
+do
+	local super = ContextualEmitter
+	ClientEmitter = setmetatable({}, {
+		__tostring = function()
+			return "ClientEmitter"
+		end,
+		__index = super,
+	})
+	ClientEmitter.__index = ClientEmitter
+	function ClientEmitter.new(...)
+		local self = setmetatable({}, ClientEmitter)
+		return self:constructor(...) or self
+	end
+	function ClientEmitter:constructor(...)
+		super.constructor(self, ...)
+		self.context = "client"
+	end
+	function ClientEmitter:emit(player, message, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if RunService:IsClient() then
+			error("[tether::error] Cannot emit message from client to client")
+		end
+		task.spawn(function()
+			local _binding = self.master:runClientMiddlewares(message, data, player)
+			local dropRequest = _binding[1]
+			local newData = _binding[2]
+			if dropRequest then
+				return nil
+			end
+			self.master:queueMessage(self.context, message, { player, message, newData, unreliable })
+		end)
+	end
+	function ClientEmitter:emitExcept(player, message, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		local shouldSendTo = function(p)
+			local _player = player
+			local _result
+			if typeof(_player) == "Instance" then
+				_result = p ~= player
+			else
+				local _player_1 = player
+				local _p = p
+				_result = not (table.find(_player_1, _p) ~= nil)
+			end
+			return _result
+		end
+		local _self = self
+		local _exp = Players:GetPlayers()
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _length = 0
+		for _k, _v in _exp do
+			if shouldSendTo(_v, _k - 1, _exp) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		_self:emit(_newValue, message, data, unreliable)
+	end
+	function ClientEmitter:emitAll(message, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if RunService:IsClient() then
+			error("[tether::error] Cannot emit message from client to all clients")
+		end
+		task.spawn(function()
+			local _binding = self.master:runClientMiddlewares(message, data)
+			local dropRequest = _binding[1]
+			local newData = _binding[2]
+			if dropRequest then
+				return nil
+			end
+			self.master:queueMessage(true, message, { message, newData, unreliable })
+		end)
+	end
+	function ClientEmitter:setCallback(message, returnMessage, callback)
+		if RunService:IsServer() then
+			error("[tether::error] Cannot listen to server message from client")
+		end
+		return self:on(message, function(data)
+			local returnValue = callback(data)
+			-- Defer the response emission to end of frame and swap context to avoid context check issues
+			-- task.defer guarantees response is sent by end of current frame, ensuring predictable timing in production
+			task.defer(function()
+				setLuneContext("client")
+				self.master.server:emit(returnMessage, returnValue)
+				setLuneContext("both")
+			end)
+		end)
+	end
+	function ClientEmitter:invoke(message, returnMessage, player, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if RunService:IsClient() then
+			error("[tether::error] Cannot invoke function from client to client")
+		end
+		local _binding = self.master
+		local serverFunctions = _binding.serverFunctions
+		local _returnMessage = returnMessage
+		if not (serverFunctions[_returnMessage] ~= nil) then
+			local _returnMessage_1 = returnMessage
+			serverFunctions[_returnMessage_1] = {}
+		end
+		local _returnMessage_1 = returnMessage
+		local functions = serverFunctions[_returnMessage_1]
+		local returnValue
+		local responseCallback = function(data)
+			returnValue = data
+			return returnValue
+		end
+		functions[responseCallback] = true
+		self:emit(player, message, data, unreliable)
+		return TS.Promise.new(function(resolve, reject)
+			-- awful
+			local frames = 0
+			while true do
+				local _condition = returnValue == nil
+				if _condition then
+					local _original = frames
+					frames += 1
+					_condition = _original < 400
+				end
+				if not _condition then
+					break
+				end
+				RunService.Heartbeat:Wait()
+			end
+			if frames == 400 then
+				return reject("[tether::error] Client function timed out (no response)")
+			end
+			-- clean up the callback after receiving the response
+			functions[responseCallback] = nil
+			resolve(returnValue)
+		end)
+	end
+end
+return {
+	ClientEmitter = ClientEmitter,
+}

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

@@ -0,0 +1,26 @@
+import type { MessageEmitter } from "./message-emitter";
+import type { BaseMessage, MessageCallback, FunctionMessageCallback } from "../structs";
+type Cleanup = () => void;
+export declare abstract class ContextualEmitter<MessageData> {
+    protected readonly master: MessageEmitter<MessageData>;
+    abstract readonly context: "client" | "server";
+    /**
+     * Constructs a new ContextualEmitter.
+     * @param master The master emitter to which messages are delegated.
+     */
+    constructor(master: MessageEmitter<MessageData>);
+    abstract emit<K extends keyof MessageData>(player: (K & BaseMessage) | (Player | Player[]), message?: MessageData[K] | (K & BaseMessage), data?: MessageData[K] | boolean, unreliable?: boolean): void;
+    abstract setCallback<K extends keyof MessageData, R extends keyof MessageData>(message: K & BaseMessage, returnMessage: R & BaseMessage, callback: FunctionMessageCallback<MessageData[K], MessageData[R]>): Cleanup;
+    abstract invoke<K extends keyof MessageData, R extends keyof MessageData>(message: K & BaseMessage, returnMessage: R & BaseMessage, player?: Player | MessageData[K], data?: MessageData[K] | boolean, unreliable?: boolean): Promise<MessageData[R]>;
+    /**
+     * @returns A destructor function that disconnects the callback from the message
+     */
+    on<K extends keyof MessageData>(message: K & BaseMessage, callback: MessageCallback<MessageData[K]>): Cleanup;
+    /**
+     * Disconnects the callback as soon as it is called for the first time
+     *
+     * @returns A destructor function that disconnects the callback from the message
+     */
+    once<K extends keyof MessageData>(message: K & BaseMessage, callback: MessageCallback<MessageData[K]>): Cleanup;
+}
+export {};

package/out/emitters/contextual-emitter.luau

@@ -0,0 +1,49 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local ContextualEmitter
+do
+	ContextualEmitter = {}
+	function ContextualEmitter:constructor(master)
+		self.master = master
+	end
+	function ContextualEmitter:on(message, callback)
+		local isClient = self.context == "client"
+		if RunService:IsClient() and not isClient then
+			return error("[tether::error] Cannot listen to server message from client")
+		elseif RunService:IsServer() and isClient then
+			return error("[tether::error] Cannot listen to client message from server")
+		end
+		local callbacksMap = if isClient then self.master.clientCallbacks else self.master.serverCallbacks
+		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 ContextualEmitter:once(message, callback)
+		local destructor
+		destructor = self:on(message, function(player, data)
+			destructor()
+			callback(player, data)
+		end)
+		return destructor
+	end
+end
+return {
+	ContextualEmitter = ContextualEmitter,
+}

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

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

package/out/{message-emitter.luau → emitters/message-emitter.luau}

@@ -8,23 +8,25 @@ local Destroyable = TS.import(script, TS.getModule(script, "@rbxts", "destroyabl
 local Object = TS.import(script, TS.getModule(script, "@rbxts", "object-utils"))
 local createSerializer = TS.import(script, TS.getModule(script, "@rbxts", "serio").out).default
 local repr = TS.import(script, TS.getModule(script, "@rbxts", "repr").out)
-local _middleware = TS.import(script, script.Parent, "middleware")
+local _middleware = TS.import(script, script.Parent.Parent, "middleware")
 local DropRequest = _middleware.DropRequest
 local MiddlewareProvider = _middleware.MiddlewareProvider
-local IS_LUNE = string.sub(_VERSION, 1, 4) == "Lune"
+local ServerEmitter = TS.import(script, script.Parent, "server-emitter").ServerEmitter
+local ClientEmitter = TS.import(script, script.Parent, "client-emitter").ClientEmitter
+local _utility = TS.import(script, script.Parent.Parent, "utility")
+local readMessage = _utility.readMessage
+local writeMessage = _utility.writeMessage
 if setLuneContext == nil then
 	setLuneContext = function() end
 end
 setLuneContext("both")
-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)}`
+	return `[tether::warning]: Type validation guard failed for message '{message}' - check your sent data\nSent data: {repr(data)}`
 end
 local defaultMesssageEmitterOptions = {
 	batchRemotes = true,
 	batchRate = 1 / 24,
+	doNotBatch = {},
 }
 local sendMessage
 do
@@ -66,232 +68,18 @@ do
 		end
 		super.constructor(self)
 		self.options = options
+		self.server = ServerEmitter.new(self)
+		self.client = ClientEmitter.new(self)
 		self.middleware = MiddlewareProvider.new()
-		self.guards = {}
-		self.serializers = {}
 		self.clientCallbacks = {}
 		self.clientFunctions = {}
 		self.serverCallbacks = {}
 		self.serverFunctions = {}
+		self.guards = {}
+		self.serializers = {}
 		self.serverQueue = {}
 		self.clientBroadcastQueue = {}
 		self.clientQueue = {}
-		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
-				if RunService:IsServer() then
-					error("[@rbxts/tether]: Cannot emit message to server from server")
-				end
-				task.spawn(function()
-					local _binding = self:runServerMiddlewares(message, data)
-					local dropRequest = _binding[1]
-					local newData = _binding[2]
-					if dropRequest then
-						return nil
-					end
-					local _serverQueue = self.serverQueue
-					local _arg0 = { message, newData, unreliable }
-					table.insert(_serverQueue, _arg0)
-					if not self.options.batchRemotes then
-						self:update()
-					end
-				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
-					local _clientFunctions_1 = self.clientFunctions
-					local _returnMessage_1 = returnMessage
-					_clientFunctions_1[_returnMessage_1] = {}
-				end
-				local _clientFunctions_1 = self.clientFunctions
-				local _returnMessage_1 = returnMessage
-				local functions = _clientFunctions_1[_returnMessage_1]
-				local returnValue
-				local responseCallback = function(data)
-					returnValue = data
-					return returnValue
-				end
-				functions[responseCallback] = true
-				self.server.emit(message, data, unreliable)
-				while returnValue == nil do
-					RunService.Heartbeat:Wait()
-				end
-				-- Clean up the callback after receiving the response
-				functions[responseCallback] = nil
-				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)
-					-- Defer the response emission to end of frame and swap context to avoid context check issues
-					-- task.defer guarantees response is sent by end of current frame, ensuring predictable timing in production
-					task.defer(function()
-						setLuneContext("server")
-						self.client.emit(player, returnMessage, returnValue)
-						setLuneContext("both")
-					end)
-				end)
-			end,
-		}
-		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
-				if RunService:IsClient() then
-					error("[@rbxts/tether]: Cannot emit message to client from client")
-				end
-				task.spawn(function()
-					local _binding = self:runClientMiddlewares(message, data)
-					local dropRequest = _binding[1]
-					local newData = _binding[2]
-					if dropRequest then
-						return nil
-					end
-					local _clientQueue = self.clientQueue
-					local _arg0 = { player, message, newData, unreliable }
-					table.insert(_clientQueue, _arg0)
-					if not self.options.batchRemotes then
-						self:update()
-					end
-				end)
-			end,
-			emitExcept = function(player, message, data, unreliable)
-				if unreliable == nil then
-					unreliable = false
-				end
-				local shouldSendTo = function(p)
-					local _player = player
-					local _result
-					if typeof(_player) == "Instance" then
-						_result = p ~= player
-					else
-						local _player_1 = player
-						local _p = p
-						_result = not (table.find(_player_1, _p) ~= nil)
-					end
-					return _result
-				end
-				local _client = self.client
-				local _exp = Players:GetPlayers()
-				-- ▼ ReadonlyArray.filter ▼
-				local _newValue = {}
-				local _length = 0
-				for _k, _v in _exp do
-					if shouldSendTo(_v, _k - 1, _exp) == true then
-						_length += 1
-						_newValue[_length] = _v
-					end
-				end
-				-- ▲ ReadonlyArray.filter ▲
-				_client.emit(_newValue, message, data, unreliable)
-			end,
-			emitAll = function(message, data, unreliable)
-				if unreliable == nil then
-					unreliable = false
-				end
-				if RunService:IsClient() then
-					error("[@rbxts/tether]: Cannot emit message to all clients from client")
-				end
-				task.spawn(function()
-					local _binding = self:runClientMiddlewares(message, data)
-					local dropRequest = _binding[1]
-					local newData = _binding[2]
-					if dropRequest then
-						return nil
-					end
-					local _clientBroadcastQueue = self.clientBroadcastQueue
-					local _arg0 = { message, newData, unreliable }
-					table.insert(_clientBroadcastQueue, _arg0)
-					if not self.options.batchRemotes then
-						self:update()
-					end
-				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
-					local _serverFunctions_1 = self.serverFunctions
-					local _returnMessage_1 = returnMessage
-					_serverFunctions_1[_returnMessage_1] = {}
-				end
-				local _serverFunctions_1 = self.serverFunctions
-				local _returnMessage_1 = returnMessage
-				local functions = _serverFunctions_1[_returnMessage_1]
-				local returnValue
-				local responseCallback = function(data)
-					returnValue = data
-					return returnValue
-				end
-				functions[responseCallback] = true
-				self.client.emit(player, message, data, unreliable)
-				while returnValue == nil do
-					RunService.Heartbeat:Wait()
-				end
-				-- Clean up the callback after receiving the response
-				functions[responseCallback] = nil
-				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)
-					-- Defer the response emission to end of frame and swap context to avoid context check issues
-					-- task.defer guarantees response is sent by end of current frame, ensuring predictable timing in production
-					task.defer(function()
-						setLuneContext("client")
-						self.server.emit(returnMessage, returnValue)
-						setLuneContext("both")
-					end)
-				end)
-			end,
-		}
 		self.trash:add(function()
 			self.clientCallbacks = {}
 			self.serverCallbacks = {}
@@ -304,9 +92,10 @@ do
 	function MessageEmitter:create(options, meta)
 		local emitter = MessageEmitter.new(Object.assign({}, defaultMesssageEmitterOptions, options))
 		if meta == nil then
-			warn(metaGenerationFailed)
+			warn("[tether::warning] Failed to generate message metadata - make sure you have the Flamework transformer and are using Flamework macro-friendly types in your schemas")
 			return emitter:initialize()
 		end
+		-- https://discord.com/channels/476080952636997633/506983834877689856/1363938149486821577
 		for kind, _binding in pairs(meta) do
 			local guard = _binding.guard
 			local serializerMetadata = _binding.serializerMetadata
@@ -319,6 +108,87 @@ do
 		end
 		return emitter:initialize()
 	end
+	function MessageEmitter:queueMessage(context, message, data)
+		local queue = if context == "client" then self.clientQueue elseif context == true then self.clientBroadcastQueue else self.serverQueue
+		local _data = data
+		table.insert(queue, _data)
+		if not self:shouldBatch(message) then
+			self:relay()
+		end
+	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,
+			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, ctx.data, "Invalid data after global client middleware") then
+				return { false, ctx.data }
+			end
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Global client middleware")
+				return { true, ctx.data }
+			end
+		end
+		for _, middleware in self.middleware:getClient(message) do
+			local result = middleware(players, ctx)
+			if not self:validateData(message, ctx.data, "Invalid data after client middleware") then
+				return { false, ctx.data }
+			end
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Client middleware")
+				return { true, ctx.data }
+			end
+		end
+		if not self:validateData(message, ctx.data) then
+			return { true, ctx.data }
+		end
+		return { false, ctx.data }
+	end
+	function MessageEmitter:runServerMiddlewares(message, data)
+		if not self:validateData(message, data) then
+			return { true, data }
+		end
+		local ctx = {
+			message = message,
+			data = data,
+			getRawData = function()
+				return self:getPacket(message, data)
+			end,
+		}
+		for _, globalMiddleware in self.middleware:getServerGlobal() do
+			if not self:validateData(message, ctx.data, "Invalid data after global server middleware") then
+				return { false, ctx.data }
+			end
+			local result = globalMiddleware(ctx)
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Global server middleware")
+				return { true, ctx.data }
+			end
+		end
+		for _, middleware in self.middleware:getServer(message) do
+			if not self:validateData(message, ctx.data, "Invalid data after server middleware") then
+				return { false, ctx.data }
+			end
+			local result = middleware(ctx)
+			if result == DropRequest then
+				self.middleware:notifyRequestDropped(message, "Server middleware")
+				return { true, ctx.data }
+			end
+		end
+		if not self:validateData(message, ctx.data) then
+			return { true, ctx.data }
+		end
+		return { false, ctx.data }
+	end
 	function MessageEmitter:initialize()
 		setLuneContext("client")
 		if RunService:IsClient() then
@@ -355,11 +225,11 @@ do
 				return nil
 			end
 			elapsed -= batchRate
-			self:update()
+			self:relay()
 		end))
 		return self
 	end
-	function MessageEmitter:update()
+	function MessageEmitter:relay()
 		local getPacket = function(info)
 			return info.packet
 		end
@@ -590,79 +460,6 @@ do
 			self.clientQueue = {}
 		end
 	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,
-			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, ctx.data, "Invalid data after global client middleware") then
-				return { false, ctx.data }
-			end
-			if result == DropRequest then
-				self.middleware:notifyRequestDropped(message, "Global client middleware")
-				return { true, ctx.data }
-			end
-		end
-		for _, middleware in self.middleware:getClient(message) do
-			local result = middleware(players, ctx)
-			if not self:validateData(message, ctx.data, "Invalid data after client middleware") then
-				return { false, ctx.data }
-			end
-			if result == DropRequest then
-				self.middleware:notifyRequestDropped(message, "Client middleware")
-				return { true, ctx.data }
-			end
-		end
-		if not self:validateData(message, ctx.data) then
-			return { true, ctx.data }
-		end
-		return { false, ctx.data }
-	end
-	function MessageEmitter:runServerMiddlewares(message, data)
-		if not self:validateData(message, data) then
-			return { true, data }
-		end
-		local ctx = {
-			message = message,
-			data = data,
-			getRawData = function()
-				return self:getPacket(message, data)
-			end,
-		}
-		for _, globalMiddleware in self.middleware:getServerGlobal() do
-			if not self:validateData(message, ctx.data, "Invalid data after global server middleware") then
-				return { false, ctx.data }
-			end
-			local result = globalMiddleware(ctx)
-			if result == DropRequest then
-				self.middleware:notifyRequestDropped(message, "Global server middleware")
-				return { true, ctx.data }
-			end
-		end
-		for _, middleware in self.middleware:getServer(message) do
-			if not self:validateData(message, ctx.data, "Invalid data after server middleware") then
-				return { false, ctx.data }
-			end
-			local result = middleware(ctx)
-			if result == DropRequest then
-				self.middleware:notifyRequestDropped(message, "Server middleware")
-				return { true, ctx.data }
-			end
-		end
-		if not self:validateData(message, ctx.data) then
-			return { true, ctx.data }
-		end
-		return { false, ctx.data }
-	end
 	function MessageEmitter:validateData(message, data, requestDropReason)
 		if requestDropReason == nil then
 			requestDropReason = "Invalid data"
@@ -680,9 +477,9 @@ do
 	function MessageEmitter:onRemoteFire(isServer, serializedPackets, player)
 		for _, packet in serializedPackets do
 			if buffer.len(packet.messageBuf) > 1 then
-				return warn("[@rbxts/tether]: Rejected packet because message buffer was larger than one byte")
+				return warn("[tether::warning] Rejected packet because message buffer was larger than one byte")
 			end
-			local message = buffer.readu8(packet.messageBuf, 0)
+			local message = readMessage(packet)
 			self:executeEventCallbacks(isServer, message, packet, player)
 			self:executeFunctions(isServer, message, packet)
 		end
@@ -715,6 +512,15 @@ do
 			end
 		end
 	end
+	function MessageEmitter:shouldBatch(message)
+		local _condition = self.options.batchRemotes
+		if _condition then
+			local _doNotBatch = self.options.doNotBatch
+			local _message = message
+			_condition = not (_doNotBatch[_message] ~= nil)
+		end
+		return _condition
+	end
 	function MessageEmitter:deserializeAndValidate(message, serializedPacket)
 		local serializer = self:getSerializer(message)
 		local _packet = serializer
@@ -725,43 +531,10 @@ do
 		self:validateData(message, packet)
 		return packet
 	end
-	function MessageEmitter:once(message, callback, callbacksMap)
-		local destructor
-		destructor = self:on(message, function(player, data)
-			destructor()
-			callback(player, data)
-		end, callbacksMap)
-		return destructor
-	end
-	function MessageEmitter:on(message, callback, callbacksMap)
-		local _callbacksMap = callbacksMap
-		local _message = message
-		if not (_callbacksMap[_message] ~= nil) then
-			local _callbacksMap_1 = callbacksMap
-			local _message_1 = message
-			_callbacksMap_1[_message_1] = {}
-		end
-		local _callbacksMap_1 = callbacksMap
-		local _message_1 = message
-		local callbacks = _callbacksMap_1[_message_1]
-		local _callback = callback
-		callbacks[_callback] = true
-		local _callbacksMap_2 = callbacksMap
-		local _message_2 = message
-		_callbacksMap_2[_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:getPacket(message, data)
 		local serializer = self:getSerializer(message)
 		local messageBuf = buffer.create(1)
-		buffer.writeu8(messageBuf, 0, message)
+		writeMessage(messageBuf, message)
 		if serializer == nil then
 			return {
 				messageBuf = messageBuf,

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

@@ -0,0 +1,30 @@
+import { ContextualEmitter } from "./contextual-emitter";
+import type { BaseMessage, ServerMessageCallback, ServerFunctionMessageCallback } from "../structs";
+export declare class ServerEmitter<MessageData> extends ContextualEmitter<MessageData> {
+    readonly context = "server";
+    readonly on: <K extends keyof MessageData>(this: ServerEmitter<MessageData>, message: K & BaseMessage, callback: ServerMessageCallback<MessageData[K]>) => () => void;
+    readonly once: <K extends keyof MessageData>(this: ServerEmitter<MessageData>, message: K & BaseMessage, callback: ServerMessageCallback<MessageData[K]>) => () => void;
+    /**
+     * Emits a message to the server
+     *
+     * @param message The message kind to be sent
+     * @param data The data associated with the message
+     * @param unreliable Whether the message should be sent unreliably
+     */
+    emit<K extends keyof MessageData>(message: K & BaseMessage, data?: MessageData[K], unreliable?: boolean): void;
+    /**
+     * Sets a callback for a simulated remote function
+     *
+     * @returns A destructor function that disconnects the callback from the message
+     */
+    setCallback<K extends keyof MessageData, R extends keyof MessageData>(message: K & BaseMessage, returnMessage: R & BaseMessage, callback: ServerFunctionMessageCallback<MessageData[K], MessageData[R]>): () => void;
+    /**
+     * Simulates a remote function invocation
+     *
+     * @param message The message kind to be sent
+     * @param returnMessage The message kind to be returned
+     * @param data The data associated with the message
+     * @param unreliable Whether the message should be sent unreliably
+     */
+    invoke<K extends keyof MessageData, R extends keyof MessageData>(message: K & BaseMessage, returnMessage: R & BaseMessage, data?: MessageData[K], unreliable?: boolean): Promise<MessageData[R]>;
+}

package/out/emitters/server-emitter.luau

@@ -0,0 +1,104 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local ContextualEmitter = TS.import(script, script.Parent, "contextual-emitter").ContextualEmitter
+local ServerEmitter
+do
+	local super = ContextualEmitter
+	ServerEmitter = setmetatable({}, {
+		__tostring = function()
+			return "ServerEmitter"
+		end,
+		__index = super,
+	})
+	ServerEmitter.__index = ServerEmitter
+	function ServerEmitter.new(...)
+		local self = setmetatable({}, ServerEmitter)
+		return self:constructor(...) or self
+	end
+	function ServerEmitter:constructor(...)
+		super.constructor(self, ...)
+		self.context = "server"
+	end
+	function ServerEmitter:emit(message, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if RunService:IsServer() then
+			error("[tether::error] Cannot emit message from server to server")
+		end
+		task.spawn(function()
+			local _binding = self.master:runServerMiddlewares(message, data)
+			local dropRequest = _binding[1]
+			local newData = _binding[2]
+			if dropRequest then
+				return nil
+			end
+			self.master:queueMessage(self.context, message, { message, newData, unreliable })
+		end)
+	end
+	function ServerEmitter:setCallback(message, returnMessage, callback)
+		if RunService:IsClient() then
+			error("[tether::error] Cannot listen to client message from server")
+		end
+		return self:on(message, function(player, data)
+			local returnValue = callback(player, data)
+			-- Defer the response emission to end of frame and swap context to avoid context check issues
+			-- task.defer guarantees response is sent by end of current frame, ensuring predictable timing in production
+			task.defer(function()
+				setLuneContext("server")
+				self.master.client:emit(player, returnMessage, returnValue)
+				setLuneContext("both")
+			end)
+		end)
+	end
+	function ServerEmitter:invoke(message, returnMessage, data, unreliable)
+		if unreliable == nil then
+			unreliable = false
+		end
+		if RunService:IsServer() then
+			error("[tether::error] Cannot invoke function from server to server")
+		end
+		local _binding = self.master
+		local clientFunctions = _binding.clientFunctions
+		local _returnMessage = returnMessage
+		if not (clientFunctions[_returnMessage] ~= nil) then
+			local _returnMessage_1 = returnMessage
+			clientFunctions[_returnMessage_1] = {}
+		end
+		local _returnMessage_1 = returnMessage
+		local functions = clientFunctions[_returnMessage_1]
+		local returnValue
+		local responseCallback = function(data)
+			returnValue = data
+			return returnValue
+		end
+		functions[responseCallback] = true
+		self:emit(message, data, unreliable)
+		return TS.Promise.new(function(resolve, reject)
+			-- awful
+			local frames = 0
+			while true do
+				local _condition = returnValue == nil
+				if _condition then
+					local _original = frames
+					frames += 1
+					_condition = _original < 400
+				end
+				if not _condition then
+					break
+				end
+				RunService.Heartbeat:Wait()
+			end
+			if frames == 400 then
+				return reject("[tether::error] Server function timed out (no response)")
+			end
+			-- clean up the callback after receiving the response
+			functions[responseCallback] = nil
+			resolve(returnValue)
+		end)
+	end
+end
+return {
+	ServerEmitter = ServerEmitter,
+}

package/out/index.d.ts

@@ -1,3 +1,3 @@
-export { MessageEmitter } from "./message-emitter";
+export { MessageEmitter } from "./emitters/message-emitter";
 export { BuiltinMiddlewares } from "./builtin-middlewares";
 export { DropRequest, type ClientMiddleware, type ServerMiddleware, type SharedMiddleware, type Middleware, type MiddlewareContext } from "./middleware";

package/out/init.luau

@@ -1,7 +1,7 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 local exports = {}
-exports.MessageEmitter = TS.import(script, script, "message-emitter").MessageEmitter
+exports.MessageEmitter = TS.import(script, script, "emitters", "message-emitter").MessageEmitter
 exports.BuiltinMiddlewares = TS.import(script, script, "builtin-middlewares").BuiltinMiddlewares
 exports.DropRequest = TS.import(script, script, "middleware").DropRequest
 return exports

package/out/logging.d.ts

@@ -0,0 +1,15 @@
+export declare const enum Error {
+    NoServerListen = "[tether::error] Cannot listen to server message from client",
+    NoClientListen = "[tether::error] Cannot listen to client message from server",
+    NoServerToServer = "[tether::error] Cannot emit message from server to server",
+    NoClientToClient = "[tether::error] Cannot emit message from client to client",
+    NoClientToAllClients = "[tether::error] Cannot emit message from client to all clients",
+    NoServerToServerFunction = "[tether::error] Cannot invoke function from server to server",
+    NoClientToClientFunction = "[tether::error] Cannot invoke function from client to client",
+    ServerFunctionTimeout = "[tether::error] Server function timed out (no response)",
+    ClientFunctionTimeout = "[tether::error] Client function timed out (no response)"
+}
+export declare const enum Warning {
+    MessageBufferTooLong = "[tether::warning] Rejected packet because message buffer was larger than one byte",
+    MetaGenerationFailed = "[tether::warning] Failed to generate message metadata - make sure you have the Flamework transformer and are using Flamework macro-friendly types in your schemas"
+}

package/out/logging.luau

@@ -0,0 +1,4 @@
+-- Compiled with roblox-ts v3.0.0
+local errorTag = "[tether::error] "
+local warnTag = "[tether::warning] "
+return nil

package/out/structs.d.ts

@@ -1,10 +1,11 @@
 import type { Modding } from "@flamework/core";
 import type { SerializerMetadata, SerializedData, Transform, Vector, String, u8, u16, u24, u32, i8, i16, i24, i32, f16, f24, f32, f64 } from "@rbxts/serio";
 export type MessageCallback<T = unknown> = ServerMessageCallback<T> | ClientMessageCallback<T>;
+export type FunctionMessageCallback<T = unknown, R = unknown> = ServerFunctionMessageCallback<T, R> | ClientFunctionMessageCallback<T, R>;
 export type ClientMessageCallback<T = unknown> = (data: T) => void;
-export type ClientMessageFunctionCallback<T = unknown, R = unknown> = (data: T) => R;
+export type ClientFunctionMessageCallback<T = unknown, R = unknown> = (data: T) => R;
 export type ServerMessageCallback<T = unknown> = (player: Player, data: T) => void;
-export type ServerMessageFunctionCallback<T = unknown, R = unknown> = (player: Player, data: T) => R;
+export type ServerFunctionMessageCallback<T = unknown, R = unknown> = (player: Player, data: T) => R;
 export type BaseMessage = number;
 export interface PacketInfo {
     readonly packet: SerializedPacket;

package/out/utility.d.ts

@@ -1 +1,6 @@
+import type { BaseMessage, SerializedPacket } from "./structs";
 export declare function bufferToString(buf?: buffer): string;
+export declare function encodeMessage(message: BaseMessage): number;
+export declare function decodeMessage(encoded: number): BaseMessage;
+export declare function writeMessage(buf: buffer, message: BaseMessage): void;
+export declare function readMessage(packet: SerializedPacket | buffer): BaseMessage;

package/out/utility.luau

@@ -1,4 +1,5 @@
 -- Compiled with roblox-ts v3.0.0
+local COEFF = 0xFA
 local function bufferToString(buf)
 	local s = { "{ " }
 	if buf ~= nil then
@@ -25,6 +26,28 @@ local function bufferToString(buf)
 	table.insert(s, "}")
 	return table.concat(s, "")
 end
+local function encodeMessage(message)
+	message = bit32.band((bit32.bxor(message, COEFF)), 0xFF)
+	return bit32.bor((bit32.lshift(message, 3)), (bit32.arshift(message, 5)))
+end
+local function decodeMessage(encoded)
+	encoded = bit32.bor((bit32.arshift(encoded, 3)), (bit32.lshift(encoded, 5)))
+	return bit32.band((bit32.bxor(encoded, COEFF)), 0xFF)
+end
+local function writeMessage(buf, message)
+	local _arg0 = buffer.len(buf) == 1
+	assert(_arg0)
+	buffer.writeu8(buf, 0, encodeMessage(message))
+end
+local function readMessage(packet)
+	local _packet = packet
+	local buf = if type(_packet) == "buffer" then packet else packet.messageBuf
+	return decodeMessage(buffer.readu8(buf, 0))
+end
 return {
 	bufferToString = bufferToString,
+	encodeMessage = encodeMessage,
+	decodeMessage = decodeMessage,
+	writeMessage = writeMessage,
+	readMessage = readMessage,
 }

package/package.json

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

package/out/message-emitter.d.ts

@@ -1,128 +0,0 @@
-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 guards;
-    private serializers;
-    private clientCallbacks;
-    private clientFunctions;
-    private serverCallbacks;
-    private serverFunctions;
-    private serverQueue;
-    private clientBroadcastQueue;
-    private clientQueue;
-    /** @metadata macro */
-    static create<MessageData>(options?: Partial<MessageEmitterOptions>, meta?: Modding.Many<MessageEmitterMetadata<MessageData>>): MessageEmitter<MessageData>;
-    private constructor();
-    readonly server: {
-        /**
-         * @returns A destructor function that disconnects the callback from the message
-         */
-        on: <Kind extends keyof MessageData>(message: Kind & BaseMessage, callback: ServerMessageCallback<MessageData[Kind]>) => () => void;
-        /**
-         * Disconnects the callback as soon as it is called for the first time
-         *
-         * @returns A destructor function that disconnects the callback from the message
-         */
-        once: <Kind extends keyof MessageData>(message: Kind & BaseMessage, callback: ServerMessageCallback<MessageData[Kind]>) => () => void;
-        /**
-         * Emits a message to the server
-         *
-         * @param message The message kind to be sent
-         * @param data The data associated with the message
-         * @param unreliable Whether the message should be sent unreliably
-         */
-        emit: <Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind], unreliable?: boolean) => void;
-        /**
-         * Simulates a remote function invocation.
-         *
-         * @param message The message kind to be sent
-         * @param data The data associated with the message
-         * @param unreliable Whether the message should be sent unreliably
-         */
-        invoke: <Kind extends keyof MessageData, ReturnKind extends keyof MessageData>(message: Kind & BaseMessage, returnMessage: ReturnKind & BaseMessage, data?: MessageData[Kind], unreliable?: boolean) => Promise<MessageData[ReturnKind]>;
-        /**
-         * Sets a callback for a simulated remote function
-         *
-         * @returns A destructor function that disconnects the callback from the message
-         */
-        setCallback: <Kind extends keyof MessageData, ReturnKind extends keyof MessageData>(message: Kind & BaseMessage, returnMessage: ReturnKind & BaseMessage, callback: ServerMessageFunctionCallback<MessageData[Kind], MessageData[ReturnKind]>) => () => void;
-    };
-    readonly client: {
-        /**
-         * @returns A destructor function that disconnects the callback from the message
-         */
-        on: <Kind extends keyof MessageData>(message: Kind & BaseMessage, callback: ClientMessageCallback<MessageData[Kind]>) => () => void;
-        /**
-         * Disconnects the callback as soon as it is called for the first time
-         *
-         * @returns A destructor function that disconnects the callback from the message
-         */
-        once: <Kind extends keyof MessageData>(message: Kind & BaseMessage, callback: ClientMessageCallback<MessageData[Kind]>) => () => void;
-        /**
-         * Emits a message to a specific client or multiple clients
-         *
-         * @param player The player(s) to whom the message is sent
-         * @param message The message kind to be sent
-         * @param data The data associated with the message
-         * @param unreliable Whether the message should be sent unreliably
-         */
-        emit: <Kind extends keyof MessageData>(player: Player | Player[], message: Kind & BaseMessage, data?: MessageData[Kind], unreliable?: boolean) => void;
-        /**
-         * Emits a message to all clients except the specified client(s)
-         *
-         * @param player The player(s) to whom the message is not sent
-         * @param message The message kind to be sent
-         * @param data The data associated with the message
-         * @param unreliable Whether the message should be sent unreliably
-         */
-        emitExcept: <Kind extends keyof MessageData>(player: Player | Player[], message: Kind & BaseMessage, 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 Whether the message should be sent unreliably
-         */
-        emitAll: <Kind extends keyof MessageData>(message: Kind & BaseMessage, data?: MessageData[Kind], unreliable?: boolean) => void;
-        /**
-         * Simulates a remote function invocation.
-         *
-         * @param message The message kind to be sent
-         * @param data The data associated with the message
-         * @param unreliable Whether the message should be sent unreliably
-         */
-        invoke: <Kind extends keyof MessageData, ReturnKind extends keyof MessageData>(message: Kind & BaseMessage, returnMessage: ReturnKind & BaseMessage, player: Player, data?: MessageData[Kind], unreliable?: boolean) => Promise<MessageData[ReturnKind]>;
-        /**
-         * Sets a callback for a simulated remote function
-         *
-         * @returns A destructor function that disconnects the callback from the message
-         */
-        setCallback: <Kind extends keyof MessageData, ReturnKind extends keyof MessageData>(message: Kind & BaseMessage, returnMessage: ReturnKind & BaseMessage, callback: ClientMessageFunctionCallback<MessageData[Kind], MessageData[ReturnKind]>) => () => void;
-    };
-    private initialize;
-    private update;
-    private runClientMiddlewares;
-    private runServerMiddlewares;
-    private validateData;
-    private onRemoteFire;
-    private executeFunctions;
-    private executeEventCallbacks;
-    private deserializeAndValidate;
-    private once;
-    private on;
-    private getPacket;
-    /** @metadata macro */
-    private addSerializer;
-    /** @metadata macro */
-    private createMessageSerializer;
-    private getSerializer;
-}
-export {};