@axpecter/lync 1.5.2 → 2.1.0

package/package.json

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

package/src/Types.luau

@@ -7,11 +7,16 @@ export type ChannelState = {
     cursor: number,
     size: number,
     refs: { Instance },
+    refCount: number,
     lastId: number,
     countPos: number,
     itemCount: number,
-    deltas: { [number]: any }, -- per-codec delta caches; shape varies by codec kind
+    singleMode: boolean,
+    singlePos: number,
+    deltas: { [number]: any },
     prevDump: buffer?,
+    prevDumpLen: number,
+    currentPacket: string?,
 }
 
 export type Codec<T> = {
@@ -19,7 +24,6 @@ export type Codec<T> = {
     read: (src: buffer, pos: number, refs: { Instance }?) -> (T, number),
 }
 
--- Extended codec exposing internal fast-path metadata used by composite codecs.
 export type InternalCodec<T> = {
     write: (ch: ChannelState, value: T) -> (),
     read: (src: buffer, pos: number, refs: { Instance }?) -> (T, number),
@@ -28,59 +32,97 @@ export type InternalCodec<T> = {
     _directRead: ((b: buffer, offset: number) -> T)?,
     _isDelta: boolean?,
     _isBool: boolean?,
+    _hasUnknown: boolean?,
+    _min: number?,
+    _max: number?,
+    _isInteger: boolean?,
+    _schema: { [string]: InternalCodec<any> }?,
+    _typeCheck: string?,
+}
+
+export type RateLimitState = {
+    tokens: number,
+    lastRefill: number,
+    lastAccepted: number,
 }
 
 export type RateLimitConfig = {
-    maxPerSecond: number,
-    burstAllowance: number?,
+    maxPerSecond: number?,
+    burst: number?,
+    cooldown: number?,
 }
 
-export type PacketConfig<T> = {
-    value: Codec<T>,
+export type PacketOptions = {
     unreliable: boolean?,
     rateLimit: RateLimitConfig?,
-    validate: ((data: T, player: Player) -> (boolean, string?))?,
+    validate: ((data: any, player: Player) -> (boolean, string?))?,
     maxPayloadBytes: number?,
+    timestamp: string?,
 }
 
-export type QueryConfig<Req, Resp> = {
-    request: Codec<Req>,
-    response: Codec<Resp>,
+export type QueryOptions = {
     timeout: number?,
     rateLimit: RateLimitConfig?,
-    validate: ((data: Req, player: Player) -> (boolean, string?))?,
-}
-
-export type NamespaceConfig = {
-    packets: { [string]: PacketConfig<any> }?,
-    queries: { [string]: QueryConfig<any, any> }?,
-}
-
--- Minimal signal interface for Registration. Avoids circular dependency
--- with Signal.luau while typing the two methods consumers actually call.
-export type SignalLike = {
-    fire: (self: SignalLike, ...any) -> (),
-    connect: (self: SignalLike, callback: (...any) -> ()) -> Connection,
+    validate: ((data: any, player: Player) -> (boolean, string?))?,
 }
 
 export type Registration = {
     id: number,
     name: string,
-    baseName: string,
-    codec: Codec<any>,
-    isUnreliable: boolean,
     kind: number,
+    codec: InternalCodec<any>,
+    isUnreliable: boolean,
     partner: number?,
     signal: SignalLike,
     rateLimit: RateLimitConfig?,
     validate: ((data: any, player: Player) -> (boolean, string?))?,
     needsGate: boolean,
     maxPayloadBytes: number?,
+    timestampMode: number,
+    headerSize: number,
+    _openFn: (ch: ChannelState, id: number) -> (),
+    bytesSent: number,
+    bytesReceived: number,
+    fires: number,
+    recvFires: number,
+    drops: number,
+}
+
+export type SignalLike = {
+    fire: (self: SignalLike, ...any) -> (),
+    connect: (self: SignalLike, callback: (...any) -> ()) -> Connection,
 }
 
 export type Connection = {
-    disconnect: (self: Connection) -> (),
     connected: boolean,
+    disconnect: (self: Connection) -> (),
+}
+
+export type ConfigureOptions = {
+    channelMaxSize: number?,
+    validationDepth: number?,
+    poolSize: number?,
+    bandwidthLimit: {
+        softLimit: number,
+        maxStrikes: number,
+    }?,
+    globalRateLimit: {
+        maxPerSecond: number,
+    }?,
+    stats: boolean?,
+}
+
+export type PacketStats = {
+    bytesSent: number,
+    bytesReceived: number,
+    fires: number,
+    recvFires: number,
+    drops: number,
+}
+
+export type PlayerStats = {
+    bytesSent: number,
+    bytesReceived: number,
 }
 
 return nil

package/src/api/Group.luau

@@ -1,164 +1,159 @@
 --!strict
 --!optimize 2
--- Named player sets with auto-cleanup on PlayerRemoving.
+-- Named player sets with __iter, auto-cleanup on PlayerRemoving.
 
 local Players = game:GetService("Players")
 
+local Types = require(script.Parent.Parent.Types)
+
 -- State ---------------------------------------------------------------
 
-local _groups = {} :: { [string]: { [Player]: true } }
-local _counts = {} :: { [string]: number }
-local _playerGroups = {} :: { [Player]: { [string]: true } }
+local _groups: { [string]: any } = {}
+local _playerCleanup: { [Player]: { any } } = {}
+local _cleanupConnected = false
 
 -- Private -------------------------------------------------------------
 
-local function onPlayerRemoving(player: Player): ()
-    local memberships = _playerGroups[player]
-    if not memberships then
+local function ensureCleanup(): ()
+    if _cleanupConnected then
         return
     end
+    _cleanupConnected = true
 
-    for name in memberships do
-        local set = _groups[name]
-        if set and set[player] then
-            set[player] = nil
-            _counts[name] -= 1
+    Players.PlayerRemoving:Connect(function(player: Player)
+        local groups = _playerCleanup[player]
+        if not groups then
+            return
         end
-    end
 
-    _playerGroups[player] = nil
+        for _, group in groups do
+            group._members[player] = nil
+            group._count -= 1
+        end
+
+        _playerCleanup[player] = nil
+    end)
 end
 
-Players.PlayerRemoving:Connect(onPlayerRemoving)
+-- Public --------------------------------------------------------------
 
-type GroupFields = {
-    _tag: "group",
-    _name: string,
+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 GroupImpl = {}
-GroupImpl.__index = GroupImpl
+local GroupMeta = {}
+GroupMeta.__index = GroupMeta
 
-export type Group = typeof(setmetatable({} :: GroupFields, GroupImpl))
+function GroupMeta.__iter(self: any): () -> (Player?, boolean?)
+    local members = self._members
+    local key: Player? = nil
 
-function GroupImpl.add(self: Group, player: Player): boolean
-    local name = self._name
-    local set = _groups[name]
-    if not set then
-        error(`[Lync] Group has been destroyed: "{name}"`)
+    return function(): (Player?, boolean?)
+        local nextKey, nextVal = next(members, key)
+        key = nextKey
+        if nextKey then
+            return nextKey, nextVal
+        end
+        return nil, nil
     end
+end
 
-    if set[player] then
+function GroupMeta.add(self: any, player: Player): boolean
+    if self._members[player] then
         return false
     end
 
-    set[player] = true
-    _counts[name] += 1
+    self._members[player] = true
+    self._count += 1
 
-    local memberships = _playerGroups[player]
-    if not memberships then
-        memberships = {}
-        _playerGroups[player] = memberships
+    -- Track for auto-cleanup
+    local cleanup = _playerCleanup[player]
+    if not cleanup then
+        cleanup = {}
+        _playerCleanup[player] = cleanup
     end
-    memberships[name] = true
+    table.insert(cleanup, self)
 
     return true
 end
 
-function GroupImpl.remove(self: Group, player: Player): boolean
-    local name = self._name
-    local set = _groups[name]
-    if not set then
-        error(`[Lync] Group has been destroyed: "{name}"`)
-    end
-
-    if not set[player] then
+function GroupMeta.remove(self: any, player: Player): boolean
+    if not self._members[player] then
         return false
     end
 
-    set[player] = nil
-    _counts[name] -= 1
+    self._members[player] = nil
+    self._count -= 1
 
-    local memberships = _playerGroups[player]
-    if memberships then
-        memberships[name] = nil
+    -- 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
+        end
     end
 
     return true
 end
 
-function GroupImpl.has(self: Group, player: Player): boolean
-    local name = self._name
-    local set = _groups[name]
-    if not set then
-        error(`[Lync] Group has been destroyed: "{name}"`)
-    end
-    return set[player] == true
-end
-
-function GroupImpl.count(self: Group): number
-    local name = self._name
-    if not _groups[name] then
-        error(`[Lync] Group has been destroyed: "{name}"`)
-    end
-    return _counts[name]
+function GroupMeta.has(self: any, player: Player): boolean
+    return self._members[player] == true
 end
 
-function GroupImpl.forEach(self: Group, fn: (player: Player) -> ()): ()
-    local name = self._name
-    local set = _groups[name]
-    if not set then
-        error(`[Lync] Group has been destroyed: "{name}"`)
-    end
-    for player in set do
-        fn(player)
-    end
-end
-
-function GroupImpl.getSet(self: Group): { [Player]: true }
-    local name = self._name
-    local set = _groups[name]
-    if not set then
-        error(`[Lync] Group has been destroyed: "{name}"`)
-    end
-    return set
+function GroupMeta.count(self: any): number
+    return self._count
 end
 
-function GroupImpl.destroy(self: Group): ()
+function GroupMeta.destroy(self: any): ()
     local name = self._name
-    local set = _groups[name]
-    if not set then
-        error(`[Lync] Group has been destroyed: "{name}"`)
-    end
-
-    for player in set do
-        local memberships = _playerGroups[player]
-        if memberships then
-            memberships[name] = nil
+    if name then
+        _groups[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
+            end
         end
     end
 
-    _groups[name] = nil
-    _counts[name] = nil
+    table.clear(self._members)
+    self._count = 0
 end
 
-table.freeze(GroupImpl)
-
--- Public --------------------------------------------------------------
-
-local GroupModule = {}
-
-function GroupModule.create(name: string): Group
+function Group.create(name: string): GroupHandle
     if _groups[name] then
-        error(`[Lync] Group already exists: "{name}"`)
+        error(`[Lync] Lync.group: "{name}" already exists`)
     end
-    _groups[name] = {}
-    _counts[name] = 0
 
-    return setmetatable({
-        _tag = "group" :: "group",
+    ensureCleanup()
+
+    local group = setmetatable({
+        _lyncGroup = true,
+        _members = {} :: { [Player]: boolean },
+        _count = 0,
         _name = name,
-    }, GroupImpl)
+    }, GroupMeta)
+
+    _groups[name] = group
+    return group :: any
 end
 
-return table.freeze(GroupModule)
+return table.freeze(Group)