@axpecter/lync 2.3.1 → 2.3.3

package/src/internal/Channel.luau

@@ -18,7 +18,6 @@ local TS_FULL = 3
 
 local INITIAL_BUF = 1024
 local HEADER_BYTE = 1
-local FRAME_MSB = Constants.FRAME_MSB
 local U8_MAX = Constants.U8_MAX
 local U16_MAX = Constants.U16_MAX
 local MAX_BATCH_ITEMS = Constants.MAX_BATCH_ITEMS
@@ -48,8 +47,8 @@ local EMPTY_REFS = table.freeze({}) :: { Instance }
 -- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
+local ensure = Base.ensure
 local band = bit32.band
-local bor = bit32.bor
 local bufCopy = buffer.copy
 local writeu8 = buffer.writeu8
 local writeu16 = buffer.writeu16
@@ -57,21 +56,7 @@ local writef64 = buffer.writef64
 local round = math.round
 local osClock = os.clock
 
-local function ensure(ch: Types.ChannelState, n: number): ()
-    if ch.cursor + n > ch.size then
-        alloc(ch, n)
-    end
-end
-
-local function writeTimestamp(b: buffer, off: number, mode: number): ()
-    if mode == TS_FRAME then
-        writeu8(b, off, _frameCounter)
-    elseif mode == TS_OFFSET then
-        writeu16(b, off, _offsetMs)
-    elseif mode == TS_FULL then
-        writef64(b, off, _clock)
-    end
-end
+-- id is in [1, 127] (Registry.MAX_ID), so id + 128 == bor(FRAME_MSB, id).
 
 --[[
     Single -> multi upgrade. Patches the previously-emitted single-item
@@ -89,10 +74,7 @@ local function upgradeSingleToMulti(ch: Types.ChannelState, regId: number, heade
     ensure(ch, 2)
     -- Re-bind: ensure() may have realloced the buffer.
     local b = ch.buff
-
-    if payloadLen > 0 then
-        bufCopy(b, afterTs + 2, b, afterTs, payloadLen)
-    end
+    bufCopy(b, afterTs + 2, b, afterTs, payloadLen)
 
     ch.countPos = afterTs
     writeu16(b, afterTs, 0)
@@ -100,34 +82,106 @@ local function upgradeSingleToMulti(ch: Types.ChannelState, regId: number, heade
     ch.singleMode = false
 end
 
+-- itemCount bump is left to the caller, AFTER the body write succeeds.
+local function openOrUpgrade(ch: Types.ChannelState, reg: Types.Registration): ()
+    if reg.id ~= ch.lastId or ch.itemCount >= MAX_BATCH_ITEMS then
+        reg._openFn(ch, reg.id)
+    elseif ch.singleMode then
+        upgradeSingleToMulti(ch, reg.id, reg.headerSize)
+    end
+end
+
+local function spliceEncoded(ch: Types.ChannelState, payload: buffer, payloadLen: number): ()
+    local cursor = ch.cursor
+    if cursor + payloadLen > ch.size then
+        alloc(ch, payloadLen)
+    end
+    bufCopy(ch.buff, cursor, payload, 0, payloadLen)
+    ch.cursor = cursor + payloadLen
+end
+
 --[[
-    Two writeBatch implementations, swapped at startup by enableStats(). For
-    high-rate channels this saves ~1 register read + 1 compare + 1 jump per
-    item versus branching on `_statsEnabled` inside the loop.
+    Hot-swapped by enableStats(). A throwing codec must rewind cursor + refs:
+    the next flush sends `[0, ch.cursor)`, so a partial write past `cursor`
+    desyncs the receiver from the truncation point onward.
 ]]
 local writeBatchPlain: (Types.ChannelState, Types.Registration, any) -> ()
 local writeBatchStats: (Types.ChannelState, Types.Registration, any) -> ()
 
+local function rewindOnThrow(ch: Types.ChannelState, cursor: number, refCount: number): ()
+    ch.cursor = cursor
+    if ch.refCount > refCount then
+        local refs = ch.refs
+        for i = refCount + 1, ch.refCount do
+            refs[i] = nil
+        end
+        ch.refCount = refCount
+    end
+end
+
 writeBatchPlain = function(ch: Types.ChannelState, reg: Types.Registration, data: any): ()
-    if reg.id ~= ch.lastId or ch.itemCount >= MAX_BATCH_ITEMS then
-        reg._openFn(ch, reg.id)
-    elseif ch.singleMode then
-        upgradeSingleToMulti(ch, reg.id, reg.headerSize)
+    openOrUpgrade(ch, reg)
+    local rewindCursor = ch.cursor
+    local rewindRefCount = ch.refCount
+    local ok, err = pcall(reg.codec.write, ch, data)
+    if not ok then
+        rewindOnThrow(ch, rewindCursor, rewindRefCount)
+        error(err, 0)
     end
     ch.itemCount += 1
-    reg.codec.write(ch, data)
 end
 
 writeBatchStats = function(ch: Types.ChannelState, reg: Types.Registration, data: any): ()
-    if reg.id ~= ch.lastId or ch.itemCount >= MAX_BATCH_ITEMS then
-        reg._openFn(ch, reg.id)
-    elseif ch.singleMode then
-        upgradeSingleToMulti(ch, reg.id, reg.headerSize)
+    openOrUpgrade(ch, reg)
+    local rewindCursor = ch.cursor
+    local rewindRefCount = ch.refCount
+    local ok, err = pcall(reg.codec.write, ch, data)
+    if not ok then
+        rewindOnThrow(ch, rewindCursor, rewindRefCount)
+        error(err, 0)
+    end
+    ch.itemCount += 1
+    reg.bytesSent += ch.cursor - rewindCursor
+end
+
+--[[
+    Splice a pre-encoded payload into the channel. Used by Packet.broadcast
+    to encode the codec output once per fanout instead of N times.
+]]
+local writeBatchEncodedPlain: (Types.ChannelState, Types.Registration, buffer, number) -> ()
+local writeBatchEncodedStats: (Types.ChannelState, Types.Registration, buffer, number) -> ()
+
+writeBatchEncodedPlain = function(
+    ch: Types.ChannelState,
+    reg: Types.Registration,
+    payload: buffer,
+    payloadLen: number
+): ()
+    openOrUpgrade(ch, reg)
+    local rewindCursor = ch.cursor
+    local ok, err = pcall(spliceEncoded, ch, payload, payloadLen)
+    if not ok then
+        ch.cursor = rewindCursor
+        error(err, 0)
     end
     ch.itemCount += 1
-    local before = ch.cursor
-    reg.codec.write(ch, data)
-    reg.bytesSent += ch.cursor - before
+end
+
+writeBatchEncodedStats = function(
+    ch: Types.ChannelState,
+    reg: Types.Registration,
+    payload: buffer,
+    payloadLen: number
+): ()
+    openOrUpgrade(ch, reg)
+    local rewindCursor = ch.cursor
+    local ok, err = pcall(spliceEncoded, ch, payload, payloadLen)
+    if not ok then
+        ch.cursor = rewindCursor
+        error(err, 0)
+    end
+    ch.itemCount += 1
+    reg.bytesSent += payloadLen
 end
 
 -- Public -----------------------------------------------------------------
@@ -209,49 +263,116 @@ function Channel.fullReset(ch: Types.ChannelState): ()
     Channel.reset(ch)
     ch.prevDump = nil
     ch.prevDumpLen = 0
-    table.clear(ch.deltas)
+    if next(ch.deltas) ~= nil then
+        table.clear(ch.deltas)
+    end
 end
 
 --[[
-    Resolve the batch-open closure for a given timestamp mode and packet
-    name. Returned function seals the prior batch, writes the single-mode
-    header [0x80 | id] + optional timestamp, and records the cursor so
-    writeBatch can upgrade single -> multi later.
+    Per-mode openFn variants. Each seals the prior batch, writes the
+    single-mode header [0x80 | id] + optional timestamp, and records the
+    cursor so writeBatch can upgrade single -> multi later.
 ]]
-function Channel.resolveOpenFn(
-    timestampMode: number,
-    name: string
-): (ch: Types.ChannelState, id: number) -> ()
-    local headerLen = HEADER_BYTE + TS_BYTES[timestampMode]
-
+local function makeOpenNoTs(name: string): (Types.ChannelState, number) -> ()
     return function(ch: Types.ChannelState, id: number): ()
-        --[[
-            Inline sealCount: this is the only call site that can take the
-            multi-mode branch on a non-fresh channel.
-        ]]
         if ch.lastId >= 0 and not ch.singleMode then
             writeu16(ch.buff, ch.countPos, ch.itemCount)
         end
+        ch.currentPacket = name
+        ch.lastId = id
+        ch.itemCount = 0
+        local cursor = ch.cursor
+        if cursor + 1 > ch.size then
+            alloc(ch, 1)
+        end
+        writeu8(ch.buff, cursor, id + 128)
+        ch.singleMode = true
+        ch.singlePos = cursor
+        ch.cursor = cursor + 1
+    end
+end
 
+local function makeOpenFrameTs(name: string): (Types.ChannelState, number) -> ()
+    return function(ch: Types.ChannelState, id: number): ()
+        if ch.lastId >= 0 and not ch.singleMode then
+            writeu16(ch.buff, ch.countPos, ch.itemCount)
+        end
         ch.currentPacket = name
         ch.lastId = id
         ch.itemCount = 0
+        local cursor = ch.cursor
+        if cursor + 2 > ch.size then
+            alloc(ch, 2)
+        end
+        local b = ch.buff
+        writeu8(b, cursor, id + 128)
+        writeu8(b, cursor + 1, _frameCounter)
+        ch.singleMode = true
+        ch.singlePos = cursor
+        ch.cursor = cursor + 2
+    end
+end
 
+local function makeOpenOffsetTs(name: string): (Types.ChannelState, number) -> ()
+    return function(ch: Types.ChannelState, id: number): ()
+        if ch.lastId >= 0 and not ch.singleMode then
+            writeu16(ch.buff, ch.countPos, ch.itemCount)
+        end
+        ch.currentPacket = name
+        ch.lastId = id
+        ch.itemCount = 0
         local cursor = ch.cursor
-        if cursor + headerLen > ch.size then
-            alloc(ch, headerLen)
+        if cursor + 3 > ch.size then
+            alloc(ch, 3)
         end
         local b = ch.buff
-        writeu8(b, cursor, bor(FRAME_MSB, id))
-        writeTimestamp(b, cursor + 1, timestampMode)
+        writeu8(b, cursor, id + 128)
+        writeu16(b, cursor + 1, _offsetMs)
+        ch.singleMode = true
+        ch.singlePos = cursor
+        ch.cursor = cursor + 3
+    end
+end
 
+local function makeOpenFullTs(name: string): (Types.ChannelState, number) -> ()
+    return function(ch: Types.ChannelState, id: number): ()
+        if ch.lastId >= 0 and not ch.singleMode then
+            writeu16(ch.buff, ch.countPos, ch.itemCount)
+        end
+        ch.currentPacket = name
+        ch.lastId = id
+        ch.itemCount = 0
+        local cursor = ch.cursor
+        if cursor + 9 > ch.size then
+            alloc(ch, 9)
+        end
+        local b = ch.buff
+        writeu8(b, cursor, id + 128)
+        writef64(b, cursor + 1, _clock)
         ch.singleMode = true
         ch.singlePos = cursor
-        ch.cursor = cursor + headerLen
+        ch.cursor = cursor + 9
+    end
+end
+
+function Channel.resolveOpenFn(
+    timestampMode: number,
+    name: string
+): (ch: Types.ChannelState, id: number) -> ()
+    if timestampMode == TS_NONE then
+        return makeOpenNoTs(name)
+    end
+    if timestampMode == TS_FRAME then
+        return makeOpenFrameTs(name)
     end
+    if timestampMode == TS_OFFSET then
+        return makeOpenOffsetTs(name)
+    end
+    return makeOpenFullTs(name)
 end
 
 Channel.writeBatch = writeBatchPlain
+Channel.writeBatchEncoded = writeBatchEncodedPlain
 
 --[[
     Every caller (Server.flushReliable / flushUnreliable, Client.flush)
@@ -282,7 +403,8 @@ function Channel.writeQuery(
     id: number,
     correlationId: number,
     codec: Types.InternalCodec<any>?,
-    data: any
+    data: any,
+    name: string?
 ): ()
     if ch.lastId >= 0 and not ch.singleMode then
         writeu16(ch.buff, ch.countPos, ch.itemCount)
@@ -294,9 +416,14 @@ function Channel.writeQuery(
         here would never be observed before the next reset overwrites it.
     ]]
     ch.lastId = -1
+    -- Without this, an alloc overflow inside the payload codec would log
+    -- the previous packet's name (whichever _openFn last touched currentPacket).
+    if name then
+        ch.currentPacket = name
+    end
 
     local hasPayload = codec ~= nil and data ~= nil
-    local headerByte = if hasPayload then id else bor(FRAME_MSB, id)
+    local headerByte = if hasPayload then id else id + 128
 
     local cursor = ch.cursor
     if cursor + 1 > ch.size then
@@ -335,6 +462,7 @@ end
 function Channel.enableStats(): ()
     _statsEnabled = true
     Channel.writeBatch = writeBatchStats
+    Channel.writeBatchEncoded = writeBatchEncodedStats
 end
 
 function Channel.statsEnabled(): boolean
@@ -350,6 +478,7 @@ function Channel.resetGlobals(): ()
     _offsetMs = 0
     _clock = 0.0
     Channel.writeBatch = writeBatchPlain
+    Channel.writeBatchEncoded = writeBatchEncodedPlain
 end
 
 return Channel

package/src/internal/Pool.luau

@@ -20,23 +20,24 @@ local _maxSize = DEFAULT_SIZE
 
 local Pool = {}
 
--- fullReset wipes the prior owner's XOR baseline and delta caches.
 function Pool.acquire(): Types.ChannelState
     if _depth > 0 then
         local ch = _stack[_depth]
         _stack[_depth] = nil
         _depth -= 1
-        Channel.fullReset(ch)
         return ch
     end
     return Channel.create()
 end
 
--- Above the cap, drop on the floor; the GC reclaims the buffer.
+-- Scrub on release so the pool never holds the prior owner's Instance refs
+-- or XOR baseline buffer; otherwise a player who disconnects mid-frame leaves
+-- those rooted in the pool until the slot is re-acquired (potentially never).
 function Pool.release(ch: Types.ChannelState): ()
     if _depth >= _maxSize then
         return
     end
+    Channel.fullReset(ch)
     _depth += 1
     _stack[_depth] = ch
 end

package/src/transport/Reader.luau

@@ -207,17 +207,27 @@ function Reader.process(
             local doGate = isServer and reg.needsGate and player ~= nil
             local regSignal = reg.signal
             local regName = reg.name
+            -- Lync.nothing reads zero bytes; bypass the pos/consumed gates that assume forward progress.
+            local isZeroSize = sizeMeta == 0
+            local accepted = 0
 
             for _ = 1, count do
-                if pos >= incomingLen then
+                if not isZeroSize and pos >= incomingLen then
                     Log.warn(`codec for "{regName}" ran past frame end; aborting`)
                     return false
                 end
                 local value, consumed = regCodec.read(incoming, pos, refs)
-                if consumed == 0 then
+                if not isZeroSize and consumed == 0 then
                     Log.warn(`codec for "{regName}" reported 0 bytes; aborting`)
                     return false
                 end
+                -- Fixed-size codecs MUST report consumed == _size or `pos` desyncs silently.
+                if sizeMeta and consumed ~= sizeMeta then
+                    Log.warn(
+                        `codec for "{regName}" consumed {consumed} bytes, expected {sizeMeta}; aborting`
+                    )
+                    return false
+                end
                 pos += consumed
                 if pos > incomingLen then
                     Log.warn(`codec for "{regName}" overran frame end; aborting`)
@@ -240,15 +250,14 @@ function Reader.process(
                     value = runReceive(value, regName, player)
                 end
 
-                if statsEnabled then
-                    reg.recvFires += 1
-                end
+                accepted += 1
 
                 -- tsValue is nil when mode == TS_NONE; pass through to skip a per-item branch.
                 regSignal:fire(value, player, tsValue)
             end
 
             if statsEnabled then
+                reg.recvFires += accepted
                 reg.bytesReceived += (pos - frameStart)
             end
         elseif kind == KIND_REQUEST or kind == KIND_RESPONSE then
@@ -266,13 +275,15 @@ function Reader.process(
                 end
                 reg.signal:fire(nil, player, corrId)
             else
-                if pos >= incomingLen then
+                local regCodec = reg.codec
+                -- Mirror the packet path: 0-byte response codecs (Lync.nothing) bypass the gates.
+                local qIsZeroSize = regCodec._size == 0
+                if not qIsZeroSize and pos >= incomingLen then
                     Log.warn(`query "{reg.name}" body missing; aborting`)
                     return false
                 end
-                local regCodec = reg.codec
                 local value, consumed = regCodec.read(incoming, pos, refs)
-                if consumed == 0 then
+                if not qIsZeroSize and consumed == 0 then
                     Log.warn(`query codec for "{reg.name}" reported 0 bytes; aborting`)
                     return false
                 end

package/src/transport/Server.luau

@@ -32,8 +32,6 @@ local xorApply = Channel.xorApply
 local sealAndDump = Channel.sealAndDump
 local resetCh = Channel.reset
 
-type StatsField = "bytesSent" | "bytesReceived"
-
 local function getOrCreateChannel(
     map: { [Player]: Types.ChannelState },
     player: Player
@@ -46,16 +44,26 @@ local function getOrCreateChannel(
     return ch
 end
 
--- Skip the table read when stats are off; the hot path needs no branch.
-local function addStat(player: Player, field: StatsField, byteLen: number): ()
-    if statsEnabled() then
-        local ps = _playerStats[player]
-        if ps then
-            ps[field] += byteLen
-        end
+-- Hot-swapped at Server.start; stats-off path is a tail-callable noop.
+local function noopStat(_player: Player, _byteLen: number): () end
+
+local function realBytesSent(player: Player, byteLen: number): ()
+    local ps = _playerStats[player]
+    if ps then
+        ps.bytesSent += byteLen
     end
 end
 
+local function realBytesReceived(player: Player, byteLen: number): ()
+    local ps = _playerStats[player]
+    if ps then
+        ps.bytesReceived += byteLen
+    end
+end
+
+local addBytesSent: (Player, number) -> () = noopStat
+local addBytesReceived: (Player, number) -> () = noopStat
+
 local function flushReliable(player: Player): ()
     local rCh = _reliableChannels[player]
     if not rCh or rCh.cursor == 0 then
@@ -69,7 +77,7 @@ local function flushReliable(player: Player): ()
 
     Bridge.fireClient(player, xored, refs)
     resetCh(rCh)
-    addStat(player, "bytesSent", byteLen)
+    addBytesSent(player, byteLen)
 end
 
 local function flushUnreliable(player: Player): ()
@@ -81,7 +89,7 @@ local function flushUnreliable(player: Player): ()
     local snapshot, refs, byteLen = sealAndDump(uCh)
     Bridge.fireClientUnreliable(player, snapshot, refs)
     resetCh(uCh)
-    addStat(player, "bytesSent", byteLen)
+    addBytesSent(player, byteLen)
 end
 
 local function flushPlayer(player: Player): ()
@@ -116,7 +124,7 @@ local function handleIncomingReliable(player: Player, data: any, refs: any?): ()
         _prevIncomingLen[player] = nil
     end
 
-    addStat(player, "bytesReceived", incomingLen)
+    addBytesReceived(player, incomingLen)
 end
 
 local function handleIncomingUnreliable(player: Player, data: any, refs: any?): ()
@@ -127,7 +135,7 @@ local function handleIncomingUnreliable(player: Player, data: any, refs: any?):
 
     local incomingLen = buffer.len(incoming)
     Reader.process(incoming, incomingLen, refs, player, true)
-    addStat(player, "bytesReceived", incomingLen)
+    addBytesReceived(player, incomingLen)
 end
 
 local function clearPlayerState(player: Player): ()
@@ -161,6 +169,15 @@ function Server.getChannel(player: Player, isUnreliable: boolean): Types.Channel
     )
 end
 
+-- Pre-resolved variants for broadcast: skip the per-audience-member isUnreliable branch.
+function Server.getReliableChannel(player: Player): Types.ChannelState
+    return getOrCreateChannel(_reliableChannels, player)
+end
+
+function Server.getUnreliableChannel(player: Player): Types.ChannelState
+    return getOrCreateChannel(_unreliableChannels, player)
+end
+
 function Server.flush(): ()
     if Channel.hasTimestamps() then
         Channel.updateTimestamp()
@@ -182,6 +199,11 @@ function Server.start(): ()
     Bridge.reliable().OnServerEvent:Connect(handleIncomingReliable)
     Bridge.unreliable().OnServerEvent:Connect(handleIncomingUnreliable)
 
+    if statsEnabled() then
+        addBytesSent = realBytesSent
+        addBytesReceived = realBytesReceived
+    end
+
     Players.PlayerAdded:Connect(function(player: Player)
         if statsEnabled() then
             _playerStats[player] = { bytesSent = 0, bytesReceived = 0 }

package/src/util/Buffer.luau

@@ -46,11 +46,9 @@ function Buf.rangeEqual(a: buffer, offA: number, b: buffer, offB: number, len: n
     return true
 end
 
-function Buf.snapshot(src: buffer, len: number): buffer
+function Buf.snapshot(src: buffer, len: number, srcOff: number?): buffer
     local out = bufCreate(len)
-    if len > 0 then
-        bufCopy(out, 0, src, 0, len)
-    end
+    bufCopy(out, 0, src, srcOff or 0, len)
     return out
 end
 

package/src/util/Quantize.luau

@@ -10,12 +10,34 @@ local ceil = math.ceil
 local maxN = math.max
 local minN = math.min
 
+local writeu8 = buffer.writeu8
+local writeu16 = buffer.writeu16
+local readu8 = buffer.readu8
+local readu16 = buffer.readu16
+local band = bit32.band
+local bor = bit32.bor
+local rshift = bit32.rshift
+local lshift = bit32.lshift
+
+--[[
+    24-bit wire form. Splits into u16 + u8 since the buffer API has no native
+    u24. Saves 1 byte over u32 for ranges needing 17–24 bits of precision.
+]]
+local function writeu24(b: buffer, off: number, value: number): ()
+    writeu16(b, off, band(value, 0xFFFF))
+    writeu8(b, off + 2, band(rshift(value, 16), 0xFF))
+end
+
+local function readu24(b: buffer, off: number): number
+    return bor(readu16(b, off), lshift(readu8(b, off + 2), 16))
+end
+
 -- Public -----------------------------------------------------------------
 
 local Quantize = {}
 
 --[[
-    Pick the narrowest u8/u16/u32 wire form for [rangeMin, rangeMax] at
+    Pick the narrowest u8/u16/u24/u32 wire form for [rangeMin, rangeMax] at
     `precision`. Returns (compBytes, wfn, rfn, scale, invScale, delta).
     `apiName` shows in error messages so callers see their public surface.
 ]]
@@ -32,8 +54,8 @@ function Quantize.setup(
     number,
     number
 )
-    if rangeMin > rangeMax then
-        Log.error(`{apiName}: min ({rangeMin}) must be <= max ({rangeMax})`)
+    if rangeMin >= rangeMax then
+        Log.error(`{apiName}: min ({rangeMin}) must be < max ({rangeMax})`)
     end
     if precision <= 0 then
         Log.error(`{apiName}: precision must be positive, got {precision}`)
@@ -50,6 +72,8 @@ function Quantize.setup(
         compBytes, wfn, rfn = 1, buffer.writeu8, buffer.readu8
     elseif maxInt <= 0xFFFF then
         compBytes, wfn, rfn = 2, buffer.writeu16, buffer.readu16
+    elseif maxInt <= 0xFFFFFF then
+        compBytes, wfn, rfn = 3, writeu24, readu24
     else
         compBytes, wfn, rfn = 4, buffer.writeu32, buffer.readu32
     end