@axpecter/lync 1.5.2 → 2.0.0

package/src/transport/Client.luau

@@ -12,6 +12,7 @@ local Types = require(script.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
+type Registration = Types.Registration
 
 -- State ---------------------------------------------------------------
 
@@ -22,6 +23,16 @@ local _unreliable = nil :: ChannelState?
 local _prevRecv = nil :: buffer?
 local _isStarted = false
 
+-- Flush control
+local _flushRate = 60
+local _flushInterval = 1 / 60
+local _useAccumulator = false
+local _flushAccum = 0
+local _flushedThisFrame = false
+
+-- Timestamp
+local _frameCounter: number = 0
+
 -- Private -------------------------------------------------------------
 
 local function receive(data: any, refs: any, applyXor: boolean): ()
@@ -64,6 +75,11 @@ local function flushChannel(remote: any, ch: ChannelState, applyXor: boolean): (
 end
 
 local function flush(): ()
+    if Channel.hasTimestamps() then
+        _frameCounter = (_frameCounter + 1) % 256
+        Channel.updateTimestamp(_frameCounter, 0, os.clock())
+    end
+
     flushChannel(Bridge.reliable, _reliable :: ChannelState, true)
     flushChannel(Bridge.unreliable, _unreliable :: ChannelState, false)
 end
@@ -89,23 +105,39 @@ function Client.start(): ()
     Bridge.unreliable.OnClientEvent:Connect(function(data: any, refs: any): ()
         receive(data, refs, false)
     end)
-    RunService.Heartbeat:Connect(flush)
+
+    if _useAccumulator then
+        RunService.Heartbeat:Connect(function(dt: number)
+            if _flushedThisFrame then
+                _flushedThisFrame = false
+                return
+            end
+            _flushAccum += dt
+            if _flushAccum < _flushInterval then
+                return
+            end
+            _flushAccum -= _flushInterval
+            flush()
+        end)
+    else
+        RunService.Heartbeat:Connect(function()
+            if _flushedThisFrame then
+                _flushedThisFrame = false
+                return
+            end
+            flush()
+        end)
+    end
 end
 
-function Client.write(
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
+function Client.write(reg: Registration, data: any, isUnreliable: boolean): ()
     if not _isStarted then
         error(NOT_STARTED)
     end
 
     local final: any
     if Middleware.hasSend then
-        final = Middleware.runSend(data, name, nil)
+        final = Middleware.runSend(data, reg.name, nil)
         if final == nil then
             return
         end
@@ -114,10 +146,16 @@ function Client.write(
     end
 
     local ch = if isUnreliable then _unreliable :: ChannelState else _reliable :: ChannelState
-    Channel.writeBatch(ch, id, name, codec, final)
+    if Channel.statsEnabled() then
+        local before = ch.cursor
+        Channel.writeBatch(ch, reg, final)
+        reg.bytesSent += ch.cursor - before
+        reg.fires += 1
+    else
+        Channel.writeBatch(ch, reg, final)
+    end
 end
 
--- Shared for both query requests and responses(identical wire format).
 function Client.writeQuery(
     id: number,
     name: string,
@@ -149,4 +187,20 @@ function Client.writeQueryNil(id: number, name: string, correlationId: number):
     Channel.writeQuery(_reliable :: ChannelState, id, name, correlationId, nil, nil)
 end
 
+function Client.flush(): ()
+    _flushAccum = 0
+    _flushedThisFrame = true
+    flush()
+end
+
+function Client.setFlushRate(hz: number): ()
+    _flushRate = math.clamp(hz, 1, 60)
+    _flushInterval = 1 / _flushRate
+    _useAccumulator = _flushRate < 60
+end
+
+function Client.getFlushRate(): number
+    return _flushRate
+end
+
 return table.freeze(Client)

package/src/transport/Gate.luau

@@ -162,11 +162,17 @@ end
 
 function Gate.check(value: any, reg: Registration, player: Player): boolean
     if not checkRate(player, reg) then
+        if reg.drops then
+            reg.drops += 1
+        end
         fireDrop(player, "rate", reg.name, nil)
         return false
     end
 
     if not isClean(value, 1) then
+        if reg.drops then
+            reg.drops += 1
+        end
         fireDrop(player, "nan", reg.name, value)
         return false
     end
@@ -175,6 +181,9 @@ function Gate.check(value: any, reg: Registration, player: Player): boolean
     if validate then
         local ok, reason = validate(value, player)
         if not ok then
+            if reg.drops then
+                reg.drops += 1
+            end
             fireDrop(player, reason or "validate", reg.name, value)
             return false
         end

package/src/transport/Reader.luau

@@ -3,9 +3,11 @@
 -- Deserializes incoming buffers and routes by registration kind.
 
 local Baseline = require(script.Parent.Parent.internal.Baseline)
+local Channel = require(script.Parent.Parent.internal.Channel)
 local Gate = require(script.Parent.Gate)
 local Middleware = require(script.Parent.Parent.internal.Middleware)
 local Registry = require(script.Parent.Parent.internal.Registry)
+local Varint = require(script.Parent.Parent.codec.primitive.Varint)
 
 local registryGet = Registry.get
 local gateCheck = Gate.check
@@ -16,8 +18,14 @@ local gateReportDrop = Gate.reportDrop
 local KIND_PACKET = Registry.KIND_PACKET
 local KIND_REQUEST = Registry.KIND_REQUEST
 
+local TS_FRAME = Channel.TS_FRAME
+local TS_OFFSET = Channel.TS_OFFSET
+local TS_FULL = Channel.TS_FULL
+
 local MAX_INCOMING = 65536
 
+local floor = math.floor
+
 -- Public --------------------------------------------------------------
 
 local Reader = {}
@@ -47,9 +55,9 @@ function Reader.process(
         Baseline.setReadKey(player or false)
     end
 
-    -- Cache flags once per frame-buffer, not per packet
     local hasReceiveMiddleware = Middleware.hasReceive
     local isServer = player ~= nil
+    local statsOn = Channel.statsEnabled()
 
     while pos < length do
         local id = buffer.readu8(incoming, pos)
@@ -80,21 +88,62 @@ function Reader.process(
             local batchStart = pos
             local maxBytes = reg.maxPayloadBytes
 
+            -- Timestamp is per-batch, read once after count
+            local timestamp: number? = nil
+            local tsMode = reg.timestampMode
+            if tsMode == TS_FRAME then
+                timestamp = buffer.readu8(incoming, pos)
+                pos += 1
+            elseif tsMode == TS_OFFSET then
+                timestamp = buffer.readu16(incoming, pos)
+                pos += 2
+            elseif tsMode == TS_FULL then
+                timestamp = 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)
+                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
-                for _ = 1, count do
-                    if pos >= length then
-                        break
+                if statsOn then
+                    local batchBytes = 0
+                    for _ = 1, count do
+                        if pos >= length then
+                            break
+                        end
+
+                        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
+                        end
 
-                    local value, consumed = codec.read(incoming, pos, refs)
-                    pos += consumed
-                    signal:fire(value, player)
+                        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
@@ -109,6 +158,11 @@ function Reader.process(
                     local value, consumed = codec.read(incoming, pos, refs)
                     pos += consumed
 
+                    if batchBytes then
+                        batchBytes += consumed
+                        recvCount += 1
+                    end
+
                     if needsGate and not gateCheck(value, reg, player :: Player) then
                         continue
                     end
@@ -118,31 +172,32 @@ function Reader.process(
                         if final == nil then
                             continue
                         end
-                        signal:fire(final, player)
+                        signal:fire(final, player, timestamp)
                     else
-                        signal:fire(value, player)
+                        signal:fire(value, player, timestamp)
                     end
                 end
+                if batchBytes then
+                    reg.bytesReceived += batchBytes
+                    reg.recvFires += recvCount :: number
+                end
             end
         else
-            -- Query frame: id(u8, already read) + correlationId(u16) + status(u8) = 3 more bytes
-            if pos + 3 > length then
+            -- Query frame: id(u8, already read) + correlationId(varint) + status(u8)
+            if pos + 2 > length then
                 break
             end
 
             local queryCodec = reg.codec
             local querySignal = reg.signal
 
-            local correlationId = buffer.readu16(incoming, pos)
-            local status = buffer.readu8(incoming, pos + 2)
-            pos += 3
+            local correlationId, corrBytes = Varint.read(incoming, pos)
+            pos += corrBytes
+            local status = buffer.readu8(incoming, pos)
+            pos += 1
 
             if status == 1 then
-                if kind == KIND_REQUEST then
-                    querySignal:fire(nil, player, correlationId)
-                else
-                    querySignal:fire(nil, player, correlationId)
-                end
+                querySignal:fire(nil, player, correlationId)
                 continue
             end
 
@@ -163,11 +218,7 @@ function Reader.process(
                 final = value
             end
 
-            if kind == KIND_REQUEST then
-                querySignal:fire(final, player, correlationId)
-            else
-                querySignal:fire(final, player, correlationId)
-            end
+            querySignal:fire(final, player, correlationId)
         end
     end
 end