@axpecter/lync 2.0.0 → 2.1.0

package/src/transport/Reader.luau

@@ -1,224 +1,232 @@
 --!strict
 --!optimize 2
--- Deserializes incoming buffers and routes by registration kind.
+-- Deserializes incoming buffers with MSB batch dispatch.
 
 local Baseline = require(script.Parent.Parent.internal.Baseline)
 local Channel = require(script.Parent.Parent.internal.Channel)
-local Gate = require(script.Parent.Gate)
+local Gate = require(script.Parent.Parent.transport.Gate)
 local Middleware = require(script.Parent.Parent.internal.Middleware)
 local Registry = require(script.Parent.Parent.internal.Registry)
+local Types = require(script.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.codec.primitive.Varint)
 
-local registryGet = Registry.get
-local gateCheck = Gate.check
-local gateReportDrop = Gate.reportDrop
-
 -- Constants -----------------------------------------------------------
 
 local KIND_PACKET = Registry.KIND_PACKET
 local KIND_REQUEST = Registry.KIND_REQUEST
+local KIND_RESPONSE = Registry.KIND_RESPONSE
 
-local TS_FRAME = Channel.TS_FRAME
-local TS_OFFSET = Channel.TS_OFFSET
-local TS_FULL = Channel.TS_FULL
-
-local MAX_INCOMING = 65536
+-- Private -------------------------------------------------------------
 
-local floor = math.floor
+local band = bit32.band
+local readu8 = buffer.readu8
 
 -- Public --------------------------------------------------------------
 
 local Reader = {}
 
--- Shared incoming-data validation used by both Client and Server receive.
 function Reader.decodeIncoming(data: any): buffer?
     if typeof(data) ~= "buffer" then
         return nil
     end
-    if buffer.len(data) > MAX_INCOMING then
+    local b = data :: buffer
+    local len = buffer.len(b)
+    if len == 0 or len > 65536 then
         return nil
     end
-    return data
+    return b
 end
 
--- Callers wrap this in pcall. Any throw aborts the entire buffer from this source.
 function Reader.process(
     incoming: buffer,
+    incomingLen: number,
     refs: { Instance }?,
     player: Player?,
-    startOffset: number
+    isServer: boolean
 ): ()
-    local length = buffer.len(incoming)
-    local pos = startOffset
-
-    if Baseline.hasDelta then
+    -- Set baseline read key for delta codecs
+    if Baseline.hasDelta() then
         Baseline.setReadKey(player or false)
     end
 
-    local hasReceiveMiddleware = Middleware.hasReceive
-    local isServer = player ~= nil
-    local statsOn = Channel.statsEnabled()
+    local statsEnabled = Channel.statsEnabled()
+    local hasRecvHooks = Middleware.hasReceiveHooks()
+    local pos = 0
 
-    while pos < length do
-        local id = buffer.readu8(incoming, pos)
+    while pos < incomingLen do
+        local raw = readu8(incoming, pos)
         pos += 1
 
-        local reg = registryGet(id)
+        local msb = band(raw, 0x80) ~= 0
+        local id = band(raw, 0x7F)
+
+        local reg = Registry.get(id)
         if not reg then
-            warn(`[Lync] Unknown packet ID {id}`)
+            warn(`[Lync] Reader: unknown packet ID {id} at byte {pos - 1}`)
             break
         end
 
-        local kind = reg.kind
-
-        if kind == KIND_PACKET then
-            if pos + 2 > length then
-                break
-            end
-
-            local count = buffer.readu16(incoming, pos)
-            pos += 2
+        if reg.kind == KIND_PACKET then
+            local count: number
 
-            if count == 0 then
-                continue
+            if msb then
+                count = 1
+            else
+                count = buffer.readu16(incoming, pos)
+                pos += 2
             end
 
-            local codec = reg.codec
-            local signal = reg.signal
-            local batchStart = pos
-            local maxBytes = reg.maxPayloadBytes
-
-            -- Timestamp is per-batch, read once after count
-            local timestamp: number? = nil
+            -- Read timestamp if this packet has one configured
             local tsMode = reg.timestampMode
-            if tsMode == TS_FRAME then
-                timestamp = buffer.readu8(incoming, pos)
+            local tsValue: any = nil
+
+            if tsMode == Channel.TS_FRAME then
+                tsValue = readu8(incoming, pos)
                 pos += 1
-            elseif tsMode == TS_OFFSET then
-                timestamp = buffer.readu16(incoming, pos)
+            elseif tsMode == Channel.TS_OFFSET then
+                tsValue = buffer.readu16(incoming, pos)
                 pos += 2
-            elseif tsMode == TS_FULL then
-                timestamp = buffer.readf64(incoming, pos)
+            elseif tsMode == Channel.TS_FULL then
+                tsValue = buffer.readf64(incoming, pos)
                 pos += 8
             end
 
-            -- Cap count for fixed-size codecs to prevent wasted iterations
-            local fixedSize = (codec :: any)._size
-            if fixedSize and fixedSize > 0 then
-                local maxItems = floor((length - pos) / fixedSize)
+            -- Prevent a malicious count from reading past the buffer
+            if reg.codec._size then
+                local maxItems = (incomingLen - pos) // (reg.codec._size :: number)
                 if count > maxItems then
                     count = maxItems
                 end
             end
 
-            -- Hot path: no gate, no middleware, no byte budget
-            if not (isServer and reg.needsGate) and not hasReceiveMiddleware and not maxBytes then
-                if statsOn then
-                    local batchBytes = 0
-                    for _ = 1, count do
-                        if pos >= length then
-                            break
-                        end
+            for _ = 1, count do
+                local value, consumed = reg.codec.read(incoming, pos, refs)
+                pos += consumed
 
-                        local value, consumed = codec.read(incoming, pos, refs)
-                        pos += consumed
-                        batchBytes += consumed
-                        signal:fire(value, player, timestamp)
-                    end
-                    reg.bytesReceived += batchBytes
-                    reg.recvFires += count
-                else
-                    for _ = 1, count do
-                        if pos >= length then
-                            break
+                if isServer and reg.needsGate then
+                    if player and not Gate.checkGlobalRateLimit(player) then
+                        if statsEnabled then
+                            reg.drops += 1
                         end
-
-                        local value, consumed = codec.read(incoming, pos, refs)
-                        pos += consumed
-                        signal:fire(value, player, timestamp)
-                    end
-                end
-            else
-                -- Cold path: gate and/or middleware and/or byte budget active
-                local baseName = reg.baseName
-                local needsGate = isServer and reg.needsGate
-                local batchBytes = if statsOn then 0 else nil
-                local recvCount = if statsOn then 0 else nil
-
-                for _ = 1, count do
-                    if pos >= length then
-                        break
-                    end
-
-                    if maxBytes and (pos - batchStart) > maxBytes then
-                        gateReportDrop(player, "size", reg.name, nil)
-                        break
+                        Middleware.fireDrop(player :: Player, "rate", reg.name, value)
+                        continue
                     end
 
-                    local value, consumed = codec.read(incoming, pos, refs)
-                    pos += consumed
-
-                    if batchBytes then
-                        batchBytes += consumed
-                        recvCount += 1
+                    if player and not Gate.checkRateLimit(reg, player) then
+                        if statsEnabled then
+                            reg.drops += 1
+                        end
+                        Middleware.fireDrop(player :: Player, "rate", reg.name, value)
+                        continue
                     end
 
-                    if needsGate and not gateCheck(value, reg, player :: Player) then
+                    local ok, reason = Gate.validate(value, reg.codec)
+                    if not ok then
+                        if statsEnabled then
+                            reg.drops += 1
+                        end
+                        if player then
+                            Middleware.fireDrop(player, "validation", reg.name, value)
+                        end
                         continue
                     end
 
-                    if hasReceiveMiddleware then
-                        local final = Middleware.runReceive(value, baseName, player)
-                        if final == nil then
+                    if reg.validate then
+                        local valid, validReason = reg.validate(value, player :: Player)
+                        if not valid then
+                            if statsEnabled then
+                                reg.drops += 1
+                            end
+                            Middleware.fireDrop(
+                                player :: Player,
+                                validReason or "validate",
+                                reg.name,
+                                value
+                            )
                             continue
                         end
-                        signal:fire(final, player, timestamp)
-                    else
-                        signal:fire(value, player, timestamp)
                     end
                 end
-                if batchBytes then
-                    reg.bytesReceived += batchBytes
-                    reg.recvFires += recvCount :: number
+
+                if hasRecvHooks then
+                    value = Middleware.runReceive(value, reg.name, player)
+                end
+
+                if statsEnabled then
+                    reg.recvFires += 1
+                end
+
+                if tsValue ~= nil then
+                    reg.signal:fire(value, player, tsValue)
+                else
+                    reg.signal:fire(value, player)
                 end
             end
-        else
-            -- Query frame: id(u8, already read) + correlationId(varint) + status(u8)
-            if pos + 2 > length then
-                break
+
+            if statsEnabled then
+                -- Approximate: counts all bytes consumed in this frame, not just payload
+                reg.bytesReceived += pos
             end
+        elseif reg.kind == KIND_REQUEST or reg.kind == KIND_RESPONSE then
+            -- MSB distinguishes nil responses (no payload) from data responses
+            local corrId, corrBytes = Varint.read(incoming, pos)
+            pos += corrBytes
 
-            local queryCodec = reg.codec
-            local querySignal = reg.signal
+            if msb then
+                if statsEnabled then
+                    reg.recvFires += 1
+                end
+                reg.signal:fire(nil, player, corrId)
+            else
+                local value, consumed = reg.codec.read(incoming, pos, refs)
+                pos += consumed
 
-            local correlationId, corrBytes = Varint.read(incoming, pos)
-            pos += corrBytes
-            local status = buffer.readu8(incoming, pos)
-            pos += 1
+                if isServer and reg.needsGate and reg.kind == KIND_REQUEST then
+                    if player and not Gate.checkRateLimit(reg, player) then
+                        if statsEnabled then
+                            reg.drops += 1
+                        end
+                        Middleware.fireDrop(player :: Player, "rate", reg.name, value)
+                        continue
+                    end
 
-            if status == 1 then
-                querySignal:fire(nil, player, correlationId)
-                continue
-            end
+                    local ok, reason = Gate.validate(value, reg.codec)
+                    if not ok then
+                        if statsEnabled then
+                            reg.drops += 1
+                        end
+                        if player then
+                            Middleware.fireDrop(player, "validation", reg.name, value)
+                        end
+                        continue
+                    end
 
-            local value, consumed = queryCodec.read(incoming, pos, refs)
-            pos += consumed
+                    if reg.validate then
+                        local valid, validReason = reg.validate(value, player :: Player)
+                        if not valid then
+                            if statsEnabled then
+                                reg.drops += 1
+                            end
+                            Middleware.fireDrop(
+                                player :: Player,
+                                validReason or "validate",
+                                reg.name,
+                                value
+                            )
+                            continue
+                        end
+                    end
+                end
 
-            if isServer and reg.needsGate and not gateCheck(value, reg, player :: Player) then
-                continue
-            end
+                if hasRecvHooks then
+                    value = Middleware.runReceive(value, reg.name, player)
+                end
 
-            local final: any
-            if hasReceiveMiddleware then
-                final = Middleware.runReceive(value, reg.baseName, player)
-                if final == nil then
-                    continue
+                if statsEnabled then
+                    reg.recvFires += 1
                 end
-            else
-                final = value
+                reg.signal:fire(value, player, corrId)
             end
-
-            querySignal:fire(final, player, correlationId)
         end
     end
 end