cluaupp 0.1.0

package/runtime/DataService/Packages/quicknet/QuickNet.luau

@@ -0,0 +1,953 @@
+--!optimize 2
+
+--[QuickNet] v0.3.0
+--author: u5eful
+
+--services--
+local RunService = game:GetService("RunService")
+local Players = game:GetService("Players")
+
+--dependencies--
+local DataTypes = require(script.Parent.DataTypes)
+local Enums = require(script.Parent.Enums)
+local Serialize = require(script.Parent.Serialize)
+local Parser = require(script.Parent.Parser)
+local Types = require(script.Parent.Types)
+
+--config--
+local SOURCE = "[QuickNet]"
+local DEBUG_MODE = true --set to false for production
+local RATE_LIMIT = {Max = 120, Time = 1} --adjust this
+local MAX_CALLS_PER_FRAME = 100000 --adjust this
+local INVOKE_TIMEOUT = 10
+local MAX_INVOKE_TIMEOUT = 60
+local MAX_PAYLOAD_SIZE = 200000000000 --adjust this (recommended 5-50K)
+local MAX_ARGS = 30
+local ERROR_MSGS = {
+	MaxArgs = "Number of arguments exceeds max",
+	InvalidInternalArg1 = "invalid internal argument 1",
+	InvalidInternalArg2 = "invalid internal argument 2",
+	Unreliable1 = "Network function cannot be unreliable",
+	Response1 = "Unreliable event does not support response",
+}
+local MAX_REQ_ID_RANGE = 65536
+local CLIENT_TEMP_BUFF_SIZE = 20000000 --adjust this (recommended 1-5M)
+local SERVER_TEMP_BUFF_SIZE = 2000000 --adjust this (recommended 500K-1M)
+local REMOTE_EVENT = 0
+local REMOTE_FUNCTION = 1
+local INVOKE_FAIL_ID = 0
+local TBL_POOL_SIZE = 100
+
+--types--
+type Signal<T...> = Types.Signal<T...>
+export type NetworkEvent<A... = ()> = Types.NetworkEvent<A...>
+export type NetworkFunction<A... = (), B... = ()> = Types.NetworkFunction<A..., B...>
+type NetworkInfo<A..., B...> = Types.NetworkInfo<A..., B...>
+export type QuickNetConnection = Types.QuickNetConnection
+type SchemaArg = Types.SchemaArg
+type Queue = Types.Queue
+
+--helpers--
+local function getClientQueue(): Queue
+	return {
+		QueueSize = 0,
+		ByteSize = 0,
+		TempBuffer = buffer.create(CLIENT_TEMP_BUFF_SIZE),
+		Instances = {},
+	}
+end
+
+--variables--
+local isServer = RunService:IsServer()
+local getSchema = Parser.getSchema
+local Net = {}
+local encodeData = Serialize.encode
+local decodeData = Serialize.decode
+local eventsInfo: {[number]: NetworkInfo<(), ()>} = {}
+local namesRegistered: {[string]: boolean} = {}
+local rateLimitInfo: {[Player]: {[string]: {Timestamp: number, NumSends: number}}} = {}
+local reqThreads: {[number]: thread} = {}
+local asyncThreadsPool: {thread} = {}
+local timeoutTasks: {[number]: thread} = {}
+local globalReqId: number = -1
+local globalEventId: number = 0
+local buffersPool: {buffer} = {}
+local buffersCache: {[number]: {buffer}} = {}
+local buffersCacheSize = 0
+local clientQueue: Queue?
+local clientQueueUnr: Queue?
+if not isServer then
+	clientQueue = getClientQueue()
+	clientQueueUnr = getClientQueue()
+end
+local serverQueue: {[Player]: Queue} = {}
+local serverQueueUnr: {[Player]: Queue} = {}
+local internalRemote: RemoteEvent
+local internalUnreliable: UnreliableRemoteEvent
+local maxPayloadSize = MAX_PAYLOAD_SIZE
+local tablePool = table.create(TBL_POOL_SIZE)
+
+--private--
+@native local function getTable(): {any}
+	local poolIdx = #tablePool
+	local tbl = tablePool[poolIdx]
+	tablePool[poolIdx] = nil
+	return tbl or {}
+end
+
+@native local function recycleTable(tbl: {any})
+	local poolIdx = #tablePool
+	if poolIdx > TBL_POOL_SIZE then
+		return
+	end
+	table.clear(tbl)
+	tablePool[poolIdx + 1] = tbl
+end
+
+local function errorMsg(msg: string)
+	error(SOURCE.." "..msg, 3)
+end
+
+local function warnMsg(msg: string, bypassDebugMode: boolean?)
+	if not DEBUG_MODE and not bypassDebugMode then
+		return
+	end
+	warn(SOURCE.." "..msg)
+end
+
+local function getRemote(name: string): RemoteEvent
+	local remote
+	if isServer then
+		remote = Instance.new("RemoteEvent")
+		remote.Name = name
+		remote.Parent = script
+	else
+		remote = script:WaitForChild(name)
+	end
+	return remote
+end
+
+local function getUnreliable(name: string): UnreliableRemoteEvent
+	local unreliable
+	if isServer then
+		unreliable = Instance.new("UnreliableRemoteEvent")
+		unreliable.Name = name
+		unreliable.Parent = script
+	else
+		unreliable = script:WaitForChild(name)
+	end
+	return unreliable
+end
+
+local function getBuffer(): buffer
+	local poolIdx = #buffersPool
+	local buff = buffersPool[poolIdx] or buffer.create(SERVER_TEMP_BUFF_SIZE)
+	buffersPool[poolIdx] = nil
+	return buff
+end
+
+local function recycleBuffer(buff: buffer)
+	local poolIdx = #buffersPool
+	if poolIdx >= 30 or not buff then return end 
+	buffersPool[#buffersPool + 1] = buff
+end
+
+@native local function cacheBuffer(buff: buffer, size: number)
+	if buffersCacheSize > 9 then
+		local k = next(buffersCache)
+		buffersCache[k] = nil
+	else
+		buffersCacheSize += 1
+	end
+	buffersCache[size] = buff
+end
+
+@native local function getBufferFromCache(size: number)
+	local buff = buffersCache[size]
+	if buff then
+		buffersCache[size] = nil
+		buffersCacheSize -= 1
+	end
+	return buff
+end
+
+@native local function getBatchedBuffer(queue: Queue): buffer
+	local bytes = queue.ByteSize
+	local size = bytes + 2
+	local buff = getBufferFromCache(size) or buffer.create(size)
+	buffer.writeu16(buff, 0, queue.QueueSize)
+	buffer.copy(buff, 2, queue.TempBuffer, 0, bytes)
+	cacheBuffer(buff, size)
+	return buff
+end
+
+@native local function flushQueue(queue: Queue, clearInst: boolean)
+	queue.QueueSize = 0
+	queue.ByteSize = 0
+	if clearInst then
+		table.clear(queue.Instances)
+	end
+end
+
+@native local function processQueueClient()
+	if clientQueueUnr.QueueSize >= 1 then --unreliable
+		local buff = getBatchedBuffer(clientQueueUnr)
+		local inst = clientQueueUnr.Instances
+		local hasInst = #inst > 0
+		if hasInst then
+			internalUnreliable:FireServer(buff, inst)
+		else
+			internalUnreliable:FireServer(buff)
+		end
+		flushQueue(clientQueueUnr, hasInst)
+	end
+	
+	if clientQueue.QueueSize >= 1 then --normal
+		local buff = getBatchedBuffer(clientQueue)
+		local inst = clientQueue.Instances
+		local hasInst = #inst > 0
+		if hasInst then
+		internalRemote:FireServer(buff, inst)
+		else
+		internalRemote:FireServer(buff)
+		end
+		flushQueue(clientQueue, hasInst)
+	end		
+end
+
+@native local function processQueueServer()
+	for player, queue in serverQueueUnr do --unreliable
+		if not queue or queue.QueueSize < 1 then
+			continue
+		end
+
+		local buff = getBatchedBuffer(queue)
+		local inst = queue.Instances
+		local hasInst = #inst > 0
+		if hasInst then
+			internalUnreliable:FireClient(player, buff, inst)
+		else
+			internalUnreliable:FireClient(player, buff)
+		end
+		flushQueue(queue, hasInst)
+	end
+	
+	for player, queue in serverQueue do --normal
+		if not queue or queue.QueueSize < 1 then
+			continue
+		end
+
+		local buff = getBatchedBuffer(queue)
+		local inst = queue.Instances
+		local hasInst = #inst > 0
+		if hasInst then
+			internalRemote:FireClient(player, buff, inst)
+		else
+			internalRemote:FireClient(player, buff)
+		end
+		flushQueue(queue, hasInst)
+	end
+end
+
+@native local function queueEvent(queue: Queue, schema: {SchemaArg?}, args: {any}, actionId: number, reqId: number,
+	networkType: number)
+	if not queue then return end
+	local offset = queue.ByteSize
+	local buff = queue.TempBuffer
+	buffer.writeu8(buff, offset, actionId)
+	local bytes = 1
+	if networkType == REMOTE_FUNCTION then
+		buffer.writeu16(buff, offset + bytes, reqId)
+		bytes += 2
+	end
+	local inst = queue.Instances
+	if schema then
+		for i, arg in schema do
+			local value = args[i]
+			local encode = encodeData[arg] or encodeData[arg[1]] 
+			:: ((buffer, number, SchemaArg, any, {Instance}?) -> number)?
+			bytes += encode(buff, offset + bytes, arg, value, inst)
+		end
+	end
+	queue.QueueSize += 1
+	queue.ByteSize += bytes
+end
+
+local function getEventId(name: string): number?
+	if isServer then
+		globalEventId += 1
+		if globalEventId > 255 then
+			errorMsg("Max number of network events is 255")
+			return
+		end
+		internalRemote:SetAttribute(name, globalEventId)
+		return globalEventId
+	end
+	
+	local id = internalRemote:GetAttribute(name)
+	if not id then
+		internalRemote:GetAttributeChangedSignal(name):Wait()
+		id = internalRemote:GetAttribute(name)
+	end
+	if not id then
+		errorMsg("unable to get action id for "..name)
+	end
+	return id
+end
+
+@native local function validateArgs(schema: {SchemaArg}?, args: {any}): boolean
+	if not schema then
+		return true
+	end
+	if #args > MAX_ARGS then
+		warnMsg(ERROR_MSGS.MaxArgs)
+		return false
+	end
+	return true
+end
+
+@native local function checkRateLimit(player: Player, name: string, rateLimitConfig: {Max: number, Time: number})
+	: boolean
+	local playerInfo = rateLimitInfo[player]
+	if not playerInfo then
+		return false
+	end
+	
+	local info = playerInfo[name]
+	local now = os.clock()
+	if not info then
+		info = {Timestamp = now, NumSends = 0}
+		playerInfo[name] = info
+	end
+	
+	local onCooldown = now - info.Timestamp < rateLimitConfig.Time
+	local exceeded = info.NumSends >= rateLimitConfig.Max
+
+	if exceeded and onCooldown then
+		warnMsg(player.Name.."'s rate limit exceeded for "..name)
+		return true
+	end
+	
+	if onCooldown then
+		info.NumSends += 1
+	else
+		info.Timestamp = now
+		info.NumSends = 1
+	end
+	return false
+end
+
+@native local function getArgs(buff: buffer, offset: number, schema: {SchemaArg}, inst: {Instance}?): ({any}, number)
+	local ptr = offset
+	local args = {}
+
+	for i, arg in schema do
+		local decode = decodeData[arg] or decodeData[arg[1]] 
+		:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
+		local value, bytes = decode(buff, ptr, arg, inst)
+		ptr += bytes
+		args[i] = value
+	end
+	return args, ptr - offset
+end
+
+@native local function fastUnpack(tbl: {any}, len: number): ...any
+	if len < 2 then
+		return tbl[1]
+		
+	elseif len < 5 then
+		return tbl[1], tbl[2], tbl[3], tbl[4]
+		
+	elseif len < 9 then
+		return tbl[1], tbl[2], tbl[3], tbl[4], tbl[5], tbl[6], tbl[7], tbl[8]
+	else
+		return table.unpack(tbl, 1, len)
+	end
+end
+
+@native local function getInvokeResults(...): (boolean, {any})
+	local success = select(1, ...)	
+	if not success then
+		local err = select(2, ...)
+		return success, err
+	end
+	
+	local args = {select(2, ...)}
+	return success, args
+end
+
+@native local function runCallback(callback, thread, responseSchema, actionId, reqId, ...)
+	if reqId then
+		local player = select(1, ...)
+		local success, result = getInvokeResults(pcall(callback, ...))
+		if success then
+			queueEvent(serverQueue[player], responseSchema, result, actionId, reqId, REMOTE_FUNCTION)
+		else
+			warnMsg(result, true)
+			queueEvent(serverQueue[player], nil, nil, INVOKE_FAIL_ID, reqId, REMOTE_FUNCTION)
+		end
+	else
+		local success, err = pcall(callback, ...)
+		if not success then warnMsg(err, true) end
+	end
+	asyncThreadsPool[#asyncThreadsPool + 1] = thread
+end
+
+@native local function yieldThread()
+	while true do
+		runCallback(coroutine.yield())
+	end
+end
+
+@native local function getThread(): thread
+	local numThreads = #asyncThreadsPool
+	local thread
+	if numThreads > 0 then
+		thread = asyncThreadsPool[numThreads]
+		asyncThreadsPool[numThreads] = nil
+	else
+		thread = coroutine.create(yieldThread)
+		coroutine.resume(thread)
+	end
+	return thread
+end
+
+local function addWait(waitThreads: {thread}): thread
+	waitThreads[#waitThreads + 1] = coroutine.running()
+	return coroutine.yield()
+end
+
+@native local function resolveWaits(waitThreads: {thread}, ...)
+	for _, thread in waitThreads do
+		if coroutine.status(thread) ~= "suspended" then
+			continue
+		end
+		coroutine.resume(thread, ...)
+	end
+	recycleTable(waitThreads)
+end
+
+@native local function disconnect(self: QuickNetConnection)
+	if not self.Connected then return end
+	self.Connected = false
+	self._callbacks[self] = nil
+	self._callbacks = nil
+end
+
+@native local function getNetworkConnection(callbacks: {[QuickNetConnection]: (...any) -> (...any)}, 
+	callback: (...any) -> (...any)): QuickNetConnection
+	local networkConn = {
+		Connected = true,
+		Disconnect = disconnect,
+		Destroy = disconnect,
+		_callbacks = callbacks,
+	} :: QuickNetConnection
+
+	callbacks[networkConn] = callback
+	return networkConn
+end
+
+@native local function remoteListenerServer(player: Player, buff: buffer, inst: {Instance}?)
+	if type(buff) ~= "buffer" then
+		warnMsg(ERROR_MSGS.InvalidInternalArg1)
+		return
+	end
+
+	if buffer.len(buff) > maxPayloadSize then
+		warnMsg(player.Name.." exceeded max packet size, dropping calls")
+		return
+	end
+
+	if inst then
+		if type(inst) ~= "table" then
+			warnMsg(ERROR_MSGS.InvalidInternalArg2)
+			return
+		end
+		inst[#inst + 1] = 1 --instance pointer
+	end
+	local numCalls = buffer.readu16(buff, 0)
+	local offset = 2
+
+	for i = 1, numCalls do
+		if i > MAX_CALLS_PER_FRAME then
+			warnMsg("max calls per frame exceeded for "..player.Name..
+				", further calls for this frame will be dropped")
+			return
+		end
+		local id = buffer.readu8(buff, offset)
+		offset += 1
+		local info: NetworkInfo<(), ()> = eventsInfo[id]
+		if not info then
+			warnMsg("unknown event id "..id..", dropping calls")
+			return
+		end
+		
+		local networkType = info.NetworkType
+		local isRemoteFunction = networkType == REMOTE_FUNCTION
+		local schema = info.SendSchema
+		local numArgs = #schema
+		local name = info.Name
+		local reqId = 0
+		if isRemoteFunction then
+			reqId = buffer.readu16(buff, offset)				
+			offset += 2
+		end
+		local args, bytesRead = getArgs(buff, offset, schema, inst)
+		offset += bytesRead
+		local valid = validateArgs(schema, args)	
+		local rateLimited = checkRateLimit(player, name, info.RateLimit)
+		if not valid or rateLimited then
+			if isRemoteFunction then
+				queueEvent(serverQueue[player], nil, nil, INVOKE_FAIL_ID, reqId, networkType)
+			end
+			continue
+		end
+		
+		local waitThreads = info.WaitThreads
+		if #waitThreads > 0 then
+			info.WaitThreads = getTable()
+			resolveWaits(waitThreads, player, fastUnpack(args, numArgs))
+		end
+
+		if isRemoteFunction then
+			local object = info.Object
+			local isAsync = object.OnServerInvokeAsync
+			local callback = object.OnServerInvoke or isAsync
+			local responseSchema = info.ResponseSchema
+			local numResults = #responseSchema
+			if isAsync then
+				local thread = getThread()
+				coroutine.resume(thread, callback, thread, responseSchema, id, reqId,
+					player, fastUnpack(args, numArgs))
+				continue
+			end
+
+			local success, result = getInvokeResults(pcall(callback, player, fastUnpack(args, numArgs)))
+			if not success then
+				warnMsg(result, true)
+				queueEvent(serverQueue[player], nil, nil, INVOKE_FAIL_ID, reqId, networkType)
+			else
+				queueEvent(serverQueue[player], responseSchema, result, id, reqId, networkType)
+			end
+			continue
+		end
+
+		for _, callback in info.Callbacks do
+			local success, err = pcall(callback, player, fastUnpack(args, numArgs))
+			if not success then warnMsg(err, true) end
+		end
+		
+		if info.NumOnceCallbacks > 0 then
+			local onces = info.OnceCallbacks
+			info.NumOnceCallbacks = 0
+			info.OnceCallbacks = getTable()
+			
+			for conn, callback in onces do
+				disconnect(conn)
+				local thread = getThread()
+				coroutine.resume(thread, callback, thread, nil, nil, nil, player, fastUnpack(args, numArgs))
+			end
+			recycleTable(onces)
+		end
+		
+		for _, callback in info.AsyncCallbacks do
+			local thread = getThread()
+			coroutine.resume(thread, callback, thread, nil, nil, nil, player, fastUnpack(args, numArgs))
+		end
+	end
+end
+
+@native local function remoteListenerServerPcall(player: Player, buff: buffer, inst: {Instance?})
+	local success, err = pcall(remoteListenerServer, player, buff, inst)
+	if not success then
+		warnMsg(err)
+	end
+end
+
+@native local function resumeInvokeThread(reqId: number, cancelTask: boolean?, ...)
+	local cor = reqThreads[reqId]
+	reqThreads[reqId] = nil
+	if cor and coroutine.status(cor) ~= "dead" then
+		coroutine.resume(cor, ...)
+	end
+	local timeoutTask = timeoutTasks[reqId]
+	timeoutTasks[reqId] = nil
+	if timeoutTask and cancelTask then
+		task.cancel(timeoutTask)
+	end
+end
+
+@native local function remoteListenerClient(buff: buffer, inst: {Instance}?)
+	if inst then
+		inst[#inst + 1] = 1
+	end
+	local numCalls = buffer.readu16(buff, 0)
+	local offset = 2
+	
+	for i = 1, numCalls do
+		local id = buffer.readu8(buff, offset)
+		offset += 1
+		
+		local reqId
+		if id == INVOKE_FAIL_ID then
+			reqId = buffer.readu16(buff, offset)			
+			offset += 2
+			resumeInvokeThread(reqId, true, nil)
+			continue
+		end
+		
+		local info: NetworkInfo<(), ()> = eventsInfo[id]
+		if not info then
+			warnMsg("unknown event id "..id..", dropping calls")
+			return
+		end
+		
+		local networkType = info.NetworkType
+		local isRemoteFunction = networkType == REMOTE_FUNCTION
+		local schema = networkType == REMOTE_FUNCTION and info.ResponseSchema or info.SendSchema
+		local numArgs = #schema
+		
+		if isRemoteFunction then
+			reqId = buffer.readu16(buff, offset)		
+			offset += 2
+		end
+		
+		local args, bytesRead = getArgs(buff, offset, schema, inst)
+		offset += bytesRead
+		
+		local waitThreads = info.WaitThreads
+		if #waitThreads > 0 then
+			info.WaitThreads = getTable()
+			resolveWaits(waitThreads, fastUnpack(args, numArgs))
+		end
+		
+		if isRemoteFunction then
+			resumeInvokeThread(reqId, true, fastUnpack(args, numArgs))
+			continue
+		end
+
+		for _, callback in info.Callbacks do
+			local success, err = pcall(callback, fastUnpack(args, numArgs))
+			if not success then warnMsg(err, true) end
+		end
+		
+		if info.NumOnceCallbacks > 0 then
+			local onces = info.OnceCallbacks
+			info.NumOnceCallbacks = 0
+			info.OnceCallbacks = getTable()
+
+			for conn, callback in onces do
+				disconnect(conn)
+				local thread = getThread()
+				coroutine.resume(thread, callback, thread, nil, nil, nil, fastUnpack(args, numArgs))
+			end
+			recycleTable(onces)
+		end
+
+		for _, callback in info.AsyncCallbacks do
+			local thread = getThread()
+			coroutine.resume(thread, callback, thread, nil, nil, nil, fastUnpack(args, numArgs))
+		end
+	end
+end
+
+@native local function remoteListenerClientPcall(buff: buffer, inst: {Instance?})
+	local success, err = pcall(remoteListenerClient, buff, inst)
+	if not success then
+		warnMsg(err)
+	end
+end
+
+local function createObjServer<A..., B...>(info: NetworkInfo<A..., B...>): NetworkEvent<A...>
+	local Object = {}
+	Object.OnServerEvent = {}
+
+	local callbacks = info.Callbacks
+	local asyncCallbacks = info.AsyncCallbacks
+	local name = info.Name	
+	local schema = info.SendSchema
+	local actionId = info.Id
+	local networkType = info.NetworkType
+	local queue = serverQueue
+	local isUnreliable = false
+	
+	function Object:SetRateLimit(max: number, timeWindow: number): NetworkEvent<A...>
+		info.RateLimit.Max = max
+		info.RateLimit.Time = timeWindow
+		return Object
+	end
+	
+	function Object:Unreliable(): NetworkEvent<A...>
+		if networkType == REMOTE_FUNCTION then
+			errorMsg(ERROR_MSGS.Unreliable1)
+			return
+		end
+		queue = serverQueueUnr
+		isUnreliable = true
+		return Object
+	end
+	
+	function Object:Response(...: B...): NetworkFunction<A..., B...>
+		if isUnreliable then
+			errorMsg(SOURCE..ERROR_MSGS.Response1)
+		end
+		Object.OnServerInvoke = nil
+		Object.OnServerInvokeAsync = nil
+		info.ResponseSchema = getSchema(...)
+		networkType = REMOTE_FUNCTION
+		info.NetworkType = REMOTE_FUNCTION
+		
+		function Object:SetResponseTimeout(val: number): NetworkFunction<A..., B...>
+			info.ResponseTimeout = val
+			return Object
+		end	
+		return Object
+	end
+	
+	function Object.OnServerEvent:Connect(callback: (player: Player, A...) -> ()): QuickNetConnection
+		return getNetworkConnection(callbacks, callback)
+	end
+	
+	function Object.OnServerEvent:ConnectAsync(callback: (player: Player, A...) -> ()): QuickNetConnection
+		return getNetworkConnection(asyncCallbacks, callback)
+	end
+	
+	function Object.OnServerEvent:Once(callback: (player: Player, A...) -> ()): QuickNetConnection
+		info.NumOnceCallbacks += 1
+		return getNetworkConnection(info.OnceCallbacks, callback)
+	end
+	
+	function Object.OnServerEvent:Wait()
+		return addWait(info.WaitThreads)
+	end
+	
+	@native function Object:FireClient(player: Player, ...: A...)
+		queueEvent(queue[player], schema, {...}, actionId, 0, networkType)
+	end
+	
+	function Object:FireClients(players: {Player}, ...: A...)
+		for _, player in players do
+			queueEvent(queue[player], schema, {...}, actionId, 0, networkType)
+		end
+	end
+
+	@native function Object:FireAllClients(...: A...)
+		for _, player in Players:GetPlayers() do
+			queueEvent(queue[player], schema, {...}, actionId, 0, networkType)
+		end
+	end
+
+	function Object:FireAllExcept(excludePlayer: Player, ...: A...)
+		for _, player in Players:GetPlayers() do
+			if player == excludePlayer then continue end 
+			queueEvent(queue[player], schema, {...}, actionId, 0, networkType)
+		end
+	end
+	return Object
+end
+
+local function timeout(reqId: number, seconds: number)
+	resumeInvokeThread(reqId)
+	warnMsg("Response "..reqId.." timed out after "..seconds.."s", true)
+end
+
+local function createObjClient<A..., B...>(info: NetworkInfo<A..., B...>): NetworkEvent<A...>
+	local Object = {}
+	Object.OnClientEvent = {}
+	
+	function Object:SetRateLimit(max: number, timeWindow: number): NetworkEvent<A...>
+		info.RateLimit.Max = max
+		info.RateLimit.Time = timeWindow
+		return Object
+	end
+	
+	local name = info.Name
+	local actionId = info.Id
+	local sendSchema = info.SendSchema
+	local callbacks = info.Callbacks
+	local asyncCallbacks = info.AsyncCallbacks
+	local networkType = info.NetworkType
+	local queue = clientQueue
+	local isUnreliable = false
+	
+	function Object:Unreliable(): NetworkEvent<A...>
+		if networkType == REMOTE_FUNCTION then
+			errorMsg(SOURCE..ERROR_MSGS.Unreliable1)
+			return
+		end
+		isUnreliable = true
+		queue = clientQueueUnr
+		return Object
+	end
+	
+	function Object:Response(...: B...): NetworkFunction<A..., B...>
+		if isUnreliable then
+			errorMsg(SOURCE..ERROR_MSGS.Response1)
+			return
+		end
+		info.ResponseSchema = getSchema(...)
+		info.NetworkType = REMOTE_FUNCTION
+		networkType = REMOTE_FUNCTION
+		
+		@native function Object:InvokeServer(...: A...): B...
+			globalReqId = (globalReqId + 1) % MAX_REQ_ID_RANGE
+			local reqId = globalReqId
+			resumeInvokeThread(reqId, true, nil)
+
+			local seconds = info.ResponseTimeout
+			local someTask = task.delay(seconds, timeout, reqId, seconds)
+			local cor = coroutine.running()
+			reqThreads[reqId] = cor
+			timeoutTasks[reqId] = someTask
+			queueEvent(clientQueue, sendSchema, {...}, actionId, reqId, REMOTE_FUNCTION)
+			return coroutine.yield()
+		end
+		
+		function Object:SetResponseTimeout(val: number): NetworkFunction<A..., B...>
+			if val > MAX_INVOKE_TIMEOUT or val < 0 then
+				warnMsg("Response timeout must be between 0 and "..MAX_INVOKE_TIMEOUT)
+				return
+			end
+			info.ResponseTimeout = val
+			return Object
+		end		
+		return Object
+	end
+	
+	function Object.OnClientEvent:Connect(callback: (A...) -> ()): QuickNetConnection	
+		return getNetworkConnection(callbacks, callback)
+	end
+	
+	function Object.OnClientEvent:ConnectAsync(callback: (A...) -> ()): QuickNetConnection	
+		return getNetworkConnection(asyncCallbacks, callback)
+	end
+	
+	function Object.OnClientEvent:Once(callback: (player: Player, A...) -> ()): QuickNetConnection
+		info.NumOnceCallbacks += 1
+		return getNetworkConnection(info.OnceCallbacks, callback)
+	end
+	
+	function Object.OnClientEvent:Wait()
+		return addWait(info.WaitThreads)
+	end
+
+	@native function Object:FireServer(...: A...)
+		queueEvent(queue, sendSchema, {...}, actionId, 0, networkType)
+	end
+	return Object
+end
+
+local function createNetworkObject<A..., B...>(info: NetworkInfo<A..., B...>): NetworkEvent<A...>
+	if isServer then
+		return createObjServer(info)
+	else
+		return createObjClient(info)
+	end
+end
+
+local function getServerQueue(): Queue
+	return {
+		QueueSize = 0,
+		ByteSize = 0,
+		TempBuffer = getBuffer(),
+		Instances = {},
+	}
+end
+
+local function start()
+	internalRemote = getRemote("QuickNetRemote")
+	internalUnreliable = getUnreliable("QuickNetUnreliable")
+	if isServer then
+		local function initPlayer(player: Player)
+			serverQueue[player] = getServerQueue()
+			serverQueueUnr[player] = getServerQueue()
+			rateLimitInfo[player] = {}
+		end
+
+		for _, player in Players:GetPlayers() do
+			task.spawn(initPlayer, player)
+		end
+		Players.PlayerAdded:Connect(initPlayer)
+
+		Players.PlayerRemoving:Connect(function(player)
+			local queue = serverQueue[player]
+			local queueUnr = serverQueueUnr[player]
+			recycleBuffer(queue.TempBuffer)
+			recycleBuffer(queueUnr.TempBuffer)
+			serverQueue[player] = nil
+			queueUnr[player] = nil
+			rateLimitInfo[player] = nil
+		end)
+		
+		RunService.PostSimulation:Connect(processQueueServer)
+		internalRemote.OnServerEvent:Connect(remoteListenerServerPcall)
+		internalUnreliable.OnServerEvent:Connect(remoteListenerServerPcall)
+	else
+		RunService.PostSimulation:Connect(processQueueClient)
+		internalRemote.OnClientEvent:Connect(remoteListenerClientPcall)
+		internalUnreliable.OnClientEvent:Connect(remoteListenerClientPcall)
+	end
+end
+
+--public--
+Net.Data = DataTypes
+local enumItems = Serialize.enumItems
+local enumItemsByEnum = Serialize.enumItemsByEnum
+
+function Net:setEnumItems(enums: {EnumItem})
+	local idx = 0
+	table.clear(enumItems)
+	table.clear(enumItemsByEnum)
+	
+	for _, enum in enums do
+		idx += 1
+		enumItems[idx] = enum
+		enumItemsByEnum[enum] = idx
+	end
+end
+
+function Net:setMaxPayloadSize(size: number)
+	maxPayloadSize = size
+end
+
+--[[
+Example usage:
+local data = QuickNet.Data
+
+local myEvent = QuickNet:register("EventName", data.NumberU8, data.String)
+
+local myUnreliable = QuickNet:register("UnreliableName", data.CFrameF32):Unreliable()
+
+local myFunction = QuickNet:register("FunctionName", data.Color3):Response(data.Boolean)
+]]
+function Net:register<A..., B...>(name: string, ...: A...): NetworkEvent<A...>
+	if namesRegistered[name] then
+		errorMsg(name.." already exists (names must be unique)")
+		return
+	end
+	namesRegistered[name] = true
+	local info = {} :: NetworkInfo<A..., B...>
+	info.Name = name
+	local id = getEventId(name)
+	info.Id = id	
+	info.NetworkType = REMOTE_EVENT
+	info.RateLimit = {Max = RATE_LIMIT.Max, Time = RATE_LIMIT.Time}
+	info.SendSchema = getSchema(...)
+	info.Callbacks = {}
+	info.AsyncCallbacks = {}
+	info.OnceCallbacks = {}
+	info.NumOnceCallbacks = 0
+	info.WaitThreads = {}
+	info.ResponseTimeout = INVOKE_TIMEOUT
+	local object = createNetworkObject(info)
+	info.Object = object
+	eventsInfo[id] = info
+	return object
+end
+
+--start module
+start()
+	
+export type QuickNet = typeof(Net)
+
+return Net