@axpecter/lync 1.4.0 → 1.4.1

package/src/internal/Channel.luau

@@ -6,7 +6,7 @@ local Types = require (script.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local INITIAL_SIZE = 1024
 local MAX_SIZE = 262144
@@ -18,12 +18,15 @@ local band32 = bit32.band
 local countlz = bit32.countlz
 local lshift = bit32.lshift
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _maxSize = MAX_SIZE
+
+-- Packet name for overflow diagnostics. Not coroutine-safe: concurrent
+-- serializers may overwrite before the error fires.
 local _currentPacket = ""
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Channel = {}
 
@@ -163,9 +166,11 @@ local function sealOpen (ch: ChannelState): ()
     end
 end
 
--- Writes a query frame. Seals any open batch, then writes:
---     id (u8) + correlationId (u16) + status (u8)
--- Status 0 = payload follows. Status 1 = nil response.
+--[[
+    Writes a query frame. Seals any open batch, then writes:
+        id (u8) + correlationId (u16) + status (u8)
+    Status 0 = payload follows. Status 1 = nil response.
+]]
 function Channel.writeQuery (
     ch: ChannelState,
     id: number,

package/src/internal/Middleware.luau

@@ -2,8 +2,6 @@
 --!optimize 2
 -- Ordered intercept chains for send and receive.
 
--- State ------------------------------------------------------------------
-
 type Handler = (data: any, name: string, player: Player?) -> any?
 
 type Chain = {
@@ -11,14 +9,16 @@ type Chain = {
     snapshot: { Handler }?,
 }
 
-local _send: Chain = { handlers = {}, snapshot = nil }
-local _receive: Chain = { handlers = {}, snapshot = nil }
-
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local DROP = table.freeze ({ _tag = "drop" })
 
--- Private ----------------------------------------------------------------
+-- State --------------------------------------------------------------
+
+local _send: Chain = { handlers = {}, snapshot = nil }
+local _receive: Chain = { handlers = {}, snapshot = nil }
+
+-- Private ------------------------------------------------------------
 
 local function runChain (chain: { Handler }, data: any, name: string, player: Player?): any?
     local current = data
@@ -79,10 +79,14 @@ local function addTo (chain: Chain, fn: Handler): () -> ()
     end
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Middleware = {}
 
+Middleware.hasSend = false
+Middleware.hasReceive = false
+Middleware.DROP = DROP
+
 function Middleware.addSend (fn: Handler): () -> ()
     local remover = addTo (_send, fn)
     Middleware.hasSend = true
@@ -111,8 +115,5 @@ function Middleware.runReceive (data: any, name: string, player: Player?): any?
     return run (_receive, data, name, player)
 end
 
-Middleware.hasSend = false
-Middleware.hasReceive = false
-Middleware.DROP = DROP
-
+-- Not frozen: hasSend and hasReceive are mutated at runtime.
 return Middleware

package/src/internal/Pool.luau

@@ -7,24 +7,24 @@ local Types = require (script.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local DEFAULT_MAX = 16
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _stack = {} :: { ChannelState }
 local _depth = 0
 local _maxSize = DEFAULT_MAX
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Pool = {}
 
--- Override the max idle ChannelStates in the pool. Default 16. Range: 2–128.
+-- Override the max idle ChannelStates in the pool. Default 16. Range: 2-128.
 function Pool.setMaxSize (count: number): ()
     if count < 2 or count > 128 then
-        error (`[Lync] Pool max size must be 2–128, got {count}`)
+        error (`[Lync] Pool max size must be 2-128, got {count}`)
     end
     _maxSize = count
 end

package/src/internal/Registry.luau

@@ -8,20 +8,20 @@ type Codec<T> = Types.Codec<T>
 type Registration = Types.Registration
 type RateLimitConfig = Types.RateLimitConfig
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local KIND_PACKET = 0
 local KIND_REQUEST = 1
 local KIND_RESPONSE = 2
 local MAX_PACKETS = 255
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _entries = {} :: { Registration }
 local _names = {} :: { [string]: number }
 local _nextId = 1
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function assign (
     name: string,
@@ -77,7 +77,7 @@ local function assign (
     return reg
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Registry = {
     KIND_PACKET = KIND_PACKET,

package/src/transport/Bridge.luau

@@ -5,19 +5,19 @@
 local ReplicatedStorage = game:GetService ("ReplicatedStorage")
 local RunService = game:GetService ("RunService")
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local FOLDER = "_lync"
 local RELIABLE = "R"
 local UNRELIABLE = "U"
 local TIMEOUT = 10
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _reliable: RemoteEvent
 local _unreliable: UnreliableRemoteEvent
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Bridge = {}
 
@@ -63,4 +63,5 @@ function Bridge.setup (): ()
     table.freeze (Bridge)
 end
 
+-- Not frozen at module level: setup() populates reliable/unreliable then freezes.
 return Bridge

package/src/transport/Client.luau

@@ -13,15 +13,16 @@ local Types = require (script.Parent.Parent.Types)
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local NOT_STARTED = "[Lync] Client not started. Call Lync.start() before sending"
+
 local _reliable = nil :: ChannelState?
 local _unreliable = nil :: ChannelState?
 local _prevRecv = nil :: buffer?
 local _isStarted = false
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function receive (data: any, refs: any, applyXor: boolean): ()
     local buf = Reader.decodeIncoming (data)
@@ -67,7 +68,7 @@ local function flush (): ()
     flushChannel (Bridge.unreliable, _unreliable :: ChannelState, false)
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Client = {}
 

package/src/transport/Gate.luau

@@ -7,7 +7,7 @@ local Types = require (script.Parent.Parent.Types)
 type Registration = Types.Registration
 type RateLimitConfig = Types.RateLimitConfig
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local DEFAULT_MAX_DEPTH = 16
 
@@ -15,7 +15,7 @@ local isfinite = math.isfinite
 local min = math.min
 local clock = os.clock
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 type Bucket = {
     tokens: number,
@@ -27,7 +27,7 @@ local _buckets = {} :: { [Player]: { [number]: Bucket } }
 local _dropHandlers =
     {} :: { (player: Player, reason: string, packetName: string, data: any?) -> () }
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function fireDrop (player: Player, reason: string, packetName: string, data: any?): ()
     for _, handler in _dropHandlers do
@@ -47,7 +47,7 @@ local function isClean (value: any, depth: number): boolean
         return isfinite (value)
     end
 
-    -- String, boolean, nil are always clean . Exit before table/vector/userdata checks
+    -- String, boolean, nil are always clean. Exit before table/vector/userdata checks.
     if t == "string" or t == "boolean" or t == "nil" then
         return true
     end
@@ -152,7 +152,7 @@ local function checkRate (player: Player, reg: Registration): boolean
     return false
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Gate = {}
 

package/src/transport/Reader.luau

@@ -11,14 +11,14 @@ local registryGet = Registry.get
 local gateCheck = Gate.check
 local gateReportDrop = Gate.reportDrop
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local KIND_PACKET = Registry.KIND_PACKET
 local KIND_REQUEST = Registry.KIND_REQUEST
 
 local MAX_INCOMING = 65536
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Reader = {}
 
@@ -126,7 +126,7 @@ function Reader.process (
             end
         else
             -- Query frame: id(u8, already read) + correlationId(u16) + status(u8) = 3 more bytes
-            if pos + 2 >= length then
+            if pos + 3 > length then
                 break
             end
 

package/src/transport/Server.luau

@@ -8,11 +8,6 @@ local RunService = game:GetService ("RunService")
 local Baseline = require (script.Parent.Parent.internal.Baseline)
 local Bridge = require (script.Parent.Bridge)
 local Channel = require (script.Parent.Parent.internal.Channel)
-
-local channelWriteBatch = Channel.writeBatch
-local channelWriteBatchRaw = Channel.writeBatchRaw
-local channelSetPacket = Channel.setCurrentPacket
-
 local Gate = require (script.Parent.Gate)
 local Middleware = require (script.Parent.Parent.internal.Middleware)
 local Pool = require (script.Parent.Parent.internal.Pool)
@@ -22,7 +17,11 @@ local Types = require (script.Parent.Parent.Types)
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- State ------------------------------------------------------------------
+local channelWriteBatch = Channel.writeBatch
+local channelWriteBatchRaw = Channel.writeBatchRaw
+local channelSetPacket = Channel.setCurrentPacket
+
+-- State --------------------------------------------------------------
 
 type PlayerState = {
     reliable: ChannelState,
@@ -34,7 +33,7 @@ local _prevRecv = {} :: { [Player]: buffer }
 local _isStarted = false
 local _broadScratch = Channel.create ()
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function onPlayerAdded (player: Player): ()
     _players[player] = {
@@ -227,7 +226,7 @@ local function broadcastToSet (
     end
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Server = {}