@axpecter/lync 1.5.1 → 2.0.0

package/src/transport/Server.luau

@@ -12,20 +12,29 @@ local Gate = require(script.Parent.Gate)
 local Middleware = require(script.Parent.Parent.internal.Middleware)
 local Pool = require(script.Parent.Parent.internal.Pool)
 local Reader = require(script.Parent.Reader)
+local Registry = require(script.Parent.Parent.internal.Registry)
 local Types = require(script.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
+type Registration = Types.Registration
 
 local channelWriteBatch = Channel.writeBatch
 local channelWriteBatchRaw = Channel.writeBatchRaw
-local channelSetPacket = Channel.setCurrentPacket
+local channelUpdateTimestamp = Channel.updateTimestamp
+local channelStatsEnabled = Channel.statsEnabled
 
 -- State ---------------------------------------------------------------
 
+type PlayerStats = {
+    bytesSent: number,
+    bytesReceived: number,
+}
+
 type PlayerState = {
     reliable: ChannelState,
     unreliable: ChannelState,
+    stats: PlayerStats,
 }
 
 local _players = {} :: { [Player]: PlayerState }
@@ -33,13 +42,47 @@ local _prevRecv = {} :: { [Player]: buffer }
 local _isStarted = false
 local _broadScratch = Channel.create()
 
+-- Flush control
+local _flushRate = 60
+local _flushInterval = 1 / 60
+local _useAccumulator = false
+local _flushAccum = 0
+local _flushedThisFrame = false
+
+-- Timestamp
+local _frameCounter: number = 0
+
+-- Bandwidth strike counter
+local _strikes = {} :: { [Player]: number }
+local _softLimit = 16384
+local _maxStrikes = 10
+
+-- Packet capture
+local _captureEnabled = false
+local _captureLabel = ""
+local _captureFrame = 0
+local _captures = {} :: { any }
+
+local MAX_HEX = 512 -- cap hex dump to first 512 bytes to keep capture size sane
+
+local function bufToHex(buf: buffer, len: number): string
+    local cap = math.min(len, MAX_HEX)
+    local parts = table.create(cap)
+    for i = 0, cap - 1 do
+        parts[i + 1] = string.format("%02x", buffer.readu8(buf, i))
+    end
+    return table.concat(parts)
+end
+
 -- Private -------------------------------------------------------------
 
 local function onPlayerAdded(player: Player): ()
     _players[player] = {
         reliable = Pool.acquire(),
         unreliable = Pool.acquire(),
+        stats = { bytesSent = 0, bytesReceived = 0 },
     }
+    _strikes[player] = 0
     Gate.onPlayerAdded(player)
 end
 
@@ -53,6 +96,7 @@ local function onPlayerRemoving(player: Player): ()
     Pool.release(state.unreliable)
     _players[player] = nil
     _prevRecv[player] = nil
+    _strikes[player] = nil
 
     Gate.onPlayerRemoved(player)
     Baseline.clearSource(player)
@@ -64,6 +108,19 @@ local function receive(player: Player, data: any, refs: any, applyXor: boolean):
         return
     end
 
+    local len = buffer.len(buf)
+    local strikes = _strikes[player] or 0
+    if len > _softLimit then
+        strikes += 1
+    else
+        strikes = math.max(0, strikes - 1)
+    end
+    _strikes[player] = strikes
+    if strikes > _maxStrikes then
+        Gate.reportDrop(player, "bandwidth", "frame", nil)
+        return
+    end
+
     local raw: buffer
     if applyXor then
         raw = Channel.xorApply(buf, _prevRecv[player])
@@ -76,6 +133,15 @@ local function receive(player: Player, data: any, refs: any, applyXor: boolean):
     local ok, err = pcall(Reader.process, raw, safeRefs, player, 0)
     if not ok then
         warn(`[Lync] Read failed from {player.Name} ({player.UserId}): {err}`)
+        strikes = (_strikes[player] or 0) + 1
+        _strikes[player] = strikes
+    end
+
+    if channelStatsEnabled() then
+        local state = _players[player]
+        if state then
+            state.stats.bytesReceived += buffer.len(raw)
+        end
     end
 end
 
@@ -86,18 +152,44 @@ local function flushChannel(remote: any, ch: ChannelState, target: Player, apply
 
     local raw, refs = Channel.sealAndDump(ch)
 
+    local xored: buffer? = nil
     if applyXor then
-        local xored = Channel.xorApply(raw, ch.prevDump)
+        xored = Channel.xorApply(raw, ch.prevDump)
         ch.prevDump = raw
         remote:FireClient(target, xored, refs)
     else
         remote:FireClient(target, raw, refs)
     end
 
+    if _captureEnabled then
+        _captureFrame += 1
+        local rawLen = buffer.len(raw)
+        table.insert(_captures, {
+            label = _captureLabel,
+            frame = _captureFrame,
+            raw = bufToHex(raw, rawLen),
+            xored = if xored then bufToHex(xored :: buffer, buffer.len(xored :: buffer)) else nil,
+            bytes = rawLen,
+            refs = #refs,
+        })
+    end
+
+    if channelStatsEnabled() then
+        local state = _players[target]
+        if state then
+            state.stats.bytesSent += buffer.len(raw)
+        end
+    end
+
     Channel.reset(ch)
 end
 
 local function flush(): ()
+    if Channel.hasTimestamps() then
+        _frameCounter = (_frameCounter + 1) % 256
+        channelUpdateTimestamp(_frameCounter, 0, os.clock())
+    end
+
     local reliable = Bridge.reliable
     local unreliable = Bridge.unreliable
 
@@ -116,31 +208,22 @@ local function flush(): ()
     end
 end
 
--- Serialize data once into shared scratch, return raw bytes + refs snapshot.
-local function serializeBroadcast(
-    name: string,
-    codec: Codec<any>,
-    data: any
-): (number, { Instance }?)
+-- No timestamp here: writeBatchRaw handles it in the batch header.
+local function serializeBroadcast(reg: Registration, data: any): (number, { Instance }?)
     local scratch = _broadScratch
     scratch.cursor = 0
     table.clear(scratch.refs)
-    channelSetPacket(name)
-    codec.write(scratch, data)
+    Channel.setCurrentPacket(reg.name)
+    reg.codec.write(scratch, data)
 
     local snapRefs = if #scratch.refs > 0 then table.clone(scratch.refs) else nil
     return scratch.cursor, snapRefs
 end
 
--- Run middleware and serialize once. Returns nil if middleware dropped.
-local function prepareBroadcast(
-    name: string,
-    codec: Codec<any>,
-    data: any
-): (any, number, { Instance }?)
+local function prepareBroadcast(reg: Registration, data: any): (any, number, { Instance }?)
     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 nil, 0, nil
         end
@@ -148,81 +231,107 @@ local function prepareBroadcast(
         final = data
     end
 
-    local snapLen, snapRefs = serializeBroadcast(name, codec, final)
+    local snapLen, snapRefs = serializeBroadcast(reg, final)
     return final, snapLen, snapRefs
 end
 
--- Fan out to all connected players via _players map.
+-- Broadcast fan-out: stats computed once from snapLen, not per-player (#7)
 local function broadcastToAll(
-    id: number,
-    name: string,
-    codec: Codec<any>,
+    reg: Registration,
     data: any,
     isUnreliable: boolean,
     exceptSet: { [Player]: true }?
 ): ()
-    local final, snapLen, snapRefs = prepareBroadcast(name, codec, data)
+    local final, snapLen, snapRefs = prepareBroadcast(reg, data)
     if final == nil and data ~= nil then
         return
     end
 
     local scratchBuff = _broadScratch.buff
+    local count = 0
     for player, state in _players do
         if exceptSet and exceptSet[player] then
             continue
         end
         local ch = if isUnreliable then state.unreliable else state.reliable
-        channelWriteBatchRaw(ch, id, scratchBuff, snapLen, snapRefs)
+        channelWriteBatchRaw(ch, reg, scratchBuff, snapLen, snapRefs)
+        count += 1
+    end
+    if channelStatsEnabled() and count > 0 then
+        -- Header (3 bytes for id+count) + timestamp + payload per player
+        local tsBytes = if reg.timestampMode == 1
+            then 1
+            elseif reg.timestampMode == 2 then 2
+            elseif reg.timestampMode == 3 then 8
+            else 0
+        reg.bytesSent += (3 + tsBytes + snapLen) * count
+        reg.fires += count
     end
 end
 
--- Fan out to a specific player list.
 local function broadcastToList(
     players: { Player },
-    id: number,
-    name: string,
-    codec: Codec<any>,
+    reg: Registration,
     data: any,
     isUnreliable: boolean
 ): ()
-    local final, snapLen, snapRefs = prepareBroadcast(name, codec, data)
+    local final, snapLen, snapRefs = prepareBroadcast(reg, data)
     if final == nil and data ~= nil then
         return
     end
 
     local scratchBuff = _broadScratch.buff
+    local count = 0
     for _, player in players do
         local state = _players[player]
         if not state then
             continue
         end
         local ch = if isUnreliable then state.unreliable else state.reliable
-        channelWriteBatchRaw(ch, id, scratchBuff, snapLen, snapRefs)
+        channelWriteBatchRaw(ch, reg, scratchBuff, snapLen, snapRefs)
+        count += 1
+    end
+    if channelStatsEnabled() and count > 0 then
+        local tsBytes = if reg.timestampMode == 1
+            then 1
+            elseif reg.timestampMode == 2 then 2
+            elseif reg.timestampMode == 3 then 8
+            else 0
+        reg.bytesSent += (3 + tsBytes + snapLen) * count
+        reg.fires += count
     end
 end
 
--- Fan out to a group set { [Player]: true }.
 local function broadcastToSet(
     set: { [Player]: true },
-    id: number,
-    name: string,
-    codec: Codec<any>,
+    reg: Registration,
     data: any,
     isUnreliable: boolean
 ): ()
-    local final, snapLen, snapRefs = prepareBroadcast(name, codec, data)
+    local final, snapLen, snapRefs = prepareBroadcast(reg, data)
     if final == nil and data ~= nil then
         return
     end
 
     local scratchBuff = _broadScratch.buff
+    local count = 0
     for player in set do
         local state = _players[player]
         if not state then
             continue
         end
         local ch = if isUnreliable then state.unreliable else state.reliable
-        channelWriteBatchRaw(ch, id, scratchBuff, snapLen, snapRefs)
+        channelWriteBatchRaw(ch, reg, scratchBuff, snapLen, snapRefs)
+        count += 1
+    end
+    if channelStatsEnabled() and count > 0 then
+        local tsBytes = if reg.timestampMode == 1
+            then 1
+            elseif reg.timestampMode == 2 then 2
+            elseif reg.timestampMode == 3 then 8
+            else 0
+        reg.bytesSent += (3 + tsBytes + snapLen) * count
+        reg.fires += count
     end
 end
 
@@ -250,17 +359,32 @@ function Server.start(): ()
     Bridge.unreliable.OnServerEvent:Connect(function(player: Player, data: any, refs: any): ()
         receive(player, 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 Server.writeTo(
-    player: Player,
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
+function Server.writeTo(player: Player, reg: Registration, data: any, isUnreliable: boolean): ()
     local state = _players[player]
     if not state then
         return
@@ -268,7 +392,7 @@ function Server.writeTo(
 
     local final: any
     if Middleware.hasSend then
-        final = Middleware.runSend(data, name, player)
+        final = Middleware.runSend(data, reg.name, player)
         if final == nil then
             return
         end
@@ -277,53 +401,47 @@ function Server.writeTo(
     end
 
     local ch = if isUnreliable then state.unreliable else state.reliable
-    channelWriteBatch(ch, id, name, codec, final)
+    if channelStatsEnabled() then
+        local before = ch.cursor
+        channelWriteBatch(ch, reg, final)
+        reg.bytesSent += ch.cursor - before
+        reg.fires += 1
+    else
+        channelWriteBatch(ch, reg, final)
+    end
 end
 
-function Server.writeToAll(
-    id: number,
-    name: string,
-    codec: Codec<any>,
-    data: any,
-    isUnreliable: boolean
-): ()
-    broadcastToAll(id, name, codec, data, isUnreliable, nil)
+function Server.writeToAll(reg: Registration, data: any, isUnreliable: boolean): ()
+    broadcastToAll(reg, data, isUnreliable, nil)
 end
 
 function Server.writeToList(
     players: { Player },
-    id: number,
-    name: string,
-    codec: Codec<any>,
+    reg: Registration,
     data: any,
     isUnreliable: boolean
 ): ()
-    broadcastToList(players, id, name, codec, data, isUnreliable)
+    broadcastToList(players, reg, data, isUnreliable)
 end
 
 function Server.writeToAllExcept(
     exceptSet: { [Player]: true },
-    id: number,
-    name: string,
-    codec: Codec<any>,
+    reg: Registration,
     data: any,
     isUnreliable: boolean
 ): ()
-    broadcastToAll(id, name, codec, data, isUnreliable, exceptSet)
+    broadcastToAll(reg, data, isUnreliable, exceptSet)
 end
 
 function Server.writeToSet(
     set: { [Player]: true },
-    id: number,
-    name: string,
-    codec: Codec<any>,
+    reg: Registration,
     data: any,
     isUnreliable: boolean
 ): ()
-    broadcastToSet(set, id, name, codec, data, isUnreliable)
+    broadcastToSet(set, reg, data, isUnreliable)
 end
 
--- Shared for both query requests and responses(identical wire format).
 function Server.writeQuery(
     player: Player,
     id: number,
@@ -359,4 +477,91 @@ function Server.writeQueryNil(player: Player, id: number, name: string, correlat
     Channel.writeQuery(state.reliable, id, name, correlationId, nil, nil)
 end
 
+function Server.flush(): ()
+    _flushAccum = 0
+    _flushedThisFrame = true
+    flush()
+end
+
+function Server.setFlushRate(hz: number): ()
+    _flushRate = math.clamp(hz, 1, 60)
+    _flushInterval = 1 / _flushRate
+    _useAccumulator = _flushRate < 60
+end
+
+function Server.getFlushRate(): number
+    return _flushRate
+end
+
+function Server.setBandwidthLimit(softLimit: number, maxStrikes: number): ()
+    _softLimit = softLimit
+    _maxStrikes = maxStrikes
+end
+
+function Server.getPlayerStats(player: Player): PlayerStats?
+    local state = _players[player]
+    return if state then state.stats else nil
+end
+
+function Server.resetStats(): ()
+    for _, state in _players do
+        state.stats.bytesSent = 0
+        state.stats.bytesReceived = 0
+    end
+    Registry.forEach(function(reg: Registration)
+        reg.bytesSent = 0
+        reg.bytesReceived = 0
+        reg.fires = 0
+        reg.recvFires = 0
+        reg.drops = 0
+    end)
+end
+
+function Server.startCapture(label: string?): ()
+    _captureEnabled = true
+    _captureLabel = label or "unknown"
+    _captureFrame = 0
+end
+
+function Server.stopCapture(): ()
+    _captureEnabled = false
+end
+
+function Server.dumpCaptures(): ()
+    local json = game:GetService("HttpService"):JSONEncode(_captures)
+    local storage = game:GetService("ServerStorage")
+
+    -- Clean up previous captures
+    local old = storage:FindFirstChild("LyncCapture")
+    if old then
+        old:Destroy()
+    end
+
+    -- Split across StringValues if needed (200K limit per value)
+    local CHUNK = 199000
+    if #json <= CHUNK then
+        local sv = Instance.new("StringValue")
+        sv.Name = "LyncCapture"
+        sv.Value = json
+        sv.Parent = storage
+    else
+        local folder = Instance.new("Folder")
+        folder.Name = "LyncCapture"
+        local parts = math.ceil(#json / CHUNK)
+        for i = 1, parts do
+            local sv = Instance.new("StringValue")
+            sv.Name = `Part{i}`
+            sv.Value = string.sub(json, (i - 1) * CHUNK + 1, i * CHUNK)
+            sv.Parent = folder
+        end
+        folder.Parent = storage
+    end
+
+    local count = #_captures
+    table.clear(_captures)
+    print(
+        `[Lync] Capture saved: {count} entries, {#json} chars -> ServerStorage.LyncCapture (open in script editor, copy contents)`
+    )
+end
+
 return table.freeze(Server)