@axpecter/lync 2.1.2 → 2.2.0

package/src/transport/Gate.luau

@@ -2,120 +2,111 @@
 --!native
 -- Schema-aware validation and rate limiting.
 
-local Middleware = require(script.Parent.Parent.internal.Middleware)
-local Registry = require(script.Parent.Parent.internal.Registry)
 local Types = require(script.Parent.Parent.Types)
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local DEFAULT_DEPTH = 16
+local STRIKE_DECAY_SEC = 5
 
--- State ---------------------------------------------------------------
+-- State ------------------------------------------------------------------
 
 local _depth = DEFAULT_DEPTH
-local _rateLimits: { [number]: { [Player]: Types.RateLimitState } } = {}
-local _globalLimits: { [Player]: Types.RateLimitState } = {}
 local _globalMaxPerSecond: number? = nil
 local _bandwidthSoftLimit: number? = nil
-local _bandwidthMaxStrikes: number? = nil
+local _bandwidthMaxStrikes = 10
+local _rateLimits: { [number]: { [Player]: Types.RateLimitState } } = {}
+local _globalLimits: { [Player]: Types.RateLimitState } = {}
 local _bandwidthStrikes: { [Player]: number } = {}
+local _bandwidthLastSeen: { [Player]: number } = {}
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local isfinite = math.isfinite
 local floor = math.floor
-local abs = math.abs
 local clock = os.clock
+local minN = math.min
 
---[[
-    Checks a number value for NaN/inf and optionally range + integrality.
-    Returns true if the value passes all checks.
-]]
-local function validateNumber(
-    value: number,
-    isInteger: boolean?,
-    minVal: number?,
-    maxVal: number?
-): boolean
+local function checkScalarBounds(value: number, minV: number?, maxV: number?): (boolean, string?)
     if not isfinite(value) then
-        return false
+        return false, "non-finite"
     end
-
-    if isInteger and floor(value) ~= value then
-        return false
+    if minV and value < minV then
+        return false, `below min {minV}`
     end
-
-    if minVal and value < minVal then
-        return false
-    end
-    if maxVal and value > maxVal then
-        return false
+    if maxV and value > maxV then
+        return false, `above max {maxV}`
     end
+    return true, nil
+end
 
-    return true
+local function checkVectorComponents(
+    value: any,
+    components: { string },
+    minV: number,
+    maxV: number
+): (boolean, string?)
+    for _, axis in components do
+        local v = value[axis]
+        if not isfinite(v) then
+            return false, `component {axis} non-finite`
+        end
+        if v < minV or v > maxV then
+            return false, `component {axis} ({v}) out of [{minV}, {maxV}]`
+        end
+    end
+    return true, nil
 end
 
---[[
-    Recursive NaN/inf scan for values without schema metadata.
-    Used as fallback for f32, f64, auto, and Roblox types.
-]]
+local VEC2_AXES = table.freeze({ "X", "Y" })
+local VEC3_AXES = table.freeze({ "X", "Y", "Z" })
+
 local function scanValue(value: any, depth: number): boolean
     if depth <= 0 then
         return true
     end
 
     local t = typeof(value)
-
     if t == "number" then
         return isfinite(value)
     end
-
     if t == "Vector2" then
         return isfinite(value.X) and isfinite(value.Y)
     end
-
     if t == "Vector3" then
         return isfinite(value.X) and isfinite(value.Y) and isfinite(value.Z)
     end
-
     if t == "CFrame" then
         local pos = value.Position
-        if not isfinite(pos.X) or not isfinite(pos.Y) or not isfinite(pos.Z) then
+        if not (isfinite(pos.X) and isfinite(pos.Y) and isfinite(pos.Z)) then
             return false
         end
         local rx, ry, rz = value:ToEulerAnglesXYZ()
         return isfinite(rx) and isfinite(ry) and isfinite(rz)
     end
-
     if t == "UDim" then
         return isfinite(value.Scale) and isfinite(value.Offset)
     end
-
     if t == "UDim2" then
         return isfinite(value.X.Scale)
             and isfinite(value.X.Offset)
             and isfinite(value.Y.Scale)
             and isfinite(value.Y.Offset)
     end
-
     if t == "Color3" then
         return isfinite(value.R) and isfinite(value.G) and isfinite(value.B)
     end
-
     if t == "NumberRange" then
         return isfinite(value.Min) and isfinite(value.Max)
     end
-
     if t == "Rect" then
         return isfinite(value.Min.X)
             and isfinite(value.Min.Y)
             and isfinite(value.Max.X)
             and isfinite(value.Max.Y)
     end
-
     if t == "Ray" then
-        local o = value.Origin
-        local d = value.Direction
+        local o, d = value.Origin, value.Direction
         return isfinite(o.X)
             and isfinite(o.Y)
             and isfinite(o.Z)
@@ -123,7 +114,6 @@ local function scanValue(value: any, depth: number): boolean
             and isfinite(d.Y)
             and isfinite(d.Z)
     end
-
     if t == "table" then
         local nextDepth = depth - 1
         for _, v in value do
@@ -131,17 +121,10 @@ local function scanValue(value: any, depth: number): boolean
                 return false
             end
         end
-        return true
     end
-
-    -- string, boolean, nil, buffer, Instance, etc. are always clean
     return true
 end
 
---[[
-    Schema-aware validation. Dispatches based on codec metadata.
-    Returns true if valid, false + reason if not.
-]]
 local function validateWithCodec(
     value: any,
     codec: Types.InternalCodec<any>,
@@ -151,61 +134,146 @@ local function validateWithCodec(
         return true, nil
     end
 
-    local codecAny = codec :: any
-
-    -- Type check
-    local typeCheck = codecAny._typeCheck
-    if typeCheck then
-        if typeof(value) ~= typeCheck then
-            return false, `expected {typeCheck}, got {typeof(value)}`
+    -- Optional: branch on nil before any other check.
+    if codec._isOptional then
+        if value == nil then
+            return true, nil
         end
+        local inner = codec._inner :: Types.InternalCodec<any>
+        return validateWithCodec(value, inner, depth - 1)
     end
 
-    -- Boolean: typeof check is sufficient
-    if codecAny._isBool then
+    -- typeCheck (cheap fail-fast for non-composite codecs).
+    local typeCheck = codec._typeCheck
+    if typeCheck and typeof(value) ~= typeCheck then
+        return false, `expected {typeCheck}, got {typeof(value)}`
+    end
+
+    if codec._isBool then
+        return true, nil
+    end
+
+    -- Enum: value is a string (typeCheck already validated typeof);
+    -- decoded enums are guaranteed to be in the value set, but on
+    -- send-side a caller may pass an arbitrary string.
+    if codec._isEnum then
+        local valid = codec._enumValues
+        if valid and valid[value] == nil then
+            return false, `not a valid enum value: "{value}"`
+        end
         return true, nil
     end
 
-    -- Integer + range
-    if codecAny._isInteger then
+    if codec._isInteger then
         if not isfinite(value) then
             return false, "non-finite"
         end
         if floor(value) ~= value then
             return false, "non-integer"
         end
-        local minV = codecAny._min
-        local maxV = codecAny._max
-        if minV and value < minV then
-            return false, `below min {minV}`
+        return checkScalarBounds(value, codec._min, codec._max)
+    end
+
+    -- Vector quantized: per-component range check.
+    if (typeCheck == "Vector2" or typeCheck == "Vector3") and codec._min and codec._max then
+        local axes = if typeCheck == "Vector2" then VEC2_AXES else VEC3_AXES
+        return checkVectorComponents(value, axes, codec._min, codec._max)
+    end
+
+    -- Scalar quantized float (number with explicit range).
+    if typeCheck == "number" and codec._min ~= nil and codec._max ~= nil then
+        return checkScalarBounds(value, codec._min, codec._max)
+    end
+
+    if codec._isTagged then
+        if typeof(value) ~= "table" then
+            return false, "expected table for tagged variant"
+        end
+        local tagField = codec._tagField :: string
+        local tagName = value[tagField]
+        if tagName == nil then
+            return false, `missing tagField "{tagField}"`
+        end
+        local variants = codec._variants :: { [string]: Types.InternalCodec<any> }
+        local variant = variants[tagName]
+        if not variant then
+            return false, `unknown variant "{tagName}"`
+        end
+        return validateWithCodec(value, variant, depth - 1)
+    end
+
+    if codec._isArray then
+        if typeof(value) ~= "table" then
+            return false, "expected array"
+        end
+        local maxCount = codec._maxCount
+        local len = #value
+        if maxCount and len > maxCount then
+            return false, `array length {len} exceeds max {maxCount}`
         end
-        if maxV and value > maxV then
-            return false, `above max {maxV}`
+        local element = codec._element :: Types.InternalCodec<any>
+        local nextDepth = depth - 1
+        for i = 1, len do
+            local ok, reason = validateWithCodec(value[i], element, nextDepth)
+            if not ok then
+                return false, `[{i}]: {reason}`
+            end
         end
         return true, nil
     end
 
-    -- Float with range (quantized float)
-    if codecAny._min ~= nil and codecAny._max ~= nil and not codecAny._isInteger then
-        if not isfinite(value) then
-            return false, "non-finite"
+    if codec._isMap then
+        if typeof(value) ~= "table" then
+            return false, "expected map"
+        end
+        local maxCount = codec._maxCount
+        local keyCodec = codec._keyCodec :: Types.InternalCodec<any>
+        local valCodec = codec._valueCodec :: Types.InternalCodec<any>
+        local nextDepth = depth - 1
+        local count = 0
+        for k, v in value do
+            count += 1
+            if maxCount and count > maxCount then
+                return false, `map size exceeds max {maxCount}`
+            end
+            local ok, reason = validateWithCodec(k, keyCodec, nextDepth)
+            if not ok then
+                return false, `key: {reason}`
+            end
+            ok, reason = validateWithCodec(v, valCodec, nextDepth)
+            if not ok then
+                return false, `value at key "{tostring(k)}": {reason}`
+            end
         end
         return true, nil
     end
 
-    -- Struct schema: recursive per-field validation
-    if codecAny._schema then
+    if codec._isTuple then
         if typeof(value) ~= "table" then
-            return false, "expected table for struct"
+            return false, "expected tuple"
+        end
+        local elements = codec._elements :: { Types.InternalCodec<any> }
+        local nextDepth = depth - 1
+        for i = 1, #elements do
+            local ok, reason = validateWithCodec(value[i], elements[i], nextDepth)
+            if not ok then
+                return false, `[{i}]: {reason}`
+            end
         end
+        return true, nil
+    end
 
-        local schema = codecAny._schema
-        for key, fieldCodec in schema do
+    if codec._schema then
+        if typeof(value) ~= "table" then
+            return false, "expected table for struct"
+        end
+        local nextDepth = depth - 1
+        for key, fieldCodec in codec._schema do
             local fieldVal = value[key]
-            if fieldVal == nil and not (fieldCodec :: any)._isBool then
+            if fieldVal == nil and not fieldCodec._isBool then
                 return false, `missing field "{key}"`
             end
-            local ok, reason = validateWithCodec(fieldVal, fieldCodec, depth - 1)
+            local ok, reason = validateWithCodec(fieldVal, fieldCodec, nextDepth)
             if not ok then
                 return false, `field "{key}": {reason}`
             end
@@ -213,19 +281,22 @@ local function validateWithCodec(
         return true, nil
     end
 
-    -- Fallback: generic NaN scan for f32, f64, auto, and Roblox types
+    -- Fallback: NaN/inf scan for codecs without specific metadata
+    -- (raw f32/f64, untagged Roblox types, buffer, etc.).
     if not scanValue(value, depth) then
         return false, "NaN/inf detected"
     end
-
     return true, nil
 end
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Gate = {}
 
 function Gate.setDepth(depth: number): ()
+    if depth < 1 then
+        error(`[Lync] Gate.setDepth: depth must be >= 1, got {depth}`)
+    end
     _depth = depth
 end
 
@@ -237,8 +308,6 @@ function Gate.scan(value: any): boolean
     return scanValue(value, _depth)
 end
 
--- Rate limiting -------------------------------------------------------
-
 function Gate.checkRateLimit(reg: Types.Registration, player: Player): boolean
     local config = reg.rateLimit
     if not config then
@@ -247,7 +316,6 @@ function Gate.checkRateLimit(reg: Types.Registration, player: Player): boolean
 
     local now = clock()
 
-    -- Get or create per-player state
     local perPacket = _rateLimits[reg.id]
     if not perPacket then
         perPacket = {}
@@ -256,15 +324,10 @@ function Gate.checkRateLimit(reg: Types.Registration, player: Player): boolean
 
     local state = perPacket[player]
     if not state then
-        state = {
-            tokens = config.burst or 1,
-            lastRefill = now,
-            lastAccepted = 0,
-        }
+        state = { tokens = config.burst or 1, lastRefill = now, lastAccepted = 0 }
         perPacket[player] = state
     end
 
-    -- Cooldown mode
     if config.cooldown then
         if now - state.lastAccepted < config.cooldown then
             return false
@@ -273,7 +336,6 @@ function Gate.checkRateLimit(reg: Types.Registration, player: Player): boolean
         return true
     end
 
-    -- Token bucket mode
     local maxPerSecond = config.maxPerSecond
     if not maxPerSecond then
         return true
@@ -281,16 +343,13 @@ function Gate.checkRateLimit(reg: Types.Registration, player: Player): boolean
 
     local elapsed = now - state.lastRefill
     state.lastRefill = now
-
-    local burst = config.burst or 1
-    state.tokens = math.min(burst, state.tokens + elapsed * maxPerSecond)
+    state.tokens = minN(config.burst or 1, state.tokens + elapsed * maxPerSecond)
 
     if state.tokens >= 1 then
         state.tokens -= 1
         state.lastAccepted = now
         return true
     end
-
     return false
 end
 
@@ -309,39 +368,50 @@ function Gate.checkGlobalRateLimit(player: Player): boolean
 
     local elapsed = now - state.lastRefill
     state.lastRefill = now
-    state.tokens = math.min(maxPS, state.tokens + elapsed * maxPS)
+    state.tokens = minN(maxPS, state.tokens + elapsed * maxPS)
 
     if state.tokens >= 1 then
         state.tokens -= 1
         return true
     end
-
     return false
 end
 
+--[[
+    Bandwidth check: frames at or below softLimit refund a strike;
+    over-soft frames add one. Strikes also decay with idle time so a
+    quiet player isn't penalized indefinitely.
+]]
 function Gate.checkBandwidth(player: Player, bytes: number): boolean
     if not _bandwidthSoftLimit then
         return true
     end
 
+    local now = clock()
+    local last = _bandwidthLastSeen[player]
+    local strikes = _bandwidthStrikes[player] or 0
+
+    if last then
+        local decay = floor((now - last) / STRIKE_DECAY_SEC)
+        if decay > 0 then
+            strikes = if decay >= strikes then 0 else strikes - decay
+        end
+    end
+    _bandwidthLastSeen[player] = now
+
     if bytes <= _bandwidthSoftLimit then
-        local strikes = _bandwidthStrikes[player]
-        if strikes and strikes > 0 then
-            _bandwidthStrikes[player] = strikes - 1
+        if strikes > 0 then
+            strikes -= 1
         end
+        _bandwidthStrikes[player] = strikes
         return true
     end
 
-    local current = _bandwidthStrikes[player]
-    local strikes = (if current then current else 0) + 1
+    strikes += 1
     _bandwidthStrikes[player] = strikes
-
-    local maxStrikes = if _bandwidthMaxStrikes then _bandwidthMaxStrikes else 10
-    return strikes <= maxStrikes
+    return strikes <= _bandwidthMaxStrikes
 end
 
--- Configuration -------------------------------------------------------
-
 function Gate.configureGlobalRateLimit(maxPerSecond: number): ()
     _globalMaxPerSecond = maxPerSecond
 end
@@ -354,7 +424,7 @@ end
 function Gate.clearPlayer(player: Player): ()
     _globalLimits[player] = nil
     _bandwidthStrikes[player] = nil
-
+    _bandwidthLastSeen[player] = nil
     for _, perPacket in _rateLimits do
         perPacket[player] = nil
     end