@axpecter/lync 1.4.3 → 1.5.0

package/src/transport/Gate.luau

@@ -1,13 +1,13 @@
 --!strict
---!optimize 2
+--!native
 -- Post-deserialization security: NaN/inf, rate limiting, custom validate.
 
-local Types = require (script.Parent.Parent.Types)
+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,24 +27,23 @@ 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?): ()
+local function fireDrop(player: Player, reason: string, packetName: string, data: any?): ()
     for _, handler in _dropHandlers do
-        handler (player, reason, packetName, data)
+        handler(player, reason, packetName, data)
     end
 end
 
-@native
-local function isClean (value: any, depth: number): boolean
+local function isClean(value: any, depth: number): boolean
     if depth > _maxDepth then
         return false
     end
 
-    local t = type (value)
+    local t = type(value)
 
     if t == "number" then
-        return isfinite (value)
+        return isfinite(value)
     end
 
     -- String, boolean, nil are always clean. Exit before table/vector/userdata checks.
@@ -55,7 +54,7 @@ local function isClean (value: any, depth: number): boolean
     if t == "table" then
         local deeper = depth + 1
         for k, v in value do
-            if not isClean (k, deeper) or not isClean (v, deeper) then
+            if not isClean(k, deeper) or not isClean(v, deeper) then
                 return false
             end
         end
@@ -63,60 +62,53 @@ local function isClean (value: any, depth: number): boolean
     end
 
     if t == "vector" then
-        return isfinite (value.X) and isfinite (value.Y) and isfinite (value.Z)
+        return isfinite(value.X) and isfinite(value.Y) and isfinite(value.Z)
     end
 
     if t == "userdata" then
-        local ut = typeof (value)
+        local ut = typeof(value)
 
         if ut == "Vector2" then
-            return isfinite (value.X) and isfinite (value.Y)
+            return isfinite(value.X) and isfinite(value.Y)
         elseif ut == "Color3" then
-            return isfinite (value.R) and isfinite (value.G) and isfinite (value.B)
+            return isfinite(value.R) and isfinite(value.G) and isfinite(value.B)
         elseif ut == "CFrame" then
             local position = value.Position
-            if
-                not isfinite (position.X)
-                or not isfinite (position.Y)
-                or not isfinite (position.Z)
-            then
+            if not isfinite(position.X) or not isfinite(position.Y) or not isfinite(position.Z) then
                 return false
             end
-            local axis, angle = value:ToAxisAngle ()
-            return isfinite (angle)
-                and isfinite (axis.X)
-                and isfinite (axis.Y)
-                and isfinite (axis.Z)
+            local axis, angle = value:ToAxisAngle()
+            return isfinite(angle) and isfinite(axis.X) and isfinite(axis.Y) and isfinite(axis.Z)
         elseif ut == "UDim" then
-            return isfinite (value.Scale)
+            return isfinite(value.Scale)
         elseif ut == "UDim2" then
-            return isfinite (value.X.Scale) and isfinite (value.Y.Scale)
+            return isfinite(value.X.Scale) and isfinite(value.Y.Scale)
         elseif ut == "NumberRange" then
-            return isfinite (value.Min) and isfinite (value.Max)
+            return isfinite(value.Min) and isfinite(value.Max)
         elseif ut == "Rect" then
-            return isfinite (value.Min.X)
-                and isfinite (value.Min.Y)
-                and isfinite (value.Max.X)
-                and isfinite (value.Max.Y)
+            return isfinite(value.Min.X)
+                and isfinite(value.Min.Y)
+                and isfinite(value.Max.X)
+                and isfinite(value.Max.Y)
         elseif ut == "Ray" then
             local origin = value.Origin
             local direction = value.Direction
-            return isfinite (origin.X)
-                and isfinite (origin.Y)
-                and isfinite (origin.Z)
-                and isfinite (direction.X)
-                and isfinite (direction.Y)
-                and isfinite (direction.Z)
+            return isfinite(origin.X)
+                and isfinite(origin.Y)
+                and isfinite(origin.Z)
+                and isfinite(direction.X)
+                and isfinite(direction.Y)
+                and isfinite(direction.Z)
         elseif ut == "Region3" then
             local position = value.CFrame.Position
-            return isfinite (position.X) and isfinite (position.Y) and isfinite (position.Z)
+            return isfinite(position.X) and isfinite(position.Y) and isfinite(position.Z)
         end
     end
 
     return true
 end
 
-local function checkRate (player: Player, reg: Registration): boolean
+local function checkRate(player: Player, reg: Registration): boolean
     local cfg = reg.rateLimit
     if not cfg then
         return true
@@ -128,7 +120,7 @@ local function checkRate (player: Player, reg: Registration): boolean
     end
 
     local id = reg.id
-    local now = clock ()
+    local now = clock()
     local cap = cfg.burstAllowance or cfg.maxPerSecond
     local bucket = playerBuckets[id]
 
@@ -141,7 +133,7 @@ local function checkRate (player: Player, reg: Registration): boolean
     end
 
     local elapsed = now - bucket.lastRef
-    bucket.tokens = min (cap, bucket.tokens + elapsed * cfg.maxPerSecond)
+    bucket.tokens = min(cap, bucket.tokens + elapsed * cfg.maxPerSecond)
     bucket.lastRef = now
 
     if bucket.tokens >= 1 then
@@ -152,38 +144,38 @@ local function checkRate (player: Player, reg: Registration): boolean
     return false
 end
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Gate = {}
 
 -- Override the max recursion depth for NaN/inf scanning. Default 16. Range: 4–32.
-function Gate.setMaxDepth (depth: number): ()
+function Gate.setMaxDepth(depth: number): ()
     if depth < 4 or depth > 32 then
-        error (`[Lync] Gate max depth must be 4–32, got {depth}`)
+        error(`[Lync] Gate max depth must be 4–32, got {depth}`)
     end
     _maxDepth = depth
 end
 
-function Gate.getMaxDepth (): number
+function Gate.getMaxDepth(): number
     return _maxDepth
 end
 
-function Gate.check (value: any, reg: Registration, player: Player): boolean
-    if not checkRate (player, reg) then
-        fireDrop (player, "rate", reg.name, nil)
+function Gate.check(value: any, reg: Registration, player: Player): boolean
+    if not checkRate(player, reg) then
+        fireDrop(player, "rate", reg.name, nil)
         return false
     end
 
-    if not isClean (value, 1) then
-        fireDrop (player, "nan", reg.name, value)
+    if not isClean(value, 1) then
+        fireDrop(player, "nan", reg.name, value)
         return false
     end
 
     local validate = reg.validate
     if validate then
-        local ok, reason = validate (value, player)
+        local ok, reason = validate(value, player)
         if not ok then
-            fireDrop (player, reason or "validate", reg.name, value)
+            fireDrop(player, reason or "validate", reg.name, value)
             return false
         end
     end
@@ -191,32 +183,32 @@ function Gate.check (value: any, reg: Registration, player: Player): boolean
     return true
 end
 
-function Gate.onDrop (
+function Gate.onDrop(
     callback: (player: Player, reason: string, packetName: string, data: any?) -> ()
 ): () -> ()
-    table.insert (_dropHandlers, callback)
+    table.insert(_dropHandlers, callback)
 
-    return function (): ()
-        local idx = table.find (_dropHandlers, callback)
+    return function(): ()
+        local idx = table.find(_dropHandlers, callback)
         if idx then
-            table.remove (_dropHandlers, idx)
+            table.remove(_dropHandlers, idx)
         end
     end
 end
 
 -- Fires drop handlers without validation. Used by Reader for byte-budget violations.
-function Gate.reportDrop (player: Player?, reason: string, packetName: string, data: any?): ()
+function Gate.reportDrop(player: Player?, reason: string, packetName: string, data: any?): ()
     if player and #_dropHandlers > 0 then
-        fireDrop (player, reason, packetName, data)
+        fireDrop(player, reason, packetName, data)
     end
 end
 
-function Gate.onPlayerAdded (player: Player): ()
+function Gate.onPlayerAdded(player: Player): ()
     _buckets[player] = {}
 end
 
-function Gate.onPlayerRemoved (player: Player): ()
+function Gate.onPlayerRemoved(player: Player): ()
     _buckets[player] = nil
 end
 
-return table.freeze (Gate)
+return table.freeze(Gate)

package/src/transport/Reader.luau

@@ -2,49 +2,49 @@
 --!optimize 2
 -- Deserializes incoming buffers and routes by registration kind.
 
-local Baseline = require (script.Parent.Parent.internal.Baseline)
-local Gate = require (script.Parent.Gate)
-local Middleware = require (script.Parent.Parent.internal.Middleware)
-local Registry = require (script.Parent.Parent.internal.Registry)
+local Baseline = require(script.Parent.Parent.internal.Baseline)
+local Gate = require(script.Parent.Gate)
+local Middleware = require(script.Parent.Parent.internal.Middleware)
+local Registry = require(script.Parent.Parent.internal.Registry)
 
 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 = {}
 
 -- Shared incoming-data validation used by both Client and Server receive.
-function Reader.decodeIncoming (data: any): buffer?
-    if typeof (data) ~= "buffer" then
+function Reader.decodeIncoming(data: any): buffer?
+    if typeof(data) ~= "buffer" then
         return nil
     end
-    if buffer.len (data) > MAX_INCOMING then
+    if buffer.len(data) > MAX_INCOMING then
         return nil
     end
     return data
 end
 
 -- Callers wrap this in pcall. Any throw aborts the entire buffer from this source.
-function Reader.process (
+function Reader.process(
     incoming: buffer,
     refs: { Instance }?,
     player: Player?,
     startOffset: number
 ): ()
-    local length = buffer.len (incoming)
+    local length = buffer.len(incoming)
     local pos = startOffset
 
     if Baseline.hasDelta then
-        Baseline.setReadKey (player or false)
+        Baseline.setReadKey(player or false)
     end
 
     -- Cache flags once per frame-buffer, not per packet
@@ -52,12 +52,12 @@ function Reader.process (
     local isServer = player ~= nil
 
     while pos < length do
-        local id = buffer.readu8 (incoming, pos)
+        local id = buffer.readu8(incoming, pos)
         pos += 1
 
-        local reg = registryGet (id)
+        local reg = registryGet(id)
         if not reg then
-            warn (`[Lync] Unknown packet ID {id}`)
+            warn(`[Lync] Unknown packet ID {id}`)
             break
         end
 
@@ -68,7 +68,7 @@ function Reader.process (
                 break
             end
 
-            local count = buffer.readu16 (incoming, pos)
+            local count = buffer.readu16(incoming, pos)
             pos += 2
 
             if count == 0 then
@@ -87,9 +87,9 @@ function Reader.process (
                         break
                     end
 
-                    local value, consumed = codec.read (incoming, pos, refs)
+                    local value, consumed = codec.read(incoming, pos, refs)
                     pos += consumed
-                    signal:fire (value, player)
+                    signal:fire(value, player)
                 end
             else
                 -- Cold path: gate and/or middleware and/or byte budget active
@@ -102,25 +102,25 @@ function Reader.process (
                     end
 
                     if maxBytes and (pos - batchStart) > maxBytes then
-                        gateReportDrop (player, "size", reg.name, nil)
+                        gateReportDrop(player, "size", reg.name, nil)
                         break
                     end
 
-                    local value, consumed = codec.read (incoming, pos, refs)
+                    local value, consumed = codec.read(incoming, pos, refs)
                     pos += consumed
 
-                    if needsGate and not gateCheck (value, reg, player :: Player) then
+                    if needsGate and not gateCheck(value, reg, player :: Player) then
                         continue
                     end
 
                     if hasReceiveMiddleware then
-                        local final = Middleware.runReceive (value, baseName, player)
+                        local final = Middleware.runReceive(value, baseName, player)
                         if final == nil then
                             continue
                         end
-                        signal:fire (final, player)
+                        signal:fire(final, player)
                     else
-                        signal:fire (value, player)
+                        signal:fire(value, player)
                     end
                 end
             end
@@ -133,29 +133,29 @@ function Reader.process (
             local queryCodec = reg.codec
             local querySignal = reg.signal
 
-            local correlationId = buffer.readu16 (incoming, pos)
-            local status = buffer.readu8 (incoming, pos + 2)
+            local correlationId = buffer.readu16(incoming, pos)
+            local status = buffer.readu8(incoming, pos + 2)
             pos += 3
 
             if status == 1 then
                 if kind == KIND_REQUEST then
-                    querySignal:fire (nil, player, correlationId)
+                    querySignal:fire(nil, player, correlationId)
                 else
-                    querySignal:fire (nil, correlationId)
+                    querySignal:fire(nil, correlationId)
                 end
                 continue
             end
 
-            local value, consumed = queryCodec.read (incoming, pos, refs)
+            local value, consumed = queryCodec.read(incoming, pos, refs)
             pos += consumed
 
-            if isServer and reg.needsGate and not gateCheck (value, reg, player :: Player) then
+            if isServer and reg.needsGate and not gateCheck(value, reg, player :: Player) then
                 continue
             end
 
             local final: any
             if hasReceiveMiddleware then
-                final = Middleware.runReceive (value, reg.baseName, player)
+                final = Middleware.runReceive(value, reg.baseName, player)
                 if final == nil then
                     continue
                 end
@@ -164,12 +164,12 @@ function Reader.process (
             end
 
             if kind == KIND_REQUEST then
-                querySignal:fire (final, player, correlationId)
+                querySignal:fire(final, player, correlationId)
             else
-                querySignal:fire (final, correlationId)
+                querySignal:fire(final, correlationId)
             end
         end
     end
 end
 
-return table.freeze (Reader)
+return table.freeze(Reader)