.github/workflows/deploy.yml

@@ -18,16 +18,16 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Setup Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v3
         with:
           node-version: 20
           cache: npm
       - name: Setup Pages
-        uses: actions/configure-pages@v4
+        uses: actions/configure-pages@v3
       - name: Install dependencies
         run: npm ci
       - name: Build
@@ -35,9 +35,9 @@ jobs:
           npm run docs:build
           touch docs/.vitepress/dist
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@v2
         with:
           path: docs/.vitepress/dist
       - name: Deploy
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v2

docs/.vitepress/config.mts

@@ -39,6 +39,7 @@ function side() {
             text: 'Utilities',
             items: [
               { text: 'Signal', link: '/api/1.0/signal' },
+              { text: 'Buffer', link: '/api/1.0/buffer' },
             ]
           },
         ]

docs/api/1.0/buffer.md

@@ -0,0 +1,3 @@
+# Buffer <Badge type="tip" text="utilities" />
+
+A Additional buffer.

docs/api/1.0/ratelimit.md

@@ -13,10 +13,8 @@ When creating a event on Server, you can add second argument (optional) as table
 -- Server
 -- Let's make the event have ratelimit with max 50 entrance for 2 seconds.
 local Remote = Warp.Server("Remote1", {
-	rateLimit = {
-		maxEntrance = 50, -- maximum 50 fires.
-		interval = 2, -- 2 seconds
-	}
+	maxEntrance = 50, -- maximum 50 fires.
+	interval = 2, -- 2 seconds
 })
 -- Now the Event RateLimit is configured, and ready to use.
 -- No need anything to adds on client side.

docs/api/1.0/server.md

@@ -36,16 +36,12 @@ Create new Warp events with array.
 ```lua [Example]
 local Events = Warp.fromServerArray({
 	["Remote1"] = {
-		rateLimit = {
-			maxEntrance: 50,
-			interval: 1,
-		}
+		maxEntrance: 50,
+		interval: 1,
 	}, -- with rateLimit configuration
 	"Remote2", -- without rateLimit configuration
 	["Remote3"] = {
-		rateLimit = {
-			maxEntrance: 10,
-		}
+		maxEntrance: 10,
 	}, -- with rateLimit configuration
 })
 

docs/api/1.0/signal.md

@@ -102,23 +102,7 @@ Signal1:DisconnectAll()
 
 ## `:Fire`
 
-Fire the signal (Immediate)
-
-::: code-group
-```lua [Variable]
-(
-	...: any
-)
-```
-
-```lua [Example]
-Signal1:Fire("Hello World!")
-```
-:::
-
-## `:DeferFire`
-
-Fire the signal (Deferred)
+Fire the signal.
 
 ::: code-group
 ```lua [Variable]
@@ -138,7 +122,7 @@ This uses `pcall`, which means it never error (safe-mode, sacrificed debugging),
 
 ## `:FireTo`
 
-Fire to other signal, this uses `:Fire`.
+Fire to other signal, this also use `:Fire`.
 
 ::: code-group
 ```lua [Variable]

docs/guide/example.md

@@ -67,5 +67,4 @@ Pong:Disconnect(connection1)
 Pong:Destroy()
 
 -- Yay Done!
-```
-:::
+```

docs/guide/installation.md

@@ -8,7 +8,7 @@
 ::: code-group
 ```toml [wally.toml]
 [dependencies]
-warp = "imezx/warp@1.0.13"
+warp = "imezx/warp@1.0.5"
 ```
 
 3. Run `wally install` in command.

src/Index/Client/ClientProcess/Logger.luau

@@ -0,0 +1,34 @@
+--!strict
+--!native
+--!optimize 2
+local Logger = {}
+local Logs: {
+	[string]: {
+		[string]: string
+	}
+} = {}
+local logging: {
+	[string]: boolean
+} = {}
+
+local now = tick()
+
+function Logger.write(Identifier: string, text: string, log: boolean?)
+	if not Logs[Identifier] then
+		Logs[Identifier] = {}
+	end
+	if log ~= nil then
+		logging[Identifier] = log
+	end
+	now = tick()
+	Logs[Identifier][tostring(now)] = text
+	if logging[Identifier] then
+		print(`[{now}] ->`, text)
+	end
+end
+
+function Logger.read(Identifier: string)
+	return Logs[Identifier]
+end
+
+return Logger

src/Index/Client/ClientProcess/init.luau

@@ -12,14 +12,17 @@ local Spawn = require(Util.Spawn)
 local Key = require(Util.Key)
 local RateLimit = require(Util.RateLimit)
 local Buffer = require(Util.Buffer)
+local Logger = require(script.Logger)
 
 local clientRatelimit: Type.StoredRatelimit = {}
 local clientQueue: Type.QueueMap = {}
 local unreliableClientQueue: Type.QueueMap = {}
 local clientCallback: Type.CallbackMap = {}
 local clientRequestQueue: Type.QueueMap = {}
-local registeredIdentifier: { [string]: boolean } = {}
 
+local queueIn: {
+	[string]: {any}
+} = {}
 local queueInRequest: {
 	[number]: {
 		[string]: {
@@ -34,6 +37,14 @@ local queueOutRequest: {
 		}
 	}
 } = {}
+local incoming_cache: {
+	[string]: {
+		any
+	}
+} = {}
+local logger: {
+	[string]: boolean
+} = {}
 
 queueInRequest[1] = {}
 queueInRequest[2] = {}
@@ -75,9 +86,10 @@ function ClientProcess.insertRequest(Identifier: string, timeout: number, ...: a
 end
 
 function ClientProcess.add(Identifier: any, originId: string, conf: Type.ClientConf)
-	if not registeredIdentifier[Identifier] then
-		registeredIdentifier[Identifier] = true
-
+	if not clientQueue[Identifier] then
+		if conf.logging then
+			ClientProcess.logger(Identifier, conf.logging.store, conf.logging.opt)
+		end
 		if not clientRatelimit[Identifier] then
 			clientRatelimit[Identifier] = RateLimit.create(originId)
 		end
@@ -106,69 +118,59 @@ function ClientProcess.add(Identifier: any, originId: string, conf: Type.ClientC
 		if not queueInRequest[2][Identifier] then
 			queueInRequest[2][Identifier] = {}
 		end
+		if not queueIn[Identifier] then
+			queueIn[Identifier] = {}
+		end
 	end
 end
 
-function ClientProcess.remove(Identifier: string)
-	if not registeredIdentifier[Identifier] then return end
-	registeredIdentifier[Identifier] = nil
-	clientQueue[Identifier] = nil
-	unreliableClientQueue[Identifier] = nil
-	clientRequestQueue[Identifier] = nil
-	clientCallback[Identifier] = nil
-	clientRatelimit[Identifier] = nil
-	queueOutRequest[1][Identifier] = nil
-	queueOutRequest[2][Identifier] = nil
-	queueInRequest[1][Identifier] = nil
-	queueInRequest[2][Identifier] = nil
+function ClientProcess.logger(Identifier: string, store: boolean, log: boolean)
+	logger[Identifier] = store
+	Logger.write(Identifier, `state: change -> {log == true and "enabled" or "disabled"} logger.`, log)
+end
+
+function ClientProcess.getlogs(Identifier: string)
+	return Logger.read(Identifier)
 end
 
 function ClientProcess.addCallback(Identifier: string, key: string, callback)
 	clientCallback[Identifier][key] = callback
+	if logger[Identifier] then
+		task.defer(Logger.write, Identifier, `state: change -> new callback added.`)
+	end
 end
 
 function ClientProcess.removeCallback(Identifier: string, key: string)
 	clientCallback[Identifier][key] = nil
+	if logger[Identifier] then
+		task.defer(Logger.write, Identifier, `state: change -> removed a callback.`)
+	end
 end
 
 function ClientProcess.start()
 	debug.setmemorycategory("Warp")
 	RunService.PostSimulation:Connect(function()
-		-- Unreliable
 		for Identifier: string, data: any in unreliableClientQueue do
 			if #data == 0 then continue end
 			if clientRatelimit[Identifier](#data) then
-				for _, unpacked in data do
-					UnreliableEvent:FireServer(Buffer.revert(Identifier), Buffer.write(unpacked))
+				UnreliableEvent:FireServer(Buffer.revert(Identifier), data)
+				if logger[Identifier] then
+					task.defer(Logger.write, Identifier, `state: out -> unreliable -> {#data} data.`)
 				end
 			end
 			unreliableClientQueue[Identifier] = nil
 		end
-		-- Reliable
 		for Identifier: string, data: any in clientQueue do
+			local callback = clientCallback[Identifier] or nil
 			if #data > 0 then
 				if clientRatelimit[Identifier](#data) then
-					for _, unpacked in data do
-						ReliableEvent:FireServer(Buffer.revert(Identifier), Buffer.write(unpacked))
+					ReliableEvent:FireServer(Buffer.revert(Identifier), data)
+					if logger[Identifier] then
+						task.defer(Logger.write, Identifier, `state: out -> reliable -> {#data} data.`)
 					end
 				end
 				clientQueue[Identifier] = nil
 			end
-		end
-		-- Sent new invokes
-		for Identifier: string, requestsData in queueOutRequest[1] do
-			if #requestsData == 0 then continue end
-			RequestEvent:FireServer(Buffer.revert(Identifier), "\1", requestsData)
-			queueOutRequest[1][Identifier] = nil
-		end
-		-- Sent returning invokes
-		for Identifier: string, toReturnDatas in queueOutRequest[2] do
-			if #toReturnDatas == 0 then continue end
-			RequestEvent:FireServer(Buffer.revert(Identifier), "\0", toReturnDatas)
-			queueOutRequest[2][Identifier] = nil
-		end
-
-		for Identifier: string in registeredIdentifier do
 			if clientRequestQueue[Identifier] then
 				for _, requestData in clientRequestQueue[Identifier] do
 					if not requestData[3] then continue end
@@ -176,70 +178,108 @@ function ClientProcess.start()
 						queueOutRequest[1][Identifier] = {}
 					end
 					table.insert(queueOutRequest[1][Identifier], { requestData[1], requestData[3] })
-					requestData[3] = nil
 				end
+				clientRequestQueue[Identifier] = nil
 			end
-
-			-- Unreliable & Reliable
-			local callback = clientCallback[Identifier] or nil
-			if not callback then continue end
-
-			-- Return Invoke
-			if queueInRequest[1][Identifier] then
-				for _, packetDatas: any in queueInRequest[1][Identifier] do
-					if #packetDatas == 0 then continue end
-					for _, fn: any in callback do
-						for i=1,#packetDatas do
-							if not packetDatas[i] then continue end
-							local packetData1 = packetDatas[i][1]
-							local packetData2 = packetDatas[i][2]
-							Spawn(function()
-								local requestReturn = { fn(table.unpack(packetData2)) }
-								if not queueOutRequest[2][Identifier] then
-									queueOutRequest[2][Identifier] = {}
-								end
-								table.insert(queueOutRequest[2][Identifier], { packetData1,  requestReturn })
-								packetData1 = nil
-								packetData2 = nil
-							end)
+			if callback then
+				if incoming_cache[Identifier] then
+					for _, packet in incoming_cache[Identifier] do
+						if #packet == 0 then continue end
+						for _, fn: any in callback do
+							for i=1,#packet do
+								Spawn(fn, table.unpack(packet[i] or {}))
+							end
 						end
 					end
+					incoming_cache[Identifier] = nil
 				end
-				queueInRequest[1][Identifier] = nil
-			end
-
-			-- Call to Invoke
-			if queueInRequest[2][Identifier] then
-				if clientRequestQueue[Identifier] then
-					for _, packetDatas: any in queueInRequest[2][Identifier] do
-						for _, packetData in packetDatas do
-							if #packetData == 1 then continue end
-							for y=1,#clientRequestQueue[Identifier] do
-								local clientRequest = clientRequestQueue[Identifier][y]
-								if not clientRequest then continue end
-								if clientRequest[1] == packetData[1] then
-									Spawn(clientRequest[2], table.unpack(packetData[2]))
-									table.remove(clientRequestQueue[Identifier], y)
-									break
+				if queueIn[Identifier] then
+					for _, packedDatas: any in queueIn[Identifier] do
+						if #packedDatas == 0 then continue end
+						for _, fn: any in callback do
+							for i=1,#packedDatas do
+								Spawn(fn, table.unpack(packedDatas[i] or {}))
+							end
+						end
+					end
+					queueIn[Identifier] = nil
+				end
+				if queueInRequest[1][Identifier] then
+					for _, packetDatas: any in queueInRequest[1][Identifier] do
+						if #packetDatas == 0 then continue end
+						for _, fn: any in callback do
+							for i=1,#packetDatas do
+								local packetData = packetDatas[i]
+								if not packetData then continue end
+								Spawn(function()
+									local requestReturn = { fn(table.unpack(packetData[2])) }
+									if not queueOutRequest[2][Identifier] then
+										queueOutRequest[2][Identifier] = {}
+									end
+									table.insert(queueOutRequest[2][Identifier], { packetData[1],  requestReturn })
+								end)
+							end
+						end
+					end
+					queueInRequest[1][Identifier] = nil
+				end
+				if queueInRequest[2][Identifier] then
+					if clientRequestQueue[Identifier] then
+						for _, packetDatas: any in queueInRequest[2][Identifier] do
+							for _, packetData in packetDatas do
+								if #packetData == 1 then continue end
+								for y=1,#clientRequestQueue[Identifier] do
+									local clientRequest = clientRequestQueue[Identifier][y]
+									if not clientRequest then continue end
+									if clientRequest[1] == packetData[1] then
+										Spawn(clientRequest[2], table.unpack(packetData[2]))
+										table.remove(clientRequestQueue[Identifier], y)
+										break
+									end
 								end
 							end
 						end
 					end
+					queueInRequest[2][Identifier] = nil
 				end
-				queueInRequest[2][Identifier] = nil
 			end
 		end
+		for Identifier: string, requestsData in queueOutRequest[1] do
+			if #requestsData == 0 then continue end
+			RequestEvent:FireServer(Buffer.revert(Identifier), "\1", requestsData)
+			if logger[Identifier] then
+				task.defer(Logger.write, Identifier, `state: out -> request -> {#requestsData} data.`)
+			end
+			queueOutRequest[1][Identifier] = nil
+		end
+		for Identifier: string, toReturnDatas in queueOutRequest[2] do
+			if #toReturnDatas == 0 then continue end
+			RequestEvent:FireServer(Buffer.revert(Identifier), "\0", toReturnDatas)
+			if logger[Identifier] then
+				task.defer(Logger.write, Identifier, `state: out -> return request -> {#toReturnDatas} data.`)
+			end
+			queueOutRequest[2][Identifier] = nil
+		end
 	end)
-	local function onClientNetworkReceive(Identifier: buffer | string, data: buffer, ref: { any }?)
-		if not Identifier or typeof(Identifier) ~= "buffer" or not data or typeof(data) ~= "buffer" then return end
+	local function onClientNetworkReceive(Identifier: any, data: any)
+		if not Identifier or not data then return end
 		Identifier = Buffer.convert(Identifier)
-		if not registeredIdentifier[Identifier :: string] then return end
-		local read = Buffer.read(data, ref)
-		if not read then return end
-		local callback = clientCallback[Identifier :: string]
-		if not callback then return end
-		for _, fn: any in callback do
-			Spawn(fn, table.unpack(read))
+		if not queueIn[Identifier] then
+			queueIn[Identifier] = {}
+		end
+		if not clientCallback[Identifier] then
+			if not incoming_cache[Identifier] then
+				incoming_cache[Identifier] = {}
+			end
+			table.insert(incoming_cache[Identifier], data)
+			if logger[Identifier] then
+				task.defer(Logger.write, Identifier, `state: cache -> net -> {#data} data.`)
+			end
+			return
+		end
+		table.insert(queueIn[Identifier], data)
+		if logger[Identifier] then
+			task.defer(Logger.write, Identifier, `state: in -> net -> {#data} data.`)
 		end
 	end
 	ReliableEvent.OnClientEvent:Connect(onClientNetworkReceive)
@@ -258,6 +298,9 @@ function ClientProcess.start()
 			end
 			table.insert(queueInRequest[2][Identifier], data)
 		end
+		if logger[Identifier] then
+			task.defer(Logger.write, Identifier, `state: in -> request -> {#data} data.`)
+		end
 	end)
 end
 

src/Index/Client/Index.luau

@@ -18,18 +18,23 @@ function Client.new(Identifier: string, conf: Type.ClientConf?)
 	local self = setmetatable({}, Client)
 
 	self._buffer = Buffer.new()
-	self._buffer:wu8(Serdes.increment(Identifier, conf and conf.yieldWait))
+	self._buffer:wu8(Serdes(Identifier, conf and conf.yieldWait))
 	self.id = Buffer.convert(self._buffer:build())
 	self.fn = {}
 	self._conf = table.freeze(conf or {})
 	self.IsConnected = false
 
-	ClientProcess.add(self.id, Identifier, conf or { yieldWait = 10 })
+	ClientProcess.add(self.id, Identifier, conf or { yieldWait = 10, logging = { store = false, opt = false } })
 	self._buffer:remove()
 
 	return self
 end
 
+function Client:logs()
+	Assert(self._conf.logging, "[Client]: Event is not configured with logging.")
+	return ClientProcess.getlogs(self.id)
+end
+
 function Client:Fire(reliable: boolean,...: any)
 	ClientProcess.insertQueue(self.id, reliable, ...)
 end
@@ -50,7 +55,7 @@ function Client:Once(callback: (args: any) -> ()): string
 	local key = tostring(Key())
 	table.insert(self.fn, key)
 	self.IsConnected = #self.fn > 0
-	ClientProcess.addCallback(self.id, key, function(...: any?)
+	ClientProcess.addCallback(self.id, key, function(...)
 		self:Disconnect(key)
 		task.spawn(callback, ...)
 	end)
@@ -71,19 +76,16 @@ function Client:DisconnectAll()
 	end
 end
 
-function Client:Disconnect(key: string)
+function Client:Disconnect(key: string): boolean
 	Assert(typeof(key) == "string", "Key must be a string type.")
 	ClientProcess.removeCallback(self.id, key)
 	table.remove(self.fn, table.find(self.fn, key))
 	self.IsConnected = #self.fn > 0
+	return table.find(self.fn, key) == nil
 end
 
 function Client:Destroy()
 	self:DisconnectAll()
-	self._buffer:remove()
-	ClientProcess.remove(self.id)
-	Serdes.decrement()
-	table.clear(self)
 	setmetatable(self, nil)
 end
 

src/Index/Event.luau

@@ -1,4 +1,5 @@
 --!strict
+--!native
 --!optimize 2
 local RunService = game:GetService("RunService")
 local Type = require(script.Parent.Type)

src/Index/Server/Index.luau

@@ -18,7 +18,7 @@ function Server.new(Identifier: string, conf: Type.ServerConf?)
 	local self = setmetatable({}, Server)
 
 	self._buffer = Buffer.new()
-	self._buffer:wu8(Serdes.increment(Identifier))
+	self._buffer:wu8(Serdes(Identifier))
 	self.id = Buffer.convert(self._buffer:build())
 	self.fn = {}
 	self._conf = table.freeze(conf or {})
@@ -30,6 +30,11 @@ function Server.new(Identifier: string, conf: Type.ServerConf?)
 	return self
 end
 
+function Server:logs()
+	Assert(self._conf.logging, "[Server]: Event is not configured with logging.")
+	return ServerProcess.getlogs(self.id)
+end
+
 function Server:Fire(reliable: boolean, player: Player, ...: any)
 	ServerProcess.insertQueue(self.id, reliable, player, ...)
 end
@@ -70,9 +75,9 @@ function Server:Once(callback: (plyer: Player, args: any) -> ()): string
 	local key = tostring(Key())
 	table.insert(self.fn, key)
 	self.IsConnected = #self.fn > 0
-	ServerProcess.addCallback(self.id, key, function(player: Player, ...: any?)
+	ServerProcess.addCallback(self.id, key, function(...)
 		self:Disconnect(key)
-		task.spawn(callback, player, ...)
+		task.spawn(callback, ...)
 	end)
 	return key
 end
@@ -101,10 +106,6 @@ end
 
 function Server:Destroy()
 	self:DisconnectAll()
-	self._buffer:remove()
-	ServerProcess.remove(self.id)
-	Serdes.decrement()
-	table.clear(self)
 	setmetatable(self, nil)
 end
 

src/Index/Server/ServerProcess/Logger.luau

@@ -0,0 +1,34 @@
+--!strict
+--!native
+--!optimize 2
+local Logger = {}
+local Logs: {
+	[string]: {
+		[string]: string
+	}
+} = {}
+local logging: {
+	[string]: boolean
+} = {}
+
+local now = tick()
+
+function Logger.write(Identifier: string, text: string, log: boolean?)
+	if not Logs[Identifier] then
+		Logs[Identifier] = {}
+	end
+	if log ~= nil then
+		logging[Identifier] = log
+	end
+	now = tick()
+	Logs[Identifier][tostring(now)] = text
+	if logging[Identifier] then
+		print(`[{now}] ->`, text)
+	end
+end
+
+function Logger.read(Identifier: string)
+	return Logs[Identifier]
+end
+
+return Logger

src/Index/Server/ServerProcess/init.luau

@@ -13,18 +13,24 @@ local Spawn = require(Util.Spawn)
 local Key = require(Util.Key)
 local RateLimit = require(Util.RateLimit)
 local Buffer = require(Util.Buffer)
+local Logger = require(script.Logger)
 
 local serverQueue: Type.QueueMap = {}
 local unreliableServerQueue: Type.QueueMap = {}
 local serverCallback: Type.CallbackMap = {}
 local serverRequestQueue: Type.QueueMap = {}
-local registeredIdentifier: { [string]: boolean } = {}
+local registeredIdentifier: { string } = {}
 
 local queueOut: {
 	[Player]: {
 		[string]: {any},
 	}
 } = {}
+local queueIn: {
+	[string]: {
+		[Player]: {any},
+	}
+} = {}
 local queueInRequest: {
 	[number]: {
 		[string]: {
@@ -39,6 +45,12 @@ local queueOutRequest: {
 		}
 	}
 } = {}
+local logger: {
+	[string]: boolean
+} = {}
+local players: {
+	Player
+} = {}
 
 queueInRequest[1] = {}
 queueInRequest[2] = {}
@@ -49,29 +61,22 @@ local ReliableEvent = Event.Reliable
 local UnreliableEvent = Event.Unreliable
 local RequestEvent = Event.Request
 
-RateLimit.Protect()
-
 local function initializeEachPlayer(player: Player)
 	if not player then return end
 	if not queueOut[player] then
 		queueOut[player] = {}
 	end
-	for Identifier: string in registeredIdentifier do
+
+	for _, Identifier: string in registeredIdentifier do
 		if not player then break end
 		if not queueOut[player][Identifier] then
 			queueOut[player][Identifier] = {}
 		end
-		if not serverRequestQueue[Identifier] then
-			serverRequestQueue[Identifier] = {}
-		end
 		if not serverRequestQueue[Identifier][player] then
 			serverRequestQueue[Identifier][player] = {}
 		end
-		if not queueOutRequest[1][Identifier] then
-			queueOutRequest[1][Identifier] = {}
-		end
-		if not queueOutRequest[2][Identifier] then
-			queueOutRequest[2][Identifier] = {}
+		if not queueIn[Identifier][player] then
+			queueIn[Identifier][player] = {}
 		end
 		if not queueInRequest[1][Identifier][player] then
 			queueInRequest[1][Identifier][player] = {}
@@ -85,44 +90,15 @@ local function initializeEachPlayer(player: Player)
 end
 
 Players.PlayerAdded:Connect(initializeEachPlayer)
-Players.PlayerRemoving:Connect(function(player: Player)
-	if not player then return end
-	if queueOut[player] then
-		queueOut[player] = nil
-	end
-	for _, map in { serverQueue, unreliableServerQueue, serverRequestQueue } do
-		for Identifier: string in map do
-			map[Identifier][player] = nil
-		end
-	end
-	for i=1,2 do
-		for Identifier: string in queueInRequest[i] do
-			if queueInRequest[i][Identifier][player] then
-				queueInRequest[i][Identifier][player] = nil
-			end
-		end
-		for Identifier: string in queueOutRequest[i] do
-			if queueOutRequest[i][Identifier][player] then
-				queueOutRequest[i][Identifier][player] = nil
-			end
-		end
-	end
-end)
 
 function ServerProcess.insertQueue(Identifier: string, reliable: boolean, player: Player, ...: any)
 	if not reliable then
-		if not unreliableServerQueue[Identifier] then
-			unreliableServerQueue[Identifier] = {}
-		end
 		if not unreliableServerQueue[Identifier][player] then
 			unreliableServerQueue[Identifier][player] = {}
 		end
 		table.insert(unreliableServerQueue[Identifier][player], { ... })
 		return
 	end
-	if not serverQueue[Identifier] then
-		serverQueue[Identifier] = {}
-	end
 	if not serverQueue[Identifier][player] then
 		serverQueue[Identifier][player] = {}
 	end
@@ -130,12 +106,12 @@ function ServerProcess.insertQueue(Identifier: string, reliable: boolean, player
 end
 
 function ServerProcess.insertRequest(Identifier: string, timeout: number, player: Player, ...: any)
+	if not serverQueue[Identifier][player] then
+		serverQueue[Identifier][player] = {}
+	end
 	if not serverRequestQueue[Identifier] then
 		serverRequestQueue[Identifier] = {}
 	end
-	if not serverRequestQueue[Identifier][player] then
-		serverRequestQueue[Identifier][player] = {}
-	end
 	local yieldThread: thread, start = coroutine.running(), os.clock()
 	local cancel = task.delay(timeout, function()
 		task.spawn(yieldThread, nil)
@@ -149,11 +125,12 @@ function ServerProcess.insertRequest(Identifier: string, timeout: number, player
 end
 
 function ServerProcess.add(Identifier: string, originId: string, conf: Type.ServerConf)
-	if not registeredIdentifier[Identifier] then
-		registeredIdentifier[Identifier] = true
-
+	if not table.find(registeredIdentifier, Identifier) then
+		table.insert(registeredIdentifier, Identifier)
 		RateLimit.create(originId, conf.rateLimit and conf.rateLimit.maxEntrance or 200, conf.rateLimit and conf.rateLimit.interval or 2)
-
+		if conf.logging then
+			ServerProcess.logger(Identifier, conf.logging.store, conf.logging.opt)
+		end
 		if not serverQueue[Identifier] then
 			serverQueue[Identifier] = {}
 		end
@@ -167,6 +144,9 @@ function ServerProcess.add(Identifier: string, originId: string, conf: Type.Serv
 			unreliableServerQueue[Identifier] = {}
 		end
 
+		if not queueIn[Identifier] then
+			queueIn[Identifier] = {}
+		end
 		if not queueInRequest[1][Identifier] then
 			queueInRequest[1][Identifier] = {}
 		end
@@ -186,158 +166,160 @@ function ServerProcess.add(Identifier: string, originId: string, conf: Type.Serv
 	end
 end
 
-function ServerProcess.remove(Identifier: string)
-	if not registeredIdentifier[Identifier] then return end
-	registeredIdentifier[Identifier] = nil
-	serverQueue[Identifier] = nil
-	serverRequestQueue[Identifier] = nil
-	serverCallback[Identifier] = nil
-	unreliableServerQueue[Identifier] = nil
-	queueInRequest[1][Identifier] = nil
-	queueInRequest[2][Identifier] = nil
-	queueOutRequest[1][Identifier] = nil
-	queueOutRequest[2][Identifier] = nil
+function ServerProcess.logger(Identifier: string, store: boolean, log: boolean)
+	logger[Identifier] = store
+	Logger.write(Identifier, `state: change -> {log == true and "enabled" or "disabled"} logger.`, log)
+end
+
+function ServerProcess.getlogs(Identifier: string)
+	return Logger.read(Identifier)
 end
 
 function ServerProcess.addCallback(Identifier: string, key: string, callback)
 	serverCallback[Identifier][key] = callback
+	if logger[Identifier] then
+		task.defer(Logger.write, Identifier, `state: change -> new callback added.`)
+	end
 end
 
 function ServerProcess.removeCallback(Identifier: string, key: string)
 	serverCallback[Identifier][key] = nil
+	if logger[Identifier] then
+		task.defer(Logger.write, Identifier, `state: change -> removed a callback.`)
+	end
 end
 
 function ServerProcess.start()
 	debug.setmemorycategory("Warp")
 	RunService.PostSimulation:Connect(function()
-		-- Unreliable
 		for Identifier: string, players in unreliableServerQueue do
 			for player: Player, content: any in players do
 				if #content == 0 then continue end
-				for _, unpacked in content do
-					UnreliableEvent:FireClient(player, Buffer.revert(Identifier), Buffer.write(unpacked))
+				UnreliableEvent:FireClient(player, Buffer.revert(Identifier), content)
+				if logger[Identifier] then
+					task.defer(Logger.write, Identifier, `state: out -> unreliable -> {#content} data.`)
 				end
 				unreliableServerQueue[Identifier][player] = nil
 			end
-			unreliableServerQueue[Identifier] = nil
 		end
-		-- Reliable
+
 		for Identifier: string, contents: { [Player]: { any } } in serverQueue do
-			for player, content: any in contents do
-				if #content > 0 and queueOut[player] then
-					for _, unpacked in content do
-						ReliableEvent:FireClient(player, Buffer.revert(Identifier), Buffer.write(unpacked))
-					end
-				end
-				serverQueue[Identifier][player] = nil
-			end
-			serverQueue[Identifier] = nil
-		end
-		-- Sent new invokes
-		for Identifier: string, contents in queueOutRequest[1] do
-			for player: Player, requestsData: any in contents do
+			
+			for player: Player, requestsData: any in queueOutRequest[1][Identifier] do
 				if #requestsData > 0 then
 					RequestEvent:FireClient(player, Buffer.revert(Identifier), "\1", requestsData)
+					if logger[Identifier] then
+						task.defer(Logger.write, Identifier, `state: out -> request -> {#requestsData} data.`)
+					end
 				end
 				queueOutRequest[1][Identifier][player] = nil
 			end
-			queueOutRequest[1][Identifier] = nil
-		end
-		-- Sent returning invokes
-		for Identifier: string, contents in queueOutRequest[2] do
-			for player: Player, toReturnDatas: any in contents do
+			
+			for player: Player, toReturnDatas: any in queueOutRequest[2][Identifier] do
 				if #toReturnDatas > 0 then
 					RequestEvent:FireClient(player, Buffer.revert(Identifier), "\0", toReturnDatas)
+					if logger[Identifier] then
+						task.defer(Logger.write, Identifier, `state: out -> return request -> {#toReturnDatas} data.`)
+					end
 				end
 				queueOutRequest[2][Identifier][player] = nil
 			end
-			queueOutRequest[2][Identifier] = nil
-		end
-
-		for Identifier: string in registeredIdentifier do
-			if serverRequestQueue[Identifier] then
-				for player, content in serverRequestQueue[Identifier] do
-					if #content == 0 then serverRequestQueue[Identifier][player] = nil continue end
-					for _, requestData in content do
+			
+			local callback = serverCallback[Identifier] or nil
+			for player, content: any in contents do
+				if #content > 0 and queueOut[player] then
+					ReliableEvent:FireClient(player, Buffer.revert(Identifier), content)
+				end
+				serverQueue[Identifier][player] = nil
+				
+				if serverRequestQueue[Identifier][player] then
+					for _, requestData in serverRequestQueue[Identifier][player] do
 						if not requestData[3] then continue end
-						if not queueOutRequest[1][Identifier] then
-							queueOutRequest[1][Identifier] = {}
-						end
 						if not queueOutRequest[1][Identifier][player] then
 							queueOutRequest[1][Identifier][player] = {}
 						end
 						table.insert(queueOutRequest[1][Identifier][player], { requestData[1], requestData[3] })
-						requestData[3] = nil
 					end
+					serverRequestQueue[Identifier][player] = nil
 				end
-			end
+				
+				if callback then
+					local requestIn1: any = queueInRequest[1][Identifier][player]
+					local requestIn2: any = queueInRequest[2][Identifier][player]
+					local incoming: any = queueIn[Identifier][player]
 
-			local callback = serverCallback[Identifier] or nil
-			if not callback then continue end
-
-			-- Return Invoke
-			for player, content in queueInRequest[1][Identifier] do
-				if not callback then break end
-				for _, packetDatas in content do
-					if not callback then break end
-					if #packetDatas == 0 then continue end
-					for _, fn: any in callback do
-						for i=1,#packetDatas do
-							if not packetDatas[i] then continue end
-							local packetData1 = packetDatas[i][1]
-							local packetData2 = packetDatas[i][2]
-							Spawn(function()
-								local requestReturn = { fn(player, table.unpack(packetData2)) }
-								if not queueOutRequest[2][Identifier] then
-									queueOutRequest[2][Identifier] = {}
+					if incoming then
+						for _, packedDatas: any in incoming do
+							if #packedDatas == 0 then continue end
+							for _, fn: any in callback do
+								for i=1,#packedDatas do
+									Spawn(fn, player, table.unpack(packedDatas[i] or {}))
 								end
-								if not queueOutRequest[2][Identifier][player] then
-									queueOutRequest[2][Identifier][player] = {}
-								end
-								table.insert(queueOutRequest[2][Identifier][player], { packetData1, requestReturn })
-								packetData1 = nil
-								packetData2 = nil
-							end)
-						end
-					end
-				end
-				queueInRequest[1][Identifier][player] = nil
-			end
-
-			-- Call to Invoke
-			for player, content in queueInRequest[2][Identifier] do
-				if not callback then break end
-				for _, packetDatas in content do
-					for _, packetData in packetDatas do
-						if not callback then break end
-						if #packetData == 1 then continue end
-						local data = serverRequestQueue[Identifier][player]
-						for i=1,#data do
-							local serverRequest = data[i]
-							if not serverRequest then continue end
-							if serverRequest[1] == packetData[1] then
-								Spawn(serverRequest[2], table.unpack(packetData[2]))
-								table.remove(data, i)
-								break
 							end
 						end
+						incoming = nil
+						queueIn[Identifier][player] = nil
+					end
+					if requestIn1 then
+						for _, packetDatas: any in requestIn1 do
+							if #packetDatas == 0 then continue end
+							for _, fn: any in callback do
+								for i=1,#packetDatas do
+									local packetData = packetDatas[i]
+									if not packetData then continue end
+									Spawn(function()
+										local requestReturn = { fn(player, table.unpack(packetData[2])) }
+										local state = queueOutRequest[2][Identifier][player]
+										if not queueOutRequest[2][Identifier][player] then
+											queueOutRequest[2][Identifier][player] = {}
+										end
+										table.insert(queueOutRequest[2][Identifier][player], { packetData[1], requestReturn })
+									end)
+								end
+							end
+						end
+						requestIn1 = nil
+						queueInRequest[1][Identifier][player] = nil
+					end
+					if requestIn2 then
+						for _, packetDatas: any in requestIn2 do
+							for _, packetData in packetDatas do
+								if #packetData == 1 then continue end
+								local data = serverRequestQueue[Identifier][player]
+								for i=1,#data do
+									local serverRequest = data[i]
+									if not serverRequest then continue end
+									if serverRequest[1] == packetData[1] then
+										Spawn(serverRequest[2], table.unpack(packetData[2]))
+										table.remove(data, i)
+										break
+									end
+								end
+							end
+						end
+						requestIn2 = nil
+						queueInRequest[2][Identifier][player] = nil
 					end
 				end
-				queueInRequest[2][Identifier][player] = nil
 			end
 		end
 	end)
-	local function onServerNetworkReceive(player: Player, Identifier: buffer | string, data: buffer, ref: { any }?)
-		if not Identifier or typeof(Identifier) ~= "buffer" or not data or typeof(data) ~= "buffer" then return end
-		Identifier = Buffer.convert(Identifier :: buffer)
-		if not registeredIdentifier[Identifier :: string] then return end
-		local read = Buffer.read(data, ref)
-		if not read then return end
-		local callback = serverCallback[Identifier :: string]
-		if not callback then return end
-		for _, fn: any in callback do
-			Spawn(fn, player, table.unpack(read))
+	local function onServerNetworkReceive(player: Player, Identifier: any, data: any)
+		if not Identifier or not data then return end
+		Identifier = Buffer.convert(Identifier)
+		if not serverQueue[Identifier] then
+			serverQueue[Identifier] = {}
 		end
+		if not serverQueue[Identifier][player] then
+			serverQueue[Identifier][player] = {}
+		end
+		if not queueIn[Identifier][player] then
+			queueIn[Identifier][player] = {}
+		end
+		if logger[Identifier] then
+			task.defer(Logger.write, Identifier, `state: in -> net -> {#data} data.`)
+		end
+		table.insert(queueIn[Identifier][player], data)
 	end
 	ReliableEvent.OnServerEvent:Connect(onServerNetworkReceive)
 	UnreliableEvent.OnServerEvent:Connect(onServerNetworkReceive)
@@ -346,13 +328,8 @@ function ServerProcess.start()
 		Identifier = Buffer.convert(Identifier)
 		if not queueInRequest[1][Identifier][player] then
 			queueInRequest[1][Identifier][player] = {}
-		end
-		if not queueInRequest[2][Identifier][player] then
 			queueInRequest[2][Identifier][player] = {}
 		end
-		if not serverQueue[Identifier] then
-			serverQueue[Identifier] = {}
-		end
 		if not serverQueue[Identifier][player] then
 			serverQueue[Identifier][player] = {}
 		end
@@ -361,6 +338,9 @@ function ServerProcess.start()
 		else
 			table.insert(queueInRequest[2][Identifier][player], data)
 		end
+		if logger[Identifier] then
+			task.defer(Logger.write, Identifier, `state: in -> request -> {#data} data.`)
+		end
 	end)
 end
 

src/Index/Signal/Dedicated.luau

@@ -12,7 +12,6 @@ function Dedicated.new(signal: any, handler: (...any) -> ())
 end
 
 function Dedicated:Disconnect()
-	table.clear(self)
 	setmetatable(self, nil)
 end
 

src/Index/Signal/init.luau

@@ -22,15 +22,15 @@ function Signal.new(Identifier: string)
 	return Signals[Identifier]
 end
 
-function Signal:Connect(fn: (...any) -> (), optKey: string?): string
-	local key: typeof(Signal) = optKey or tostring(Key()) :: any
+function Signal:Connect(fn: (...any) -> ()): string
+	local key = tostring(Key())
 	self[key] = DedicatedSignal(self, fn)
-	return key :: any
+	return key
 end
 
 function Signal:Once(fn: (...any) -> ()): string
 	local key: string
-	key = self:Connect(function(...: any)
+	key = self:Connect(function(...)
 		self:Disconnect(key)
 		task.spawn(fn, ...)
 	end)
@@ -38,9 +38,7 @@ function Signal:Once(fn: (...any) -> ()): string
 end
 
 function Signal:Disconnect(key: string)
-	if not self[key] then return end
 	self[key]:Disconnect()
-	self[key] = nil
 end
 
 function Signal:DisconnectAll(): ()
@@ -48,19 +46,13 @@ function Signal:DisconnectAll(): ()
 end
 
 function Signal:Wait(): number
-	local t, thread = os.clock(), coroutine.running()
+	local thread, t = coroutine.running(), os.clock()
 	self:Once(function()
 		task.spawn(thread, os.clock()-t)
 	end)
 	return coroutine.yield()
 end
 
-function Signal:DeferFire(...: any): ()
-	for _, handle in self do
-		task.defer(handle.fn, ...)
-	end
-end
-
 function Signal:Fire(...: any): ()
 	for _, handle in self do
 		task.spawn(handle.fn, ...)

src/Index/Type.luau

@@ -4,41 +4,44 @@ type rateLimitArg = {
 	interval: number?,
 }
 
+type logging = {
+	store: boolean,
+	opt: boolean,
+}
+
 export type ServerConf = {
 	rateLimit: rateLimitArg?,
+	logging: logging?,
 }
 
 export type ClientConf = {
 	yieldWait: number?,
-}
-
-export type Middleware = {
-	middleware: (self: Middleware, middleware: (...any) -> (...any)) -> (),
-	key: (self: Middleware) -> string,
-	destroy: (self: Middleware) -> (),
+	logging: logging?,
 }
 
 export type Client = {
 	Fire: (self: Client, reliable: boolean, ...any) -> (),
 	Invoke: (self: Client, timeout: number, ...any) -> any,
-	Connect: (self: Client, callback: (...any) -> ()) -> Middleware,
-	Once: (self: Client, callback: (player: Player, ...any) -> ()) -> Middleware,
+	Connect: (self: Client, callback: (...any) -> ()) -> string,
+	Once: (self: Client, callback: (player: Player, ...any) -> ()) -> string,
 	Disconnect: (self: Client, key: string) -> (),
 	DisconnectAll: (self: Client) -> (),
 	Wait: (self: Client) -> number,
 	Destroy: (self: Client) -> (),
+	logs: (self: Client) -> any,
 }
 
 export type Server = {
 	Fire: (self: Server, reliable: boolean, player: Player, ...any) -> (),
 	Fires: (self: Server, reliable: boolean, ...any) -> (),
 	Invoke: (self: Server, timeout: number, player: Player, ...any) -> any,
-	Connect: (self: Server, callback: (player: Player, ...any) -> ()) -> Middleware,
-	Once: (self: Server, callback: (player: Player, ...any) -> ()) -> Middleware,
+	Connect: (self: Server, callback: (player: Player, ...any) -> ()) -> string,
+	Once: (self: Server, callback: (player: Player, ...any) -> ()) -> string,
 	Disconnect: (self: Server, key: string) -> (),
 	DisconnectAll: (self: Server) -> (),
 	Wait: (self: Server) -> number,
 	Destroy: (self: Server) -> (),
+	logs: (self: Server) -> any,
 }
 
 export type Signal = {

src/Index/Util/Assert.luau

@@ -1,6 +1,6 @@
 --!strict
 --!native
 --!optimize 2
-return function(condition: (any), errorMessage: string, level: number?): ()
-	if not (condition) then error(`Warp: {errorMessage}`, level or 2) end
+return function(condition: (any), errorMessage: string?): ()
+	if not (condition) then error(`Warp: {errorMessage}`, 2) end
 end

src/Index/Util/Buffer/Dedicated.luau

@@ -16,7 +16,7 @@ local writef32 = buffer.writef32
 local writef64 = buffer.writef64
 local writestring = buffer.writestring
 
-local default: { [string]: number } = {
+local default = {
 	point = 0,
 	next = 0,
 	size = 128,
@@ -35,16 +35,17 @@ function DedicatedBuffer.alloc(self: any, byte: number)
 	local size: number = self.size
 	local b: buffer = self.buffer
 
-	while self.next + byte >= size do
-		size = math.floor(size * 1.25) -- +25% increase
+
+	while self.point + byte >= size do
+		size = math.floor(size * 1.5)
 	end
+
 	local newBuffer: buffer = create(size)
 	copy(newBuffer, 0, b)
 
 	b = newBuffer
 
 	self.point  = self.next
-	self.buffer = b
 	self.next += byte
 end
 
@@ -56,62 +57,51 @@ function DedicatedBuffer.build(self: any): buffer
 	return build
 end
 
-function DedicatedBuffer.buildAndRemove(self: any): (buffer, (any)?)
-	local p: number = self.next > self.point and self.next or self.point
-	local build: buffer = create(p)
-	local ref = #self.ref > 0 and table.clone(self.ref) or nil
-
-	copy(build, 0, self.buffer, 0, p)
-
-	self:remove()
-	return build, ref
-end
-
-function DedicatedBuffer.wi8(self: any, val: number, alloc: number?)
+function DedicatedBuffer.wi8(self: any, val: number)
 	if not val then return end
-	self:alloc(alloc or 1)
+	self:alloc(1)
 	writei8(self.buffer, self.point, val)
 end
 
-function DedicatedBuffer.wi16(self: any, val: number, alloc: number?)
+function DedicatedBuffer.wi16(self: any, val: number)
 	if not val then return end
-	self:alloc(alloc or 2)
+	self:alloc(2)
 	writei16(self.buffer, self.point, val)
 end
 
-function DedicatedBuffer.wi32(self: any, val: number, alloc: number?)
+function DedicatedBuffer.wi32(self: any, val: number)
 	if not val then return end
-	self:alloc(alloc or 4)
+	self:alloc(4)
 	writei32(self.buffer, self.point, val)
 end
 
-function DedicatedBuffer.wu8(self: any, val: number, alloc: number?)
+function DedicatedBuffer.wu8(self: any, val: number)
 	if not val then return end
-	self:alloc(alloc or 1)
+	self:alloc(1)
 	writeu8(self.buffer, self.point, val)
 end
 
-function  DedicatedBuffer.wu16(self: any, val: number, alloc: number?)
+function  DedicatedBuffer.wu16(self: any, val: number)
 	if not val then return end
-	self:alloc(alloc or 2)
+	self:alloc(2)
 	writeu16(self.buffer, self.point, val)
 end
 
-function DedicatedBuffer.wu32(self: any, val: number, alloc: number?)
+function DedicatedBuffer.wu32(self: any, val: number)
 	if not val then return end
-	self:alloc(alloc or 4)
+	self:alloc(4)
 	writeu32(self.buffer, self.point, val)
 end
 
-function DedicatedBuffer.wf32(self: any, val: number, alloc: number?)
+function DedicatedBuffer.wf32(self: any, val: number)
 	if not val then return end
-	self:alloc(alloc or 4)
+	self:alloc(4)
 	writef32(self.buffer, self.point, val)
 end
 
-function DedicatedBuffer.wf64(self: any, val: number, alloc: number?)
+function DedicatedBuffer.wf64(self: any, val: number)
 	if not val then return end
-	self:alloc(alloc or 8)
+	self:alloc(8)
 	writef64(self.buffer, self.point, val)
 end
 
@@ -121,127 +111,11 @@ function DedicatedBuffer.wstring(self: any, val: string)
 	writestring(self.buffer, self.point, val)
 end
 
-function DedicatedBuffer.wType(self: any, ref: number)
-	writeu8(self.buffer, self.point, ref)
-	self.point += 1
-end
-
-function DedicatedBuffer.wRef(self: any, value: any, alloc: number?)
-	if not value then return end
-	self:alloc(alloc or 1)
-	table.insert(self.ref, value)
-	local index = #self.ref
-	writeu8(self.buffer, self.point, index)
-	self.point += 1
-end
-
-function DedicatedBuffer.pack(self: any, data: {any})
-	if typeof(data) == "nil" then
-		self:wi8(0)
-	elseif typeof(data) == "Instance" then
-		self:wi8(-1) -- Instance marker
-		self:wRef(data)
-	elseif typeof(data) == "table" then
-		--local isArray = (next(data) ~= nil and #data > 0) and true or false
-		local isArray = true
-		local count = 0
-		for k in data do
-			count += 1
-			if typeof(k) ~= "number" or math.floor(k) ~= k then
-				isArray = false
-			end
-		end
-		if isArray then
-			self:wi8(-2) -- array marker
-			self:wu16(count) -- use 32-bit length
-			for _, v in data do
-				self:pack(v)
-			end
-		else
-			self:wi8(-3) -- dictionary marker
-			self:wu16(count) -- number of key-value pairs
-			for k, v in data do
-				self:pack(k) -- pack the key
-				self:pack(v) -- pack the value
-			end
-		end
-	elseif typeof(data) == "EnumItem" then
-		self:wi8(-4)
-		self:wi8(#`{data.EnumType}`)
-		self:wstring(`{data.EnumType}`)
-		self:wu8(data.Value)
-	elseif typeof(data) == "BrickColor" then
-		self:wi8(-5)
-		self:wi16(data.Number)
-	elseif typeof(data) == "Enum" then
-		self:wi8(-6)
-		self:wi8(#`{data}`)
-		self:wstring(`{data}`)
-	elseif typeof(data) == "number" then
-		if math.floor(data) == data then -- Integer
-			if data >= 0 and data <= 255 then
-				self:wi8(1) -- u8 marker
-				self:wu8(data)
-			elseif data >= -32768 and data <= 32767 then
-				self:wi8(2) -- i16 marker
-				self:wi16(data)
-			elseif data >= -2147483647 and data <= 2147483647 then
-				self:wi8(3) -- i32 marker
-				self:wi32(data)
-			else
-				self:wi8(4) -- f64 marker
-				self:wf64(data)
-			end
-		else
-			self:wi8(4) -- f64 marker
-			self:wf64(data)
-		end
-	elseif typeof(data) == "boolean" then
-		self:wi8(5) -- boolean marker
-		self:wu8(data and 1 or 0)
-	elseif typeof(data) == "string" then
-		local length = #data
-		if length <= 255 then
-			self:wi8(6)
-			self:wu8(length)
-		elseif length <= 65535 then
-			self:wi8(7)
-			self:wu16(length)
-		else
-			self:wi8(8)
-			self:wi32(length)
-		end
-		self:wstring(data)
-	elseif typeof(data) == "Vector3" then
-		self:wi8(9) -- Vector3 marker
-		self:wf32(data.X)
-		self:wf32(data.Y)
-		self:wf32(data.Z)
-	elseif typeof(data) == "Vector2" then
-		self:wi8(10) -- Vector2 marker
-		self:wf32(data.X)
-		self:wf32(data.Y)
-	elseif typeof(data) == "CFrame" then
-		self:wi8(11) -- CFrame marker
-		for _, v in {data:GetComponents()} do
-			self:wf32(v)
-		end
-	elseif typeof(data) == "Color3" then
-		self:wi8(12) -- Color3 marker
-		self:wu8(data.R * 255)
-		self:wu8(data.G * 255)
-		self:wu8(data.B * 255)
-	else
-		warn(`Unsupported data type: {typeof(data)} value: {data}`)
-	end
-end
-
 function DedicatedBuffer.flush(self: any)
 	self.point = default.point
 	self.next = default.next
 	self.size = default.size
 	self.buffer = create(default.bufferSize)
-	table.clear(self.ref)
 end
 
 function DedicatedBuffer.new()
@@ -249,17 +123,13 @@ function DedicatedBuffer.new()
 		point = default.point,
 		next = default.next,
 		size = default.size,
-		buffer = create(default.bufferSize),
-		ref = {},
+		buffer = create(default.bufferSize)
 	}, DedicatedBuffer)
 end
 
 function DedicatedBuffer.remove(self: any)
 	self:flush()
-	table.clear(self)
 	setmetatable(self, nil)
 end
 
-export type DedicatedType = typeof(DedicatedBuffer.new())
-
 return DedicatedBuffer.new :: typeof(DedicatedBuffer.new)

src/Index/Util/Buffer/init.luau

@@ -8,115 +8,8 @@ local Dedicated = require(script.Dedicated)
 
 local tostring = buffer.tostring
 local fromstring = buffer.fromstring
-local readu8 = buffer.readu8
-local readi8 = buffer.readi8
-local readu16 = buffer.readu16
-local readi16 = buffer.readi16
-local readi32 = buffer.readi32
-local readf32 = buffer.readf32
-local readf64 = buffer.readf64
-local readstring = buffer.readstring
-local len = buffer.len
 
-local function readValue(b: buffer, position: number, ref: { any }?): (any, number)
-	local typeByte = readi8(b, position)
-	position += 1
-	if typeByte == 0 then -- nil
-		return nil, position
-	elseif typeByte == -1 then -- Instance
-		if not ref or #ref == 0 then
-			return nil, position + 1
-		end
-		local value = ref[readu8(b, position)]
-		if typeof(value) == "Instance" then
-			return value, position + 1
-		end
-		return nil, position + 1
-	elseif typeByte == -2 then -- array
-		local length = readu16(b, position)
-		position += 2
-		local array = {}
-		for _ = 1, length do
-			local value
-			value, position = readValue(b, position, ref)
-			table.insert(array, value)
-		end
-		return array, position
-	elseif typeByte == -3 then -- dictionary
-		local length = readu16(b, position)
-		position += 2
-		local dict = {}
-		for _ = 1, length do
-			local key, value
-			key, position = readValue(b, position, ref)
-			value, position = readValue(b, position, ref)
-			dict[key] = value
-		end
-		return dict, position
-	elseif typeByte == -4 then -- EnumItem
-		local length = readi8(b, position)
-		local value = readstring(b, position + 1, length)
-		local value2 = readu8(b, position + 1 + length)
-		return Enum[value]:FromValue(value2), position + 2 + length
-	elseif typeByte == -5 then -- BrickColor
-		local value = readi16(b, position)
-		return BrickColor.new(value), position + 2
-	elseif typeByte == -6 then -- Enum
-		local length = readi8(b, position)
-		local value = readstring(b, position + 1, length)
-		return Enum[value], position + 1 + length
-	elseif typeByte == 1 then -- int u8
-		local value = readu8(b, position)
-		return value, position + 1
-	elseif typeByte == 2 then -- int i16
-		local value = readi16(b, position)
-		return value, position + 2
-	elseif typeByte == 3 then -- int i32
-		local value = readi32(b, position)
-		return value, position + 4
-	elseif typeByte == 4 then -- f64
-		local value = readf64(b, position)
-		return value, position + 8
-	elseif typeByte == 5 then -- boolean
-		local value = readu8(b, position) == 1
-		return value, position + 1
-	elseif typeByte == 6 then -- string u8
-		local length = readu8(b, position)
-		local value = readstring(b, position + 1, length)
-		return value, position + length + 1
-	elseif typeByte == 7 then -- string u16
-		local length = readu16(b, position)
-		local value = readstring(b, position + 2, length)
-		return value, position + length + 2
-	elseif typeByte == 8 then -- string i32
-		local length = readi32(b, position)
-		local value = readstring(b, position + 4, length)
-		return value, position + length + 4
-	elseif typeByte == 9 then -- Vector3
-		local x = readf32(b, position)
-		local y = readf32(b, position + 4)
-		local z = readf32(b, position + 8)
-		return Vector3.new(x, y, z), position + 12
-	elseif typeByte == 10 then -- Vector2
-		local x = readf32(b, position)
-		local y = readf32(b, position + 8)
-		return Vector2.new(x, y), position + 8
-	elseif typeByte == 11 then -- CFrame
-		local components = {}
-		for i = 1, 12 do
-			table.insert(components, readf32(b, position + (i - 1) * 4))
-		end
-		return CFrame.new(unpack(components)), position + 48
-	elseif typeByte == 12 then -- Color3
-		local r = readu8(b, position)
-		local g = readu8(b, position + 1)
-		local b = readu8(b, position + 2)
-		return Color3.fromRGB(r, g, b), position + 3
-	end
-	error(`Unsupported type marker: {typeByte}`)
-end
-
-function Buffer.new(): Dedicated.DedicatedType
+function Buffer.new()
 	return Dedicated()
 end
 
@@ -128,22 +21,4 @@ function Buffer.revert(s: string): buffer
 	return fromstring(s)
 end
 
-function Buffer.write(data: { any }): (buffer, (any)?)
-	local newBuffer = Dedicated()
-	newBuffer:pack(data)
-	return newBuffer:buildAndRemove()
-end
-
-function Buffer.read(b: buffer, ref: { any }?): any?
-	local position = 0
-	local result = {}
-	while position < len(b) do
-		local value
-		value, position = readValue(b, position, ref)
-		table.insert(result, value)
-	end
-	ref = nil
-	return table.unpack(result)
-end
-
 return Buffer :: typeof(Buffer)

src/Index/Util/Key.luau

@@ -1,5 +1,6 @@
 --!strict
+--!native
 --!optimize 2
 return function(): number?
-	return tonumber(string.sub(tostring(Random.new():NextNumber()), 3, 8)) -- 6 digits
+	return tonumber(string.sub(tostring(Random.new():NextNumber()), 3, 6)) -- 4 digits
 end

src/Index/Util/RateLimit.luau

@@ -1,54 +1,25 @@
 --!strict
+--!native
 --!optimize 2
 local RateLimit = {}
 
 local RunService = game:GetService("RunService")
 local Assert = require(script.Parent.Assert)
-local Events = require(script.Parent.Parent.Event)
-local Reliable, Unreliable, Request = Events.Reliable, Events.Unreliable, Events.Request
-local Signal = require(script.Parent.Parent.Signal)("Warp_OnSpamSignal")
-
-local map, activity, meta = {}, {}, {}
-setmetatable(meta , {
-	__index = map,
-	__newindex  = function(self, key, value)
-		if not activity[key] then
-			activity[key] = os.clock()
-		end
-		if (os.clock()-activity[key]) >= 1 then
-			activity[key] = os.clock()
-			map[key] = 1
-			return
-		end
-		if value >= 1e2 then -- 100
-			Signal:Fire(key)
-			return
-		end
-		map[key] = value
-	end,
-})
-
-local function onReceived(player: Player)
-	if not meta[player] then
-		meta[player] = 1
-		return
-	end
-	meta[player] += 1
-end
+local Event = require(script.Parent.Parent.Event).Reliable
 
 function RateLimit.create(Identifier: string, entrance: number?, interval: number?)
 	Assert(typeof(Identifier) == "string", "Identifier must a string type.")
 	if RunService:IsServer() then
 		Assert(typeof(entrance) == "number", "entrance must a number type.")
 		Assert(entrance :: number > 0, "entrance must above 0.")
-		Reliable:SetAttribute(Identifier.."_ent", entrance)
-		Reliable:SetAttribute(Identifier.."_int", interval)
+		Event:SetAttribute(Identifier.."_ent", entrance)
+		Event:SetAttribute(Identifier.."_int", interval)
 	else
-		while (not Reliable:GetAttribute(Identifier.."_ent")) or (not Reliable:GetAttribute(Identifier.."_int")) do
-			task.wait(0.1)
+		while (not Event:GetAttribute(Identifier.."_ent")) or (not Event:GetAttribute(Identifier.."_int")) do
+			task.wait(0.5)
 		end
-		entrance = tonumber(Reliable:GetAttribute(Identifier.."_ent"))
-		interval = tonumber(Reliable:GetAttribute(Identifier.."_int"))
+		entrance = tonumber(Event:GetAttribute(Identifier.."_ent"))
+		interval = tonumber(Event:GetAttribute(Identifier.."_int"))
 	end
 	local entrances: number = 0
 	return function(incoming: number?): boolean
@@ -62,14 +33,4 @@ function RateLimit.create(Identifier: string, entrance: number?, interval: numbe
 	end
 end
 
-function RateLimit.Protect()
-	if not RunService:IsServer() or Reliable:GetAttribute("Protected") or Unreliable:GetAttribute("Protected") or Request:GetAttribute("Protected") then return end
-	Reliable:SetAttribute("Protected", true)
-	Unreliable:SetAttribute("Protected", true)
-	Request:SetAttribute("Protected", true)
-	Reliable.OnServerEvent:Connect(onReceived)
-	Unreliable.OnServerEvent:Connect(onReceived)
-	Request.OnServerEvent:Connect(onReceived)
-end
-
 return RateLimit :: typeof(RateLimit)

src/Index/Util/Serdes.luau

@@ -1,19 +1,18 @@
 --!strict
+--!native
 --!optimize 2
-local SerDes = {}
 local RunService = game:GetService("RunService")
 local SerInt = 0
 
 local Event = require(script.Parent.Parent.Event).Reliable
 local Assert = require(script.Parent.Assert)
 
-function SerDes.increment(Identifier: string, timeout: number?): number
+return function(Identifier: string, timeout: number?): number
 	Assert(typeof(Identifier) == "string", "Identifier must be a string type.")
+	Assert(SerInt < 255, "reached max 255 identifiers.")
 	if RunService:IsServer() then
-		Assert(SerInt < 255, "reached max 255 identifiers.")
 		if not Event:GetAttribute(Identifier) then
 			SerInt += 1
-			Event:SetAttribute(`{SerInt}`, Identifier)
 			Event:SetAttribute(Identifier, SerInt)
 			--Event:SetAttribute(Identifier, string.pack("I1", SerInt)) -- I1 -> 255 max, I2 -> ~ 6.5e4 max. (SerInt), removed/disabled for buffer migration.
 		end
@@ -21,11 +20,11 @@ function SerDes.increment(Identifier: string, timeout: number?): number
 		local yieldThread: thread = coroutine.running()
 		local cancel = task.delay(timeout or 10, function() -- yield cancelation (timerout)
 			task.spawn(yieldThread, nil)
-			error(`Serdes: {Identifier} is taking too long to retrieve, seems like it's not replicated on server.`, 2)
+			error(`Serdes: {Identifier} is taking too long to retrieve, seems like not replicated on server.`, 2)
 		end)
 		task.spawn(function()
-			while coroutine.status(cancel) ~= "dead" and task.wait(0.04) do -- let it loop for yields! 1/24
-				if Event:GetAttribute(Identifier) then
+			while coroutine.status(cancel) ~= "dead" and task.wait(0.5) do -- let it loop for yields!
+				if (Event:GetAttribute(Identifier)) then
 					task.cancel(cancel)
 					task.spawn(yieldThread, Event:GetAttribute(Identifier))
 					break
@@ -36,15 +35,3 @@ function SerDes.increment(Identifier: string, timeout: number?): number
 	end
 	return Event:GetAttribute(Identifier)
 end
-
-function SerDes.decrement()
-	if not RunService:IsServer() or SerInt <= 0 then return end
-	local Identifier = Event:GetAttribute(`{SerInt}`)
-	if not Identifier then return end
-	Event:SetAttribute(`{Identifier}`, nil)
-	Event:SetAttribute(`{SerInt}`, nil)
-	SerInt -= 1
-	Identifier = nil
-end
-
-return SerDes :: typeof(SerDes)

src/Index/Util/Spawn.luau

@@ -1,21 +1,30 @@
 --!native
 --!strict
 --!optimize 2
-local thread: thread?
+local thread: thread? = nil
 
-local function passer<T...>(func: (T...) -> (), ...: T...): ()
-	local HoldThread: thread = thread :: thread
+local function passer(fn, ...): ()
+	local hold = thread
 	thread = nil
-	func(...)
-	thread = HoldThread
+	fn(...)
+	thread = hold
 end
 
-local function newThread(): ()
-	thread = coroutine.running()
-	while true do passer(coroutine.yield()) end
+local function yield(): never
+	while true do
+		passer(coroutine.yield())
+	end
 end
 
-return function<T...>(func: (T...) -> (), ...: T...): ()
-	if not thread then task.spawn(newThread) end
-	task.spawn(thread :: thread, func, ...)
+if not thread then
+	thread = coroutine.create(yield)
+	coroutine.resume(thread :: any, thread)
+end
+
+return function(fn: (...any) -> (...any?), ...: any): ()
+	if not thread then
+		thread = coroutine.create(yield)
+		coroutine.resume(thread :: any, thread)
+	end
+	task.spawn(thread :: thread, fn, ...)
 end

src/Index/init.luau

@@ -32,32 +32,32 @@ function Index.Client(Identifier: string, conf: Type.ClientConf?): Type.Client
 	return require(Client.Index)(Identifier, conf) :: Type.Client
 end
 
-function Index.fromServerArray(arrays: { string } | { [string]: Type.ServerConf }): Type.fromServerArray
+function Index.fromServerArray(arrays: { any }): Type.fromServerArray
 	Assert(IsServer, `[Warp]: Calling .fromServerArray({arrays}) on client side (expected server side)`)
 	Assert(typeof(arrays) == "table", "[Warp]: Array must be a table type, got {typeof(arrays)}")
-	local copy: { [string]: Type.Server } = {}
-	for param1, param2: string | Type.ServerConf in arrays do
+	local copy = {}
+	for param1: any, param2: any in arrays do
 		if typeof(param2) == "table" then
 			copy[param1] = Index.Server(param1, param2)
 		else
 			copy[param2] = Index.Server(param2)
 		end
 	end
-	return copy
+	return copy :: typeof(copy)
 end
 
-function Index.fromClientArray(arrays: { string } | { [string]: Type.ClientConf }): Type.fromClientArray
+function Index.fromClientArray(arrays: { any }): Type.fromClientArray
 	Assert(not IsServer, `[Warp]: Calling .fromClientArray({arrays}) on server side (expected client side)`)
 	Assert(typeof(arrays) == "table", `[Warp]: Array must be a table type, got {typeof(arrays)}`)
 	local copy = {}
-	for param1, param2: string | Type.ClientConf in arrays do
+	for param1: any, param2: any in arrays do
 		if typeof(param2) == "table" then
 			copy[param1] = Index.Client(param1, param2)
 		else
 			copy[param2] = Index.Client(param2)
 		end
 	end
-	return copy
+	return copy :: typeof(copy)
 end
 
 function Index.Signal(Identifier: string)
@@ -77,4 +77,4 @@ function Index.buffer()
 	return Buffer.new()
 end
 
-return table.freeze(Index) :: typeof(Index)
+return table.freeze(Index) :: typeof(Index)

src/init.luau

@@ -1,5 +1,5 @@
 -- Warp Library (@Eternity_Devs)
--- version 1.0.14
+-- version 1.0.10
 --!strict
 --!native
 --!optimize 2
@@ -11,8 +11,6 @@ return {
 	fromServerArray = Index.fromServerArray,
 	fromClientArray = Index.fromClientArray,
 	
-	OnSpamSignal = Index.OnSpamSignal,
-
 	Signal = Index.Signal,
 	fromSignalArray = Index.fromSignalArray,
 

wally.toml

@@ -1,10 +1,10 @@
 [package]
 name = "imezx/warp"
-version = "1.0.14"
+version = "1.0.10"
 registry = "https://github.com/UpliftGames/wally-index"
 realm = "shared"
 license = "MIT"
-exclude = ["node_modules", "docs", ".github", "*.rbxl", "*.rbxmx", "*.rbxml", "*.rbxm", "TestEZ", "test.project.json"]
+exclude = ["node_modules", "docs", ".github", "*.rbxl", "*.rbxmx", "*.rbxml", "TestEZ", "test.project.json"]
 description = "A very-fast & powerful networking library for Roblox."
 
 [dependencies]