@axpecter/lync 1.4.3 → 1.5.0

package/README.md

@@ -13,7 +13,7 @@
 
 ```toml
 [dependencies]
-Lync = "axp3cter/lync@1.4.2"
+Lync = "axp3cter/lync@1.5.0"
 ```
 
 **npm (roblox-ts)**
@@ -163,7 +163,7 @@ end
 | | What it does |
 |:---------|:------------|
 | `Lync.start()` | Sets up transport. Server creates remotes, client connects. Call once after all definitions. |
-| `Lync.VERSION` | `"1.4.2"` |
+| `Lync.VERSION` | `"1.5.0"` |
 
 ## Packets
 
@@ -228,6 +228,45 @@ packet:send(data)  -- send to server
 
 `Lync.defineNamespace(name, config)` returns a Namespace. Takes a `packets` table and/or a `queries` table. All names get auto-prefixed with `"YourNamespace."` so nothing collides.
 
+The config takes `PacketConfig` and `QueryConfig` objects (same shape you'd pass to `definePacket` / `defineQuery`). The namespace creates and owns the packets/queries internally.
+
+```luau
+local Combat = Lync.defineNamespace("Combat", {
+    packets = {
+        Hit = {
+            value = Lync.struct({ targetId = Lync.u16, damage = Lync.f32, headshot = Lync.bool }),
+            rateLimit = { maxPerSecond = 30, burstAllowance = 5 },
+            validate = function(data, player)
+                if data.damage > 200 then return false, "damage" end
+                return true
+            end,
+        },
+        Death = { value = Lync.u16 },
+    },
+    queries = {
+        Stats = {
+            request  = Lync.nothing,
+            response = Lync.struct({ kills = Lync.u16, deaths = Lync.u16 }),
+            timeout  = 3,
+        },
+    },
+})
+
+-- Access by short name directly on the namespace
+Combat.Hit:send(data, player)
+Combat.Death:listen(function(targetId, sender) end)
+Combat.Stats:listen(function(request, player) return { kills = 10, deaths = 2 } end)
+
+-- Or via the typed sub-tables
+Combat.packets.Hit:send(data, player)
+Combat.queries.Stats:request(nil)
+```
+
+| Config field | Type | What it does |
+|:-------------|:-----|:-------------|
+| `packets` | `{ [string]: PacketConfig }?` | Map of short name → packet config. Each entry becomes a Packet on the namespace. |
+| `queries` | `{ [string]: QueryConfig }?` | Map of short name → query config. Each entry becomes a Query on the namespace. |
+
 Access packets and queries by their short name on the returned object: `ns.PacketName`, `ns.QueryName`. Or use the typed sub-tables: `ns.packets.PacketName`, `ns.queries.QueryName`.
 
 | Method | What it does |

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@axpecter/lync",
-    "version": "1.4.3",
+    "version": "1.5.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

@@ -51,6 +51,18 @@ export type QueryConfig<Req, Resp> = {
     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,
+}
+
 export type Registration = {
     id: number,
     name: string,
@@ -59,7 +71,7 @@ export type Registration = {
     isUnreliable: boolean,
     kind: number,
     partner: number?,
-    signal: any,
+    signal: SignalLike,
     rateLimit: RateLimitConfig?,
     validate: ((data: any, player: Player) -> (boolean, string?))?,
     needsGate: boolean,

package/src/api/Group.luau

@@ -2,17 +2,17 @@
 --!optimize 2
 -- Named player sets with auto-cleanup on PlayerRemoving.
 
-local Players = game:GetService ("Players")
+local Players = game:GetService("Players")
 
--- State --------------------------------------------------------------
+-- State ---------------------------------------------------------------
 
 local _groups = {} :: { [string]: { [Player]: true } }
 local _counts = {} :: { [string]: number }
 local _playerGroups = {} :: { [Player]: { [string]: true } }
 
--- Private ------------------------------------------------------------
+-- Private -------------------------------------------------------------
 
-local function onPlayerRemoving (player: Player): ()
+local function onPlayerRemoving(player: Player): ()
     local memberships = _playerGroups[player]
     if not memberships then
         return
@@ -29,16 +29,23 @@ local function onPlayerRemoving (player: Player): ()
     _playerGroups[player] = nil
 end
 
-Players.PlayerRemoving:Connect (onPlayerRemoving)
+Players.PlayerRemoving:Connect(onPlayerRemoving)
+
+type GroupFields = {
+    _tag: "group",
+    _name: string,
+}
 
 local GroupImpl = {}
 GroupImpl.__index = GroupImpl
 
-function GroupImpl.add (self: any, player: Player): boolean
+export type Group = typeof(setmetatable({} :: GroupFields, GroupImpl))
+
+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}"`)
+        error(`[Lync] Group has been destroyed: "{name}"`)
     end
 
     if set[player] then
@@ -58,11 +65,11 @@ function GroupImpl.add (self: any, player: Player): boolean
     return true
 end
 
-function GroupImpl.remove (self: any, player: Player): boolean
+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}"`)
+        error(`[Lync] Group has been destroyed: "{name}"`)
     end
 
     if not set[player] then
@@ -80,48 +87,48 @@ function GroupImpl.remove (self: any, player: Player): boolean
     return true
 end
 
-function GroupImpl.has (self: any, player: Player): boolean
+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}"`)
+        error(`[Lync] Group has been destroyed: "{name}"`)
     end
     return set[player] == true
 end
 
-function GroupImpl.count (self: any): number
+function GroupImpl.count(self: Group): number
     local name = self._name
     if not _groups[name] then
-        error (`[Lync] Group has been destroyed: "{name}"`)
+        error(`[Lync] Group has been destroyed: "{name}"`)
     end
     return _counts[name]
 end
 
-function GroupImpl.forEach (self: any, fn: (player: Player) -> ()): ()
+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}"`)
+        error(`[Lync] Group has been destroyed: "{name}"`)
     end
     for player in set do
-        fn (player)
+        fn(player)
     end
 end
 
-function GroupImpl.getSet (self: any): { [Player]: true }
+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}"`)
+        error(`[Lync] Group has been destroyed: "{name}"`)
     end
     return set
 end
 
-function GroupImpl.destroy (self: any): ()
+function GroupImpl.destroy(self: Group): ()
     local name = self._name
     local set = _groups[name]
     if not set then
-        error (`[Lync] Group has been destroyed: "{name}"`)
+        error(`[Lync] Group has been destroyed: "{name}"`)
     end
 
     for player in set do
@@ -135,23 +142,23 @@ function GroupImpl.destroy (self: any): ()
     _counts[name] = nil
 end
 
-table.freeze (GroupImpl)
+table.freeze(GroupImpl)
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
-local Group = {}
+local GroupModule = {}
 
-function Group.create (name: string): any
+function GroupModule.create(name: string): Group
     if _groups[name] then
-        error (`[Lync] Group already exists: "{name}"`)
+        error(`[Lync] Group already exists: "{name}"`)
     end
     _groups[name] = {}
     _counts[name] = 0
 
-    return setmetatable ({
-        _tag = "group",
+    return setmetatable({
+        _tag = "group" :: "group",
         _name = name,
     }, GroupImpl)
 end
 
-return table.freeze (Group)
+return table.freeze(GroupModule)

package/src/api/Namespace.luau

@@ -2,57 +2,66 @@
 --!optimize 2
 -- Scoped packet/query groups with batch ops and local middleware.
 
-local Middleware = require (script.Parent.Parent.internal.Middleware)
-local Packet = require (script.Parent.Packet)
-local Query = require (script.Parent.Query)
-local Types = require (script.Parent.Parent.Types)
+local Middleware = require(script.Parent.Parent.internal.Middleware)
+local Packet = require(script.Parent.Packet)
+local Query = require(script.Parent.Query)
+local Types = require(script.Parent.Parent.Types)
 
 type Connection = Types.Connection
 type PacketConfig<T> = Types.PacketConfig<T>
 type QueryConfig<R, S> = Types.QueryConfig<R, S>
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
 local MAX_NAMESPACES = 64
 
--- State --------------------------------------------------------------
+-- State ---------------------------------------------------------------
 
 local _registered = {} :: { [string]: true }
 local _count = 0
 
--- Private ------------------------------------------------------------
+-- Private -------------------------------------------------------------
 
-type NamespaceConfig = {
-    packets: { [string]: PacketConfig<any> }?,
-    queries: { [string]: QueryConfig<any, any> }?,
+type NamespaceConfig = Types.NamespaceConfig
+
+type NamespaceFields = {
+    _name: string,
+    _packets: { [string]: Packet.Packet },
+    _queries: { [string]: Query.Query },
+    _tracked: { Connection },
+    _removers: { () -> () },
+    packets: { [string]: Packet.Packet },
+    queries: { [string]: Query.Query },
 }
 
-local function prefixName (nsName: string, name: string): string
+local function prefixName(nsName: string, name: string): string
     return `{nsName}.{name}`
 end
 
 -- Wraps a middleware handler so it only fires for packets in this namespace.
-local function scopedHandler (
+local function scopedHandler(
     nsName: string,
     handler: (data: any, name: string, player: Player?) -> any?
 ): (data: any, name: string, player: Player?) -> any?
     local prefix = nsName .. "."
     local prefixLen = #prefix
 
-    return function (data: any, name: string, player: Player?): any?
-        if string.sub (name, 1, prefixLen) ~= prefix then
+    return function(data: any, name: string, player: Player?): any?
+        if string.sub(name, 1, prefixLen) ~= prefix then
             return data
         end
-        return handler (data, name, player)
+        return handler(data, name, player)
     end
 end
 
 local NamespaceImpl = {}
 NamespaceImpl.__index = NamespaceImpl
 
+export type Namespace = typeof(setmetatable({} :: NamespaceFields, NamespaceImpl))
+
 -- Listens on every packet in this namespace. Returns a Connection.
-function NamespaceImpl.listenAll (
-    self: any,
+function NamespaceImpl.listenAll(
+    self: Namespace,
     callback: (name: string, data: any, sender: Player?) -> ()
 ): Connection
     local connections = {} :: { Connection }
@@ -60,174 +69,183 @@ function NamespaceImpl.listenAll (
     local prefixLen = #prefix
 
     for fullName, packet in self._packets do
-        local shortName = string.sub (fullName, prefixLen + 1)
-        local conn = packet:listen (function (data: any, sender: Player?): ()
-            callback (shortName, data, sender)
+        local shortName = string.sub(fullName, prefixLen + 1)
+        local conn = packet:listen(function(data: any, sender: Player?): ()
+            callback(shortName, data, sender)
         end)
-        table.insert (connections, conn)
-        table.insert (self._tracked, conn)
+        table.insert(connections, conn)
+        table.insert(self._tracked, conn)
     end
 
-    local bundle = {
+    local bundle: Connection
+    bundle = {
         connected = true,
-        disconnect = function (conn: Connection): ()
-            if not conn.connected then
+        disconnect = function(self: Connection): ()
+            if not self.connected then
                 return
             end
-            conn.connected = false
+            self.connected = false
 
             for _, inner in connections do
                 if inner.connected then
-                    inner:disconnect ()
+                    inner:disconnect()
                 end
             end
         end,
     }
 
-    return bundle :: any
+    return bundle
 end
 
 -- Disconnects every listenAll connection. Does not remove scoped middleware.
-function NamespaceImpl.disconnectAll (self: any): ()
+function NamespaceImpl.disconnectAll(self: Namespace): ()
     for _, conn in self._tracked do
         if conn.connected then
-            conn:disconnect ()
+            conn:disconnect()
         end
     end
-    table.clear (self._tracked)
+    table.clear(self._tracked)
 end
 
 -- Registers send middleware scoped to this namespace. Returns a remover.
-function NamespaceImpl.onSend (
-    self: any,
+function NamespaceImpl.onSend(
+    self: Namespace,
     handler: (data: any, name: string, player: Player?) -> any?
 ): () -> ()
-    local wrapped = scopedHandler (self._name, handler)
-    local remover = Middleware.addSend (wrapped)
-    table.insert (self._removers, remover)
+    local wrapped = scopedHandler(self._name, handler)
+    local remover = Middleware.addSend(wrapped)
+    table.insert(self._removers, remover)
 
-    return function (): ()
-        remover ()
-        local idx = table.find (self._removers, remover)
+    return function(): ()
+        remover()
+        local idx = table.find(self._removers, remover)
         if idx then
-            table.remove (self._removers, idx)
+            table.remove(self._removers, idx)
         end
     end
 end
 
 -- Registers receive middleware scoped to this namespace. Returns a remover.
-function NamespaceImpl.onReceive (
-    self: any,
+function NamespaceImpl.onReceive(
+    self: Namespace,
     handler: (data: any, name: string, player: Player?) -> any?
 ): () -> ()
-    local wrapped = scopedHandler (self._name, handler)
-    local remover = Middleware.addReceive (wrapped)
-    table.insert (self._removers, remover)
+    local wrapped = scopedHandler(self._name, handler)
+    local remover = Middleware.addReceive(wrapped)
+    table.insert(self._removers, remover)
 
-    return function (): ()
-        remover ()
-        local idx = table.find (self._removers, remover)
+    return function(): ()
+        remover()
+        local idx = table.find(self._removers, remover)
         if idx then
-            table.remove (self._removers, idx)
+            table.remove(self._removers, idx)
         end
     end
 end
 
 -- Kills all listeners and removes all scoped middleware. Full cleanup.
-function NamespaceImpl.destroy (self: any): ()
-    self:disconnectAll ()
+function NamespaceImpl.destroy(self: Namespace): ()
+    self:disconnectAll()
 
     for _, remover in self._removers do
-        remover ()
+        remover()
     end
-    table.clear (self._removers)
+    table.clear(self._removers)
 end
 
--- Returns every packet name (without prefix) in this namespace.
-function NamespaceImpl.packetNames (self: any): { string }
+-- Returns every packet name(without prefix) in this namespace.
+function NamespaceImpl.packetNames(self: Namespace): { string }
     local result = {} :: { string }
     local prefix = self._name .. "."
     local prefixLen = #prefix
 
     for fullName in self._packets do
-        table.insert (result, string.sub (fullName, prefixLen + 1))
+        table.insert(result, string.sub(fullName, prefixLen + 1))
     end
 
-    table.sort (result)
+    table.sort(result)
     return result
 end
 
--- Returns every query name (without prefix) in this namespace.
-function NamespaceImpl.queryNames (self: any): { string }
+-- Returns every query name(without prefix) in this namespace.
+function NamespaceImpl.queryNames(self: Namespace): { string }
     local result = {} :: { string }
     local prefix = self._name .. "."
     local prefixLen = #prefix
 
     for fullName in self._queries do
-        table.insert (result, string.sub (fullName, prefixLen + 1))
+        table.insert(result, string.sub(fullName, prefixLen + 1))
     end
 
-    table.sort (result)
+    table.sort(result)
     return result
 end
 
-table.freeze (NamespaceImpl)
+table.freeze(NamespaceImpl)
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
-local Namespace = {}
+local NamespaceModule = {}
 
 -- Defines a namespace. Names are auto-prefixed to prevent collisions.
-function Namespace.define (name: string, config: NamespaceConfig): any
+function NamespaceModule.define(name: string, config: NamespaceConfig): Namespace
     if #name == 0 then
-        error ("[Lync] Namespace name must not be empty")
+        error("[Lync] Namespace name must not be empty")
     end
     if _registered[name] then
-        error (`[Lync] Duplicate namespace: "{name}"`)
+        error(`[Lync] Duplicate namespace: "{name}"`)
     end
     if _count >= MAX_NAMESPACES then
-        error (`[Lync] Namespace limit reached: {MAX_NAMESPACES}`)
+        error(`[Lync] Namespace limit reached: {MAX_NAMESPACES}`)
     end
 
     _count += 1
     _registered[name] = true
 
-    local packets = {} :: { [string]: any }
-    local queries = {} :: { [string]: any }
-    local packetsByShort = {} :: { [string]: any }
-    local queriesByShort = {} :: { [string]: any }
-    local fields = {} :: { [string]: any }
-
-    fields._name = name
-    fields._packets = packets
-    fields._queries = queries
-    fields._tracked = {} :: { Connection }
-    fields._removers = {} :: { () -> () }
+    local packets = {} :: { [string]: Packet.Packet }
+    local queries = {} :: { [string]: Query.Query }
+    local packetsByShort = {} :: { [string]: Packet.Packet }
+    local queriesByShort = {} :: { [string]: Query.Query }
 
     if config.packets then
         for shortName, packetConfig in config.packets do
-            local fullName = prefixName (name, shortName)
-            local packet = Packet.define (fullName, packetConfig)
+            local fullName = prefixName(name, shortName)
+            local packet = Packet.define(fullName, packetConfig)
             packets[fullName] = packet
             packetsByShort[shortName] = packet
-            fields[shortName] = packet
         end
     end
 
     if config.queries then
         for shortName, queryConfig in config.queries do
-            local fullName = prefixName (name, shortName)
-            local query = Query.define (fullName, queryConfig)
+            local fullName = prefixName(name, shortName)
+            local query = Query.define(fullName, queryConfig)
             queries[fullName] = query
             queriesByShort[shortName] = query
-            fields[shortName] = query
         end
     end
 
-    fields.packets = table.freeze (packetsByShort)
-    fields.queries = table.freeze (queriesByShort)
+    local nsFields: NamespaceFields = {
+        _name = name,
+        _packets = packets,
+        _queries = queries,
+        _tracked = {} :: { Connection },
+        _removers = {} :: { () -> () },
+        packets = table.freeze(packetsByShort),
+        queries = table.freeze(queriesByShort),
+    }
+
+    -- Inject dynamic short-name accessors (ns.Hit, ns.Stats, etc.)
+    -- These bypass the typed fields; consumers should prefer ns.packets.X / ns.queries.X.
+    local raw = nsFields :: any
+    for shortName, packet in packetsByShort do
+        raw[shortName] = packet
+    end
+    for shortName, query in queriesByShort do
+        raw[shortName] = query
+    end
 
-    return setmetatable (fields, NamespaceImpl)
+    return setmetatable(nsFields, NamespaceImpl)
 end
 
-return table.freeze (Namespace)
+return table.freeze(NamespaceModule)