@axpecter/lync 1.3.1 → 1.4.1

package/src/init.luau

@@ -7,22 +7,22 @@ local RunService = game:GetService ("RunService")
 -- Codec: primitive
 local BoolCodec = require (script.codec.primitive.Bool)
 local Float16 = require (script.codec.primitive.Float16)
-local Number = require (script.codec.primitive.Number)
+local NumberCodec = require (script.codec.primitive.Number)
 
 -- Codec: datatype
-local Buffer = require (script.codec.datatype.Buffer)
+local BufferCodec = require (script.codec.datatype.Buffer)
 local CFrameCodec = require (script.codec.datatype.CFrame)
-local Color = require (script.codec.datatype.Color)
+local ColorCodec = require (script.codec.datatype.Color)
 local InstanceCodec = require (script.codec.datatype.Instance)
-local IntVector = require (script.codec.datatype.IntVector)
+local IntVectorCodec = require (script.codec.datatype.IntVector)
 local NumberRangeCodec = require (script.codec.datatype.NumberRange)
 local RayCodec = require (script.codec.datatype.Ray)
 local RectCodec = require (script.codec.datatype.Rect)
-local Region = require (script.codec.datatype.Region)
-local Sequence = require (script.codec.datatype.Sequence)
-local String = require (script.codec.datatype.String)
+local RegionCodec = require (script.codec.datatype.Region)
+local SequenceCodec = require (script.codec.datatype.Sequence)
+local StringCodec = require (script.codec.datatype.String)
 local UDimCodec = require (script.codec.datatype.UDim)
-local Vector = require (script.codec.datatype.Vector)
+local VectorCodec = require (script.codec.datatype.Vector)
 
 -- Codec: composite
 local Array = require (script.codec.composite.Array)
@@ -43,21 +43,35 @@ local Unknown = require (script.codec.meta.Unknown)
 
 -- Internal
 local Channel = require (script.internal.Channel)
-local Gate = require (script.transport.Gate)
 local Middleware = require (script.internal.Middleware)
 local Pool = require (script.internal.Pool)
 
+-- Transport
+local Client = require (script.transport.Client)
+local Gate = require (script.transport.Gate)
+local Server = require (script.transport.Server)
+
 -- API
 local Group = require (script.api.Group)
 local Namespace = require (script.api.Namespace)
 local Packet = require (script.api.Packet)
 local Query = require (script.api.Query)
+local Scope = require (script.api.Scope)
 
--- Transport
-local Client = require (script.transport.Client)
-local Server = require (script.transport.Server)
+-- Constants ----------------------------------------------------------
 
--- Public -----------------------------------------------------------------
+local ALL = table.freeze ({ _tag = "all" })
+
+-- Private ------------------------------------------------------------
+
+local function except (...: any): any
+    local count = select ("#", ...)
+    local set = {} :: { [Player]: true }
+    for i = 1, count do
+        set[select (i, ...)] = true
+    end
+    return { _tag = "except", _set = set }
+end
 
 local function start (): ()
     if RunService:IsServer () then
@@ -67,9 +81,10 @@ local function start (): ()
     end
 end
 
+-- Public -------------------------------------------------------------
+
 local Lync = {
-    VERSION = "1.3.1",
-    version = "1.3.1",
+    VERSION = "1.4.1",
 
     -- Lifecycle
     start = start,
@@ -80,37 +95,37 @@ local Lync = {
     defineNamespace = Namespace.define,
 
     -- Primitives
-    u8 = Number.u8,
-    u16 = Number.u16,
-    u32 = Number.u32,
-    i8 = Number.i8,
-    i16 = Number.i16,
-    i32 = Number.i32,
-    f32 = Number.f32,
-    f64 = Number.f64,
+    u8 = NumberCodec.u8,
+    u16 = NumberCodec.u16,
+    u32 = NumberCodec.u32,
+    i8 = NumberCodec.i8,
+    i16 = NumberCodec.i16,
+    i32 = NumberCodec.i32,
+    f32 = NumberCodec.f32,
+    f64 = NumberCodec.f64,
     bool = BoolCodec.bool,
     f16 = Float16.f16,
 
     -- Datatypes
-    string = String.string,
-    boundedString = String.bounded,
-    vec2 = Vector.vec2,
-    vec3 = Vector.vec3,
+    string = StringCodec.string,
+    boundedString = StringCodec.bounded,
+    vec2 = VectorCodec.vec2,
+    vec3 = VectorCodec.vec3,
     cframe = CFrameCodec.cframe,
-    color3 = Color.color3,
+    color3 = ColorCodec.color3,
     inst = InstanceCodec.inst,
-    buff = Buffer.buff,
+    buff = BufferCodec.buff,
     udim = UDimCodec.udim,
     udim2 = UDimCodec.udim2,
     numberRange = NumberRangeCodec.numberRange,
     rect = RectCodec.rect,
-    vec2int16 = IntVector.vec2int16,
-    vec3int16 = IntVector.vec3int16,
-    region3 = Region.region3,
-    region3int16 = Region.region3int16,
+    vec2int16 = IntVectorCodec.vec2int16,
+    vec3int16 = IntVectorCodec.vec3int16,
+    region3 = RegionCodec.region3,
+    region3int16 = RegionCodec.region3int16,
     ray = RayCodec.ray,
-    numberSequence = Sequence.numberSequence,
-    colorSequence = Sequence.colorSequence,
+    numberSequence = SequenceCodec.numberSequence,
+    colorSequence = SequenceCodec.colorSequence,
 
     -- Composites
     struct = Struct.struct,
@@ -139,15 +154,18 @@ local Lync = {
     onSend = Middleware.addSend,
     onReceive = Middleware.addReceive,
 
+    -- Target descriptors
+    all = ALL,
+    except = except,
+
+    -- Middleware sentinel
+    DROP = Middleware.DROP,
+
     -- Groups
     createGroup = Group.create,
-    destroyGroup = Group.destroy,
-    addToGroup = Group.add,
-    removeFromGroup = Group.remove,
-    hasInGroup = Group.has,
-    getGroupSet = Group.getSet,
-    groupCount = Group.count,
-    forEachInGroup = Group.forEach,
+
+    -- Scope
+    scope = Scope.create,
 
     -- Configuration (call before start)
     setChannelMaxSize = Channel.setMaxSize,

package/src/internal/Baseline.luau

@@ -2,15 +2,18 @@
 --!optimize 2
 -- Read-side baseline cache keyed by source (player or client sentinel).
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _readKey = false :: any
 local _readCaches = {} :: { [any]: { [number]: any } }
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Baseline = {}
 
+-- One-way latch: set to true on first delta write, never reset. This
+-- avoids a setReadKey call on every non-delta frame at the cost of a
+-- cheap branch once deltas are first used in the session.
 Baseline.hasDelta = false
 
 function Baseline.setReadKey (key: any): ()
@@ -38,4 +41,5 @@ function Baseline.clearSource (key: any): ()
     _readCaches[key] = nil
 end
 
+-- Not frozen: hasDelta is mutated at runtime by setCache.
 return Baseline

package/src/internal/Channel.luau

@@ -6,7 +6,7 @@ local Types = require (script.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local INITIAL_SIZE = 1024
 local MAX_SIZE = 262144
@@ -18,12 +18,15 @@ local band32 = bit32.band
 local countlz = bit32.countlz
 local lshift = bit32.lshift
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _maxSize = MAX_SIZE
+
+-- Packet name for overflow diagnostics. Not coroutine-safe: concurrent
+-- serializers may overwrite before the error fires.
 local _currentPacket = ""
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Channel = {}
 
@@ -163,9 +166,11 @@ local function sealOpen (ch: ChannelState): ()
     end
 end
 
--- Writes a query frame. Seals any open batch, then writes:
---     id (u8) + correlationId (u16) + status (u8)
--- Status 0 = payload follows. Status 1 = nil response.
+--[[
+    Writes a query frame. Seals any open batch, then writes:
+        id (u8) + correlationId (u16) + status (u8)
+    Status 0 = payload follows. Status 1 = nil response.
+]]
 function Channel.writeQuery (
     ch: ChannelState,
     id: number,

package/src/internal/Middleware.luau

@@ -2,8 +2,6 @@
 --!optimize 2
 -- Ordered intercept chains for send and receive.
 
--- State ------------------------------------------------------------------
-
 type Handler = (data: any, name: string, player: Player?) -> any?
 
 type Chain = {
@@ -11,16 +9,22 @@ type Chain = {
     snapshot: { Handler }?,
 }
 
+-- Constants ----------------------------------------------------------
+
+local DROP = table.freeze ({ _tag = "drop" })
+
+-- State --------------------------------------------------------------
+
 local _send: Chain = { handlers = {}, snapshot = nil }
 local _receive: Chain = { handlers = {}, snapshot = nil }
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function runChain (chain: { Handler }, data: any, name: string, player: Player?): any?
     local current = data
     for i = 1, #chain do
         local result = chain[i] (current, name, player)
-        if result == nil then
+        if result == nil or result == DROP then
             return nil
         end
         current = result
@@ -55,6 +59,10 @@ local function run (chain: Chain, data: any, name: string, player: Player?): any
         return nil
     end
 
+    if result == DROP then
+        return nil
+    end
+
     return result
 end
 
@@ -71,10 +79,14 @@ local function addTo (chain: Chain, fn: Handler): () -> ()
     end
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Middleware = {}
 
+Middleware.hasSend = false
+Middleware.hasReceive = false
+Middleware.DROP = DROP
+
 function Middleware.addSend (fn: Handler): () -> ()
     local remover = addTo (_send, fn)
     Middleware.hasSend = true
@@ -103,7 +115,5 @@ function Middleware.runReceive (data: any, name: string, player: Player?): any?
     return run (_receive, data, name, player)
 end
 
-Middleware.hasSend = false
-Middleware.hasReceive = false
-
+-- Not frozen: hasSend and hasReceive are mutated at runtime.
 return Middleware

package/src/internal/Pool.luau

@@ -7,24 +7,24 @@ local Types = require (script.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local DEFAULT_MAX = 16
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _stack = {} :: { ChannelState }
 local _depth = 0
 local _maxSize = DEFAULT_MAX
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Pool = {}
 
--- Override the max idle ChannelStates in the pool. Default 16. Range: 2–128.
+-- Override the max idle ChannelStates in the pool. Default 16. Range: 2-128.
 function Pool.setMaxSize (count: number): ()
     if count < 2 or count > 128 then
-        error (`[Lync] Pool max size must be 2–128, got {count}`)
+        error (`[Lync] Pool max size must be 2-128, got {count}`)
     end
     _maxSize = count
 end

package/src/internal/Registry.luau

@@ -8,20 +8,20 @@ type Codec<T> = Types.Codec<T>
 type Registration = Types.Registration
 type RateLimitConfig = Types.RateLimitConfig
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local KIND_PACKET = 0
 local KIND_REQUEST = 1
 local KIND_RESPONSE = 2
 local MAX_PACKETS = 255
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _entries = {} :: { Registration }
 local _names = {} :: { [string]: number }
 local _nextId = 1
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function assign (
     name: string,
@@ -77,7 +77,7 @@ local function assign (
     return reg
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Registry = {
     KIND_PACKET = KIND_PACKET,

package/src/transport/Bridge.luau

@@ -5,19 +5,19 @@
 local ReplicatedStorage = game:GetService ("ReplicatedStorage")
 local RunService = game:GetService ("RunService")
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local FOLDER = "_lync"
 local RELIABLE = "R"
 local UNRELIABLE = "U"
 local TIMEOUT = 10
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _reliable: RemoteEvent
 local _unreliable: UnreliableRemoteEvent
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Bridge = {}
 
@@ -63,4 +63,5 @@ function Bridge.setup (): ()
     table.freeze (Bridge)
 end
 
+-- Not frozen at module level: setup() populates reliable/unreliable then freezes.
 return Bridge

package/src/transport/Client.luau

@@ -13,15 +13,16 @@ local Types = require (script.Parent.Parent.Types)
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local NOT_STARTED = "[Lync] Client not started. Call Lync.start() before sending"
+
 local _reliable = nil :: ChannelState?
 local _unreliable = nil :: ChannelState?
 local _prevRecv = nil :: buffer?
 local _isStarted = false
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function receive (data: any, refs: any, applyXor: boolean): ()
     local buf = Reader.decodeIncoming (data)
@@ -67,7 +68,7 @@ local function flush (): ()
     flushChannel (Bridge.unreliable, _unreliable :: ChannelState, false)
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Client = {}
 

package/src/transport/Gate.luau

@@ -7,7 +7,7 @@ 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,7 +27,7 @@ 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?): ()
     for _, handler in _dropHandlers do
@@ -47,7 +47,7 @@ local function isClean (value: any, depth: number): boolean
         return isfinite (value)
     end
 
-    -- String, boolean, nil are always clean . Exit before table/vector/userdata checks
+    -- String, boolean, nil are always clean. Exit before table/vector/userdata checks.
     if t == "string" or t == "boolean" or t == "nil" then
         return true
     end
@@ -152,7 +152,7 @@ local function checkRate (player: Player, reg: Registration): boolean
     return false
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Gate = {}
 

package/src/transport/Reader.luau

@@ -11,14 +11,14 @@ 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 = {}
 
@@ -126,7 +126,7 @@ function Reader.process (
             end
         else
             -- Query frame: id(u8, already read) + correlationId(u16) + status(u8) = 3 more bytes
-            if pos + 2 >= length then
+            if pos + 3 > length then
                 break
             end
 

package/src/transport/Server.luau

@@ -8,13 +8,7 @@ local RunService = game:GetService ("RunService")
 local Baseline = require (script.Parent.Parent.internal.Baseline)
 local Bridge = require (script.Parent.Bridge)
 local Channel = require (script.Parent.Parent.internal.Channel)
-
-local channelWriteBatch = Channel.writeBatch
-local channelWriteBatchRaw = Channel.writeBatchRaw
-local channelSetPacket = Channel.setCurrentPacket
-
 local Gate = require (script.Parent.Gate)
-local Group = require (script.Parent.Parent.api.Group)
 local Middleware = require (script.Parent.Parent.internal.Middleware)
 local Pool = require (script.Parent.Parent.internal.Pool)
 local Reader = require (script.Parent.Reader)
@@ -23,7 +17,11 @@ local Types = require (script.Parent.Parent.Types)
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- State ------------------------------------------------------------------
+local channelWriteBatch = Channel.writeBatch
+local channelWriteBatchRaw = Channel.writeBatchRaw
+local channelSetPacket = Channel.setCurrentPacket
+
+-- State --------------------------------------------------------------
 
 type PlayerState = {
     reliable: ChannelState,
@@ -35,7 +33,7 @@ local _prevRecv = {} :: { [Player]: buffer }
 local _isStarted = false
 local _broadScratch = Channel.create ()
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function onPlayerAdded (player: Player): ()
     _players[player] = {
@@ -161,7 +159,7 @@ local function broadcastToAll (
     codec: Codec<any>,
     data: any,
     isUnreliable: boolean,
-    except: Player?
+    exceptSet: { [Player]: true }?
 ): ()
     local final, snapLen, snapRefs = prepareBroadcast (name, codec, data)
     if final == nil and data ~= nil then
@@ -170,7 +168,7 @@ local function broadcastToAll (
 
     local scratchBuff = _broadScratch.buff
     for player, state in _players do
-        if except and player == except then
+        if exceptSet and exceptSet[player] then
             continue
         end
         local ch = if isUnreliable then state.unreliable else state.reliable
@@ -228,7 +226,7 @@ local function broadcastToSet (
     end
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Server = {}
 
@@ -304,25 +302,25 @@ function Server.writeToList (
 end
 
 function Server.writeToAllExcept (
-    except: Player,
+    exceptSet: { [Player]: true },
     id: number,
     name: string,
     codec: Codec<any>,
     data: any,
     isUnreliable: boolean
 ): ()
-    broadcastToAll (id, name, codec, data, isUnreliable, except)
+    broadcastToAll (id, name, codec, data, isUnreliable, exceptSet)
 end
 
-function Server.writeToGroup (
-    groupName: string,
+function Server.writeToSet (
+    set: { [Player]: true },
     id: number,
     name: string,
     codec: Codec<any>,
     data: any,
     isUnreliable: boolean
 ): ()
-    broadcastToSet (Group.getSet (groupName), id, name, codec, data, isUnreliable)
+    broadcastToSet (set, id, name, codec, data, isUnreliable)
 end
 
 -- Shared for both query requests and responses (identical wire format).