@axpecter/lync 2.3.2 → 2.3.3

package/README.md

@@ -16,7 +16,7 @@ Schemas, packets, queries, groups, validation, rate limiting. Every send batches
 Wally — add to your `wally.toml`:
 
 ```toml
-Lync = "axp3cter/lync@2.3.2"
+Lync = "axp3cter/lync@2.3.3"
 ```
 
 npm (roblox-ts):

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@axpecter/lync",
-    "version": "2.3.2",
+    "version": "2.3.3",
     "description": "Buffer networking for Roblox. Delta compression, XOR framing, built-in security",
     "main": "src/init.luau",
     "types": "src/index.d.ts",

package/src/api/Packet.luau

@@ -152,15 +152,13 @@ function Packet.define<T>(
                 local payload = scratch.buff
                 local payloadLen = scratch.cursor
                 local server = Transport.server()
+                local getChannel = if isUnreliable
+                    then server.getUnreliableChannel
+                    else server.getReliableChannel
                 -- Channel.writeBatchEncoded is hot-swapped by enableStats; re-read per call.
                 local writeBatchEncoded = Channel.writeBatchEncoded
                 for i = 1, count do
-                    writeBatchEncoded(
-                        server.getChannel(players[i], isUnreliable),
-                        reg,
-                        payload,
-                        payloadLen
-                    )
+                    writeBatchEncoded(getChannel(players[i]), reg, payload, payloadLen)
                 end
                 Shared.releaseScratch()
                 bumpFires()

package/src/api/Query.luau

@@ -44,10 +44,10 @@ local function writeQueryTracked(
 ): ()
     if Channel.statsEnabled() then
         local before = ch.cursor
-        Channel.writeQuery(ch, reg.id, corrId, codec, data)
+        Channel.writeQuery(ch, reg.id, corrId, codec, data, reg.name)
         reg.bytesSent += ch.cursor - before
     else
-        Channel.writeQuery(ch, reg.id, corrId, codec, data)
+        Channel.writeQuery(ch, reg.id, corrId, codec, data, reg.name)
     end
 end
 

package/src/api/Signal.luau

@@ -17,11 +17,16 @@ local _freeThread: thread? = nil
 
 -- Private ----------------------------------------------------------------
 
+-- pcall wrapper: a handler error must not consume the recycled thread, otherwise
+-- every subsequent fire pays a coroutine.create until process restart.
 local function passer(fn: (...any) -> (), ...): ()
     local thread = _freeThread
     _freeThread = nil
-    fn(...)
+    local ok, err = pcall(fn, ...)
     _freeThread = thread
+    if not ok then
+        task.spawn(error, err)
+    end
 end
 
 local function yielder(): ()

package/src/codec/Base.luau

@@ -7,7 +7,7 @@ local Types = require(script.Parent.Parent.Types)
 
 -- Constants --------------------------------------------------------------
 
-local DEFAULT_MAX = 262144
+local DEFAULT_MAX = 1048576
 local INITIAL_BUF = 1024
 
 -- State ------------------------------------------------------------------

package/src/codec/composite/Array.luau

@@ -53,7 +53,7 @@ local function makeBoolArray(
         write = function(ch: Types.ChannelState, value: { boolean }): ()
             local len = #value
             varintWrite(ch, len)
-            packBoolArray(ch, value, len)
+            packBoolArray(ch, value, len, if len > 0 then boolBytes(len) else 0)
         end,
 
         read = function(src: buffer, pos: number, _refs: { Instance }?): ({ boolean }, number)
@@ -69,7 +69,7 @@ local function makeBoolArray(
                 Log.error(`payload {byteCount}B exceeds remaining buffer`)
             end
             local result = table.create(len, false)
-            unpackBoolArray(src, dataStart, len, result)
+            unpackBoolArray(src, dataStart, len, result, byteCount)
             return result, lenBytes + byteCount
         end,
     }
@@ -157,6 +157,11 @@ local function makeGenericArray(
             if len == 0 then
                 return {}, lenBytes
             end
+            -- Every element occupies at least 1 byte; len > remaining is
+            -- unambiguously corrupt and would OOM table.create otherwise.
+            if len > bufLen(src) - (pos + lenBytes) then
+                Log.error(`array length {len} exceeds remaining buffer`)
+            end
 
             local result = table.create(len)
             local total = lenBytes
@@ -415,22 +420,28 @@ function Array.deltaArray(
                 if cLen == 0 then
                     Log.error("truncated deltaArray change count")
                 end
-                -- changeCount is also bounded by newLen: every index appears at most once.
                 if changeCount > newLen then
                     Log.error(`deltaArray changeCount {changeCount} exceeds newLen {newLen}`)
                 end
                 total += cLen
 
+                -- The writer marks every appended index (cachedLen+1 .. newLen)
+                -- as changed; the reader must enforce this so the wire can't
+                -- ship a holey baseline that breaks #result downstream.
+                local appendedNeeded = if newLen > cachedLen then newLen - cachedLen else 0
+                local appendedSeen = 0
+
                 for _ = 1, changeCount do
                     local idx, iLen = varintRead(src, pos + total)
                     if iLen == 0 then
                         Log.error("truncated deltaArray index")
                     end
-                    -- Reject out-of-range idx so the wire can't poison the cache with
-                    -- arbitrary keys that survive truncation.
                     if idx < 1 or idx > newLen then
                         Log.error(`deltaArray index {idx} out of range [1, {newLen}]`)
                     end
+                    if idx > cachedLen then
+                        appendedSeen += 1
+                    end
                     total += iLen
                     local v, vc = element.read(src, pos + total, refs)
                     if vc == 0 then
@@ -440,6 +451,12 @@ function Array.deltaArray(
                     result[idx] = v
                 end
 
+                if appendedSeen ~= appendedNeeded then
+                    Log.error(
+                        `deltaArray PATCH grew length to {newLen} but only {appendedSeen}/{appendedNeeded} appended indices supplied`
+                    )
+                end
+
                 for i = newLen + 1, cachedLen do
                     result[i] = nil
                 end

package/src/codec/composite/Map.luau

@@ -21,9 +21,11 @@ local DM_DIFF = 2
 --[[
     Depth-stacked key scratch. A nested Map.write (Map<K, Map<K2, V>>) would
     clobber a single shared array mid-iteration; the stack gives each frame
-    its own slot. Mirrors Shared.acquireScratch / releaseScratch.
+    its own slot. _keyTails parallels _keyStacks because `#keys` after
+    `keys[count] = k` is undefined when count < the prior count.
 ]]
 local _keyStacks: { { any } } = {}
+local _keyTails: { number } = {}
 local _keyDepth = 0
 
 -- Private ----------------------------------------------------------------
@@ -73,23 +75,23 @@ local function sortKeys(keys: { any }, canSortDirect: boolean): ()
     end
 end
 
---[[
-    Acquire a scratch keys array, populate it from `value`, nil any leftover
-    tail entries from a prior reuse, then sort. Returns the keys array and
-    the populated count. Caller MUST releaseKeys() after consuming the keys.
-]]
 local function collectAndSortKeys(value: { [any]: any }, canSortDirect: boolean): ({ any }, number)
     local keys = acquireKeys()
+    local prevTail = _keyTails[_keyDepth] or 0
     local count = 0
     for k in value do
         count += 1
         keys[count] = k
     end
-    local prevTail = #keys
-    for i = count + 1, prevTail do
-        keys[i] = nil
+    if count < prevTail then
+        for i = count + 1, prevTail do
+            keys[i] = nil
+        end
+    end
+    _keyTails[_keyDepth] = count
+    if count > 1 then
+        sortKeys(keys, canSortDirect)
     end
-    sortKeys(keys, canSortDirect)
     return keys, count
 end
 
@@ -163,6 +165,11 @@ function Map.map(
                 if payloadBytes > bufLen(src) - (pos + lenBytes) then
                     Log.error(`payload {payloadBytes}B exceeds remaining buffer`)
                 end
+            elseif count > 0 then
+                -- Variable-size: each pair is at least 2 bytes (key + value).
+                if count * 2 > bufLen(src) - (pos + lenBytes) then
+                    Log.error(`map count {count} exceeds remaining buffer`)
+                end
             end
 
             local result: { [any]: any } = {}
@@ -419,14 +426,19 @@ function Map.deltaMap(
                 local result: { [any]: any } = table.clone(cached)
                 local total = 1
 
+                local cachedSize = 0
+                for _ in cached do
+                    cachedSize += 1
+                end
+
                 local removeCount, rcLen = varintRead(src, pos + total)
                 if rcLen == 0 then
                     Log.error("truncated deltaMap remove count")
                 end
-                -- Both counts bounded by maxCount; otherwise a malicious DIFF
-                -- could spin the loop arbitrarily long before erroring on
-                -- buffer overrun.
                 enforceMaxCount(removeCount, maxCount, "removeCount")
+                if removeCount > cachedSize then
+                    Log.error(`deltaMap removeCount {removeCount} exceeds cached size {cachedSize}`)
+                end
                 total += rcLen
                 for _ = 1, removeCount do
                     local k, kc = keyCodec.read(src, pos + total, refs)
@@ -442,6 +454,10 @@ function Map.deltaMap(
                     Log.error("truncated deltaMap change count")
                 end
                 enforceMaxCount(changeCount, maxCount, "changeCount")
+                -- Joint bound: post-DIFF size can't exceed maxCount either.
+                if maxCount and (cachedSize - removeCount + changeCount) > maxCount then
+                    Log.error(`deltaMap DIFF would grow map past maxCount {maxCount}`)
+                end
                 total += ccLen
                 for _ = 1, changeCount do
                     local k, kc = keyCodec.read(src, pos + total, refs)

package/src/codec/composite/Shared.luau

@@ -97,7 +97,9 @@ end
 --[[
     Stack-based scratch ChannelState pool. Re-entrant codec serialization
     (a codec writing into scratch that triggers another codec's scratch
-    acquire) works without aliasing.
+    acquire) works without aliasing. Full scrub on reuse so any codec that
+    reads framing fields (lastId/singleMode/itemCount/countPos) on scratch
+    sees a clean state, not stale bytes from the previous owner.
 ]]
 function Shared.acquireScratch(): Types.ChannelState
     _scratchDepth += 1
@@ -105,6 +107,15 @@ function Shared.acquireScratch(): Types.ChannelState
     if ch then
         ch.cursor = 0
         ch.refCount = 0
+        ch.lastId = -1
+        ch.countPos = -1
+        ch.itemCount = 0
+        ch.singleMode = false
+        ch.singlePos = 0
+        ch.currentPacket = nil
+        if next(ch.deltas) ~= nil then
+            table.clear(ch.deltas)
+        end
         return ch
     end
     ch = Channel.create()
@@ -171,25 +182,27 @@ function Shared.extractFields(
     return dataKeys, dataCodecs, boolKeys
 end
 
+-- `byteCount` is `(boolCount + 7) // 8`; callers with it cached pass it through.
 function Shared.packBools(
     ch: Types.ChannelState,
     value: { [string]: any },
     boolKeys: { string },
-    boolCount: number
+    boolCount: number,
+    byteCount: number?
 ): ()
     if boolCount == 0 then
         return
     end
 
-    local byteCount = (boolCount + 7) // 8
+    local bc = byteCount or (boolCount + 7) // 8
     local cursor = ch.cursor
-    if cursor + byteCount > ch.size then
-        alloc(ch, byteCount)
+    if cursor + bc > ch.size then
+        alloc(ch, bc)
     end
 
     local idx = 1
     local b = ch.buff
-    for byteIdx = 0, byteCount - 1 do
+    for byteIdx = 0, bc - 1 do
         local packed = 0
         local remaining = boolCount - idx + 1
         local limit = if remaining >= 8 then 8 else remaining
@@ -202,27 +215,32 @@ function Shared.packBools(
         writeu8(b, cursor + byteIdx, packed)
     end
 
-    ch.cursor = cursor + byteCount
+    ch.cursor = cursor + bc
 end
 
 --[[
     Integer-indexed bool-array pack. Split from packBools to skip the
     per-bit string-key getter on the bool-array hot path.
 ]]
-function Shared.packBoolArray(ch: Types.ChannelState, value: { boolean }, count: number): ()
+function Shared.packBoolArray(
+    ch: Types.ChannelState,
+    value: { boolean },
+    count: number,
+    byteCount: number?
+): ()
     if count == 0 then
         return
     end
 
-    local byteCount = (count + 7) // 8
+    local bc = byteCount or (count + 7) // 8
     local cursor = ch.cursor
-    if cursor + byteCount > ch.size then
-        alloc(ch, byteCount)
+    if cursor + bc > ch.size then
+        alloc(ch, bc)
     end
 
     local idx = 1
     local b = ch.buff
-    for byteIdx = 0, byteCount - 1 do
+    for byteIdx = 0, bc - 1 do
         local packed = 0
         local remaining = count - idx + 1
         local limit = if remaining >= 8 then 8 else remaining
@@ -235,7 +253,7 @@ function Shared.packBoolArray(ch: Types.ChannelState, value: { boolean }, count:
         writeu8(b, cursor + byteIdx, packed)
     end
 
-    ch.cursor = cursor + byteCount
+    ch.cursor = cursor + bc
 end
 
 function Shared.unpackBools(
@@ -243,15 +261,16 @@ function Shared.unpackBools(
     pos: number,
     boolKeys: { string },
     boolCount: number,
-    result: { [string]: any }
+    result: { [string]: any },
+    byteCount: number?
 ): number
     if boolCount == 0 then
         return 0
     end
 
-    local byteCount = (boolCount + 7) // 8
+    local bc = byteCount or (boolCount + 7) // 8
     local idx = 1
-    for byteIdx = 0, byteCount - 1 do
+    for byteIdx = 0, bc - 1 do
         local byte = readu8(src, pos + byteIdx)
         local remaining = boolCount - idx + 1
         local limit = if remaining >= 8 then 8 else remaining
@@ -260,7 +279,7 @@ function Shared.unpackBools(
             idx += 1
         end
     end
-    return byteCount
+    return bc
 end
 
 -- Fills `result[1..count]` in place.
@@ -268,15 +287,16 @@ function Shared.unpackBoolArray(
     src: buffer,
     pos: number,
     count: number,
-    result: { boolean }
+    result: { boolean },
+    byteCount: number?
 ): number
     if count == 0 then
         return 0
     end
 
-    local byteCount = (count + 7) // 8
+    local bc = byteCount or (count + 7) // 8
     local idx = 1
-    for byteIdx = 0, byteCount - 1 do
+    for byteIdx = 0, bc - 1 do
         local byte = readu8(src, pos + byteIdx)
         local remaining = count - idx + 1
         local limit = if remaining >= 8 then 8 else remaining
@@ -285,7 +305,7 @@ function Shared.unpackBoolArray(
             idx += 1
         end
     end
-    return byteCount
+    return bc
 end
 
 return table.freeze(Shared)

package/src/codec/composite/Struct.luau

@@ -165,7 +165,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                     result[dataKeys[i]] = directReads[i](b, off + offsets[i])
                 end
                 if boolCount > 0 then
-                    unpackBools(b, off + fixedSize, boolKeys, boolCount, result)
+                    unpackBools(b, off + fixedSize, boolKeys, boolCount, result, boolBytes)
                 end
                 return result
             end,
@@ -181,7 +181,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                 end
                 ch.cursor = cursor + fixedSize
                 if boolCount > 0 then
-                    packBools(ch, value, boolKeys, boolCount)
+                    packBools(ch, value, boolKeys, boolCount, boolBytes)
                 end
             end,
 
@@ -191,7 +191,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                     result[dataKeys[i]] = directReads[i](src, pos + offsets[i])
                 end
                 if boolCount > 0 then
-                    unpackBools(src, pos + fixedSize, boolKeys, boolCount, result)
+                    unpackBools(src, pos + fixedSize, boolKeys, boolCount, result, boolBytes)
                 end
                 return result, totalFixed
             end,
@@ -213,7 +213,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                 dataCodecs[i].write(ch, value[dataKeys[i]])
             end
             if boolCount > 0 then
-                packBools(ch, value, boolKeys, boolCount)
+                packBools(ch, value, boolKeys, boolCount, boolBytes)
             end
         end,
 
@@ -226,7 +226,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                 total += consumed
             end
             if boolCount > 0 then
-                total += unpackBools(src, pos + total, boolKeys, boolCount, result)
+                total += unpackBools(src, pos + total, boolKeys, boolCount, result, boolBytes)
             end
             return result, total
         end,
@@ -316,7 +316,7 @@ function Struct.deltaStruct(
         refs: { Instance }?
     ): number
         if hasBoolSeg and segIdx == boolSegIdx then
-            return unpackBools(src, pos, boolKeys, boolCount, target)
+            return unpackBools(src, pos, boolKeys, boolCount, target, boolBytes)
         end
         local v, consumed = dataCodecs[segIdx].read(src, pos, refs)
         target[dataKeys[segIdx]] = v
@@ -361,7 +361,7 @@ function Struct.deltaStruct(
                     prev = cur
                 end
                 if hasBoolSeg then
-                    packBools(scratch, value, boolKeys, boolCount)
+                    packBools(scratch, value, boolKeys, boolCount, boolBytes)
                     segOff[boolSegIdx] = prev
                     segLen[boolSegIdx] = scratch.cursor - prev
                 end

package/src/codec/meta/Bitfield.luau

@@ -117,11 +117,24 @@ function Bitfield.define(schema: { [string]: FieldSpec }): Types.InternalCodec<a
         local packed = 0
         for i = 1, fieldCount do
             local v = value[fieldKeys[i]]
-            if fieldTypes[i] == TYPE_BOOL then
+            local ft = fieldTypes[i]
+            if ft == TYPE_BOOL then
                 if v then
                     packed = bor(packed, lshift(1, fieldOffsets[i]))
                 end
+            elseif ft == TYPE_UINT then
+                local mask = fieldMasks[i]
+                if v < 0 or v > mask or v % 1 ~= 0 then
+                    Log.error(`field "{fieldKeys[i]}" value {v} out of uint range [0, {mask}]`)
+                end
+                packed = bor(packed, lshift(v, fieldOffsets[i]))
             else
+                local signBit = fieldSignBit[i]
+                if v < -signBit or v >= signBit or v % 1 ~= 0 then
+                    Log.error(
+                        `field "{fieldKeys[i]}" value {v} out of int range [{-signBit}, {signBit - 1}]`
+                    )
+                end
                 packed = bor(packed, lshift(band(v, fieldMasks[i]), fieldOffsets[i]))
             end
         end

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
@@ -50,7 +49,6 @@ local EMPTY_REFS = table.freeze({}) :: { Instance }
 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
@@ -58,15 +56,7 @@ local writef64 = buffer.writef64
 local round = math.round
 local osClock = os.clock
 
-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
@@ -111,25 +101,47 @@ local function spliceEncoded(ch: Types.ChannelState, payload: buffer, payloadLen
 end
 
 --[[
-    Hot-swapped by enableStats() so the per-item dispatch avoids a runtime
-    branch on the stats flag. itemCount bumps AFTER codec.write so a
-    throwing codec leaves the count consistent with the buffer.
+    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): ()
     openOrUpgrade(ch, reg)
-    reg.codec.write(ch, data)
+    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
 end
 
 writeBatchStats = function(ch: Types.ChannelState, reg: Types.Registration, data: any): ()
     openOrUpgrade(ch, reg)
-    local before = ch.cursor
-    reg.codec.write(ch, data)
+    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 - before
+    reg.bytesSent += ch.cursor - rewindCursor
 end
 
 --[[
@@ -146,7 +158,12 @@ writeBatchEncodedPlain = function(
     payloadLen: number
 ): ()
     openOrUpgrade(ch, reg)
-    spliceEncoded(ch, payload, payloadLen)
+    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
 end
 
@@ -157,7 +174,12 @@ writeBatchEncodedStats = function(
     payloadLen: number
 ): ()
     openOrUpgrade(ch, reg)
-    spliceEncoded(ch, payload, payloadLen)
+    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
@@ -241,48 +263,114 @@ 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
 
@@ -315,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)
@@ -327,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

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

@@ -209,6 +209,7 @@ function Reader.process(
             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 not isZeroSize and pos >= incomingLen then
@@ -249,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

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 }