@axpecter/lync 2.1.2 → 2.2.0

package/package.json

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

package/src/Types.luau

@@ -1,5 +1,4 @@
 --!strict
---!optimize 2
 -- Shared type definitions for the Lync networking library.
 
 export type ChannelState = {
@@ -13,17 +12,27 @@ export type ChannelState = {
     itemCount: number,
     singleMode: boolean,
     singlePos: number,
-    deltas: { [number]: any },
+    deltas: { [number]: DeltaCacheEntry },
     prevDump: buffer?,
     prevDumpLen: number,
     currentPacket: string?,
 }
 
+export type DeltaCacheEntry = {
+    raw: buffer,
+    len: number,
+}
+
 export type Codec<T> = {
     write: (ch: ChannelState, value: T) -> (),
     read: (src: buffer, pos: number, refs: { Instance }?) -> (T, number),
 }
 
+--[[
+    InternalCodec carries optional metadata used by Gate (validation),
+    Reader (max-item bound), Auto (type dispatch), and composite codecs
+    (direct write/read fast path).
+]]
 export type InternalCodec<T> = {
     write: (ch: ChannelState, value: T) -> (),
     read: (src: buffer, pos: number, refs: { Instance }?) -> (T, number),
@@ -38,6 +47,25 @@ export type InternalCodec<T> = {
     _isInteger: boolean?,
     _schema: { [string]: InternalCodec<any> }?,
     _typeCheck: string?,
+    --[[
+        Composite-codec metadata. Gate uses these to recurse element /
+        variant validation rather than fall through to a generic NaN scan.
+    ]]
+    _isOptional: boolean?,
+    _inner: InternalCodec<any>?,
+    _isTagged: boolean?,
+    _variants: { [string]: InternalCodec<any> }?,
+    _tagField: string?,
+    _isArray: boolean?,
+    _element: InternalCodec<any>?,
+    _maxCount: number?,
+    _isMap: boolean?,
+    _keyCodec: InternalCodec<any>?,
+    _valueCodec: InternalCodec<any>?,
+    _isTuple: boolean?,
+    _elements: { InternalCodec<any> }?,
+    _isEnum: boolean?,
+    _enumValues: { [string]: number }?,
 }
 
 export type RateLimitState = {
@@ -46,24 +74,30 @@ export type RateLimitState = {
     lastAccepted: number,
 }
 
+--[[
+    Token-bucket (maxPerSecond + optional burst) or cooldown (cooldown
+    seconds between accepts). Mixing both forms is undefined.
+]]
 export type RateLimitConfig = {
     maxPerSecond: number?,
     burst: number?,
     cooldown: number?,
 }
 
+export type ValidateFn = (data: any, player: Player) -> (boolean, string?)
+
 export type PacketOptions = {
     unreliable: boolean?,
     rateLimit: RateLimitConfig?,
-    validate: ((data: any, player: Player) -> (boolean, string?))?,
+    validate: ValidateFn?,
     maxPayloadBytes: number?,
-    timestamp: string?,
+    timestamp: ("frame" | "offset" | "full")?,
 }
 
 export type QueryOptions = {
     timeout: number?,
     rateLimit: RateLimitConfig?,
-    validate: ((data: any, player: Player) -> (boolean, string?))?,
+    validate: ValidateFn?,
 }
 
 export type Registration = {
@@ -75,7 +109,7 @@ export type Registration = {
     partner: number?,
     signal: SignalLike,
     rateLimit: RateLimitConfig?,
-    validate: ((data: any, player: Player) -> (boolean, string?))?,
+    validate: ValidateFn?,
     needsGate: boolean,
     maxPayloadBytes: number?,
     timestampMode: number,
@@ -90,7 +124,12 @@ export type Registration = {
 
 export type SignalLike = {
     fire: (self: SignalLike, ...any) -> (),
+    fireSync: (self: SignalLike, ...any) -> (),
     connect: (self: SignalLike, callback: (...any) -> ()) -> Connection,
+    once: (self: SignalLike, callback: (...any) -> ()) -> Connection,
+    wait: (self: SignalLike) -> ...any,
+    count: (self: SignalLike) -> number,
+    hasListeners: (self: SignalLike) -> boolean,
 }
 
 export type Connection = {
@@ -102,13 +141,8 @@ export type ConfigureOptions = {
     channelMaxSize: number?,
     validationDepth: number?,
     poolSize: number?,
-    bandwidthLimit: {
-        softLimit: number,
-        maxStrikes: number,
-    }?,
-    globalRateLimit: {
-        maxPerSecond: number,
-    }?,
+    bandwidthLimit: { softLimit: number, maxStrikes: number }?,
+    globalRateLimit: { maxPerSecond: number }?,
     stats: boolean?,
 }
 
@@ -125,4 +159,10 @@ export type PlayerStats = {
     bytesReceived: number,
 }
 
+--[[
+    Server keys baselines per Player; client uses `false` since booleans
+    are valid table keys but Players never collide with that.
+]]
+export type BaselineKey = Player | false
+
 return nil

package/src/api/Group.luau

@@ -4,15 +4,31 @@
 
 local Players = game:GetService("Players")
 
-local Types = require(script.Parent.Parent.Types)
+local Util = require(script.Parent.Parent.internal.Util)
 
--- State ---------------------------------------------------------------
+-- Public types -----------------------------------------------------------
 
-local _groups: { [string]: any } = {}
-local _playerCleanup: { [Player]: { any } } = {}
+export type GroupHandle = {
+    add: (self: GroupHandle, player: Player) -> boolean,
+    remove: (self: GroupHandle, player: Player) -> boolean,
+    has: (self: GroupHandle, player: Player) -> boolean,
+    count: (self: GroupHandle) -> number,
+    destroy: (self: GroupHandle) -> (),
+    _lyncGroup: boolean,
+    _members: { [Player]: boolean },
+}
+
+type Group = GroupHandle & { _count: number, _name: string }
+
+-- State ------------------------------------------------------------------
+
+local _groups: { [string]: Group } = {}
+local _playerCleanup: { [Player]: { Group } } = {}
 local _cleanupConnected = false
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
+
+local swapRemove = Util.swapRemove
 
 local function ensureCleanup(): ()
     if _cleanupConnected then
@@ -25,48 +41,30 @@ local function ensureCleanup(): ()
         if not groups then
             return
         end
-
         for _, group in groups do
             group._members[player] = nil
             group._count -= 1
         end
-
         _playerCleanup[player] = nil
     end)
 end
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Group = {}
 
-export type GroupHandle = {
-    add: (self: GroupHandle, player: Player) -> boolean,
-    remove: (self: GroupHandle, player: Player) -> boolean,
-    has: (self: GroupHandle, player: Player) -> boolean,
-    count: (self: GroupHandle) -> number,
-    destroy: (self: GroupHandle) -> (),
-    _lyncGroup: boolean,
-    _members: { [Player]: boolean },
-}
-
 local GroupMeta = {}
 GroupMeta.__index = GroupMeta
 
-function GroupMeta.__iter(self: any): () -> (Player?, boolean?)
-    local members = self._members
-    local key: Player? = nil
-
-    return function(): (Player?, boolean?)
-        local nextKey, nextVal = next(members, key)
-        key = nextKey
-        if nextKey then
-            return nextKey, nextVal
-        end
-        return nil, nil
-    end
+--[[
+    __iter returns the standard 3-tuple iterator so `for player in group do`
+    uses Luau's builtin path (luaH_next) with zero closure allocation.
+]]
+function GroupMeta.__iter(self: Group): (any, any, any)
+    return next, self._members, nil
 end
 
-function GroupMeta.add(self: any, player: Player): boolean
+function GroupMeta.add(self: Group, player: Player): boolean
     if self._members[player] then
         return false
     end
@@ -74,18 +72,16 @@ function GroupMeta.add(self: any, player: Player): boolean
     self._members[player] = true
     self._count += 1
 
-    -- Track for auto-cleanup
     local cleanup = _playerCleanup[player]
     if not cleanup then
         cleanup = {}
         _playerCleanup[player] = cleanup
     end
     table.insert(cleanup, self)
-
     return true
 end
 
-function GroupMeta.remove(self: any, player: Player): boolean
+function GroupMeta.remove(self: Group, player: Player): boolean
     if not self._members[player] then
         return false
     end
@@ -93,43 +89,35 @@ function GroupMeta.remove(self: any, player: Player): boolean
     self._members[player] = nil
     self._count -= 1
 
-    -- Remove from cleanup tracking
     local cleanup = _playerCleanup[player]
     if cleanup then
         local idx = table.find(cleanup, self)
         if idx then
-            local last = #cleanup
-            cleanup[idx] = cleanup[last]
-            cleanup[last] = nil
+            swapRemove(cleanup, idx)
         end
     end
-
     return true
 end
 
-function GroupMeta.has(self: any, player: Player): boolean
+function GroupMeta.has(self: Group, player: Player): boolean
     return self._members[player] == true
 end
 
-function GroupMeta.count(self: any): number
+function GroupMeta.count(self: Group): number
     return self._count
 end
 
-function GroupMeta.destroy(self: any): ()
-    local name = self._name
-    if name then
-        _groups[name] = nil
+function GroupMeta.destroy(self: Group): ()
+    if _groups[self._name] == self then
+        _groups[self._name] = nil
     end
 
-    -- Remove all members from cleanup tracking
     for player in self._members do
         local cleanup = _playerCleanup[player]
         if cleanup then
             local idx = table.find(cleanup, self)
             if idx then
-                local last = #cleanup
-                cleanup[idx] = cleanup[last]
-                cleanup[last] = nil
+                swapRemove(cleanup, idx)
             end
         end
     end
@@ -138,6 +126,8 @@ function GroupMeta.destroy(self: any): ()
     self._count = 0
 end
 
+table.freeze(GroupMeta)
+
 function Group.create(name: string): GroupHandle
     if _groups[name] then
         error(`[Lync] Lync.group: "{name}" already exists`)
@@ -150,10 +140,10 @@ function Group.create(name: string): GroupHandle
         _members = {} :: { [Player]: boolean },
         _count = 0,
         _name = name,
-    }, GroupMeta)
+    }, GroupMeta) :: any
 
     _groups[name] = group
-    return group :: any
+    return group
 end
 
 return table.freeze(Group)