@axpecter/lync 2.1.1 → 2.2.0

package/src/internal/Registry.luau

@@ -5,28 +5,29 @@
 local Signal = require(script.Parent.Parent.api.Signal)
 local Types = require(script.Parent.Parent.Types)
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local KIND_PACKET = 0
 local KIND_REQUEST = 1
 local KIND_RESPONSE = 2
 local MAX_ID = 127
 
--- State ---------------------------------------------------------------
+-- State ------------------------------------------------------------------
 
 local _nextId = 0
 local _byId: { [number]: Types.Registration } = {}
 local _byName: { [string]: Types.Registration } = {}
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Registry = {}
 
 Registry.KIND_PACKET = KIND_PACKET
 Registry.KIND_REQUEST = KIND_REQUEST
 Registry.KIND_RESPONSE = KIND_RESPONSE
+Registry.MAX_ID = MAX_ID
 
-function Registry.register(
+export type RegisterOptions = {
     name: string,
     kind: number,
     codec: Types.InternalCodec<any>,
@@ -37,35 +38,36 @@ function Registry.register(
     timestampMode: number,
     openFn: (ch: Types.ChannelState, id: number) -> (),
     rateLimit: Types.RateLimitConfig?,
-    validate: ((data: any, player: Player) -> (boolean, string?))?,
-    maxPayloadBytes: number?
-): Types.Registration
-    _nextId += 1
-    local id = _nextId
-
-    if id > MAX_ID then
-        error(`[Lync] Registry: ID limit exceeded ({MAX_ID}), too many packets/queries`)
+    validate: Types.ValidateFn?,
+    maxPayloadBytes: number?,
+}
+
+function Registry.register(opts: RegisterOptions): Types.Registration
+    local nextCandidate = _nextId + 1
+    if nextCandidate > MAX_ID then
+        error(`[Lync] Registry.register: ID limit exceeded ({MAX_ID})`)
     end
-
-    if _byName[name] and kind ~= KIND_RESPONSE then
-        error(`[Lync] Registry: duplicate name "{name}"`)
+    if opts.kind ~= KIND_RESPONSE and _byName[opts.name] then
+        error(`[Lync] Registry.register: duplicate name "{opts.name}"`)
     end
 
+    _nextId = nextCandidate
+
     local reg: Types.Registration = {
-        id = id,
-        name = name,
-        kind = kind,
-        codec = codec,
-        isUnreliable = isUnreliable,
-        partner = partner,
+        id = nextCandidate,
+        name = opts.name,
+        kind = opts.kind,
+        codec = opts.codec,
+        isUnreliable = opts.isUnreliable,
+        partner = opts.partner,
         signal = Signal.create(),
-        rateLimit = rateLimit,
-        validate = validate,
-        needsGate = needsGate,
-        maxPayloadBytes = maxPayloadBytes,
-        timestampMode = timestampMode,
-        headerSize = headerSize,
-        _openFn = openFn,
+        rateLimit = opts.rateLimit,
+        validate = opts.validate,
+        needsGate = opts.needsGate,
+        maxPayloadBytes = opts.maxPayloadBytes,
+        timestampMode = opts.timestampMode,
+        headerSize = opts.headerSize,
+        _openFn = opts.openFn,
         bytesSent = 0,
         bytesReceived = 0,
         fires = 0,
@@ -73,11 +75,10 @@ function Registry.register(
         drops = 0,
     }
 
-    _byId[id] = reg
-    if kind ~= KIND_RESPONSE then
-        _byName[name] = reg
+    _byId[nextCandidate] = reg
+    if opts.kind ~= KIND_RESPONSE then
+        _byName[opts.name] = reg
     end
-
     return reg
 end
 
@@ -95,9 +96,12 @@ end
 
 function Registry.all(): { Types.Registration }
     local result = table.create(_nextId)
+    local n = 0
     for i = 1, _nextId do
-        if _byId[i] then
-            table.insert(result, _byId[i])
+        local reg = _byId[i]
+        if reg then
+            n += 1
+            result[n] = reg
         end
     end
     return result

package/src/internal/Transport.luau

@@ -0,0 +1,28 @@
+--!strict
+--!optimize 2
+-- Lazy-require Server/Client to break the api -> transport import cycle.
+
+-- State ------------------------------------------------------------------
+
+local _server: any = nil
+local _client: any = nil
+
+-- Public -----------------------------------------------------------------
+
+local Transport = {}
+
+function Transport.server(): any
+    if not _server then
+        _server = require(script.Parent.Parent.transport.Server)
+    end
+    return _server
+end
+
+function Transport.client(): any
+    if not _client then
+        _client = require(script.Parent.Parent.transport.Client)
+    end
+    return _client
+end
+
+return table.freeze(Transport)

package/src/internal/Util.luau

@@ -0,0 +1,26 @@
+--!strict
+--!optimize 2
+-- Cross-module utility helpers.
+
+-- Public -----------------------------------------------------------------
+
+local Util = {}
+
+function Util.isPlayer(value: any): boolean
+    return typeof(value) == "Instance" and (value :: Instance):IsA("Player")
+end
+
+--[[
+    O(1) array remove via swap with last element. The slot becomes nil
+    after this returns; callers that track an external count must
+    decrement it themselves.
+]]
+function Util.swapRemove<T>(arr: { T }, idx: number): ()
+    local last = #arr
+    if idx ~= last then
+        arr[idx] = arr[last]
+    end
+    arr[last] = nil
+end
+
+return table.freeze(Util)

package/src/transport/Bridge.luau

@@ -1,21 +1,39 @@
 --!strict
 --!optimize 2
--- Remote instance creation and access.
+-- RemoteEvent / UnreliableRemoteEvent thin wrapper.
 
 local RunService = game:GetService("RunService")
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local RELIABLE_NAME = "LyncReliable"
 local UNRELIABLE_NAME = "LyncUnreliable"
 
--- State ---------------------------------------------------------------
+-- State ------------------------------------------------------------------
 
 local _reliable: RemoteEvent? = nil
 local _unreliable: UnreliableRemoteEvent? = nil
 local _isServer = RunService:IsServer()
 
--- Public --------------------------------------------------------------
+-- Private ----------------------------------------------------------------
+
+local function ensureReliable(): RemoteEvent
+    local re = _reliable
+    if not re then
+        error("[Lync] Bridge.reliable: not set up; call Lync.start() first")
+    end
+    return re
+end
+
+local function ensureUnreliable(): UnreliableRemoteEvent
+    local ure = _unreliable
+    if not ure then
+        error("[Lync] Bridge.unreliable: not set up; call Lync.start() first")
+    end
+    return ure
+end
+
+-- Public -----------------------------------------------------------------
 
 local Bridge = {}
 
@@ -29,28 +47,18 @@ function Bridge.setup(container: Instance): ()
         ure.Name = UNRELIABLE_NAME
         ure.Parent = container
 
-        _reliable = re
-        _unreliable = ure
-    else
-        _reliable = container:WaitForChild(RELIABLE_NAME) :: RemoteEvent
-        _unreliable = container:WaitForChild(UNRELIABLE_NAME) :: UnreliableRemoteEvent
+        _reliable, _unreliable = re, ure
+        return
     end
+    _reliable = container:WaitForChild(RELIABLE_NAME) :: RemoteEvent
+    _unreliable = container:WaitForChild(UNRELIABLE_NAME) :: UnreliableRemoteEvent
 end
 
-function Bridge.reliable(): RemoteEvent
-    return _reliable :: RemoteEvent
-end
-
-function Bridge.unreliable(): UnreliableRemoteEvent
-    return _unreliable :: UnreliableRemoteEvent
-end
-
-function Bridge.isServer(): boolean
-    return _isServer
-end
+Bridge.reliable = ensureReliable
+Bridge.unreliable = ensureUnreliable
 
 function Bridge.fireServer(data: buffer, refs: { Instance }): ()
-    local re = _reliable :: RemoteEvent
+    local re = ensureReliable()
     if #refs > 0 then
         re:FireServer(data, refs)
     else
@@ -59,7 +67,7 @@ function Bridge.fireServer(data: buffer, refs: { Instance }): ()
 end
 
 function Bridge.fireClient(player: Player, data: buffer, refs: { Instance }): ()
-    local re = _reliable :: RemoteEvent
+    local re = ensureReliable()
     if #refs > 0 then
         re:FireClient(player, data, refs)
     else
@@ -68,7 +76,7 @@ function Bridge.fireClient(player: Player, data: buffer, refs: { Instance }): ()
 end
 
 function Bridge.fireServerUnreliable(data: buffer, refs: { Instance }): ()
-    local ure = _unreliable :: UnreliableRemoteEvent
+    local ure = ensureUnreliable()
     if #refs > 0 then
         ure:FireServer(data, refs)
     else
@@ -77,7 +85,7 @@ function Bridge.fireServerUnreliable(data: buffer, refs: { Instance }): ()
 end
 
 function Bridge.fireClientUnreliable(player: Player, data: buffer, refs: { Instance }): ()
-    local ure = _unreliable :: UnreliableRemoteEvent
+    local ure = ensureUnreliable()
     if #refs > 0 then
         ure:FireClient(player, data, refs)
     else

package/src/transport/Client.luau

@@ -1,20 +1,59 @@
 --!strict
 --!optimize 2
--- Client-side transport: single channel pair, flush.
+-- Client-side transport: single channel pair, flush, with outbound XOR delta.
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
 
 local Bridge = require(script.Parent.Parent.transport.Bridge)
 local Channel = require(script.Parent.Parent.internal.Channel)
 local Reader = require(script.Parent.Parent.transport.Reader)
 local Types = require(script.Parent.Parent.Types)
 
--- State ---------------------------------------------------------------
+-- Constants --------------------------------------------------------------
+
+local CONTAINER_NAME = "LyncRemotes"
+
+-- State ------------------------------------------------------------------
 
 local _reliable: Types.ChannelState = Channel.create()
 local _unreliable: Types.ChannelState = Channel.create()
 local _prevIncoming: buffer? = nil
 local _prevIncomingLen = 0
 
--- Public --------------------------------------------------------------
+-- Private ----------------------------------------------------------------
+
+local function handleIncomingReliable(data: any, refs: any?): ()
+    local incoming = Reader.decodeIncoming(data)
+    if not incoming then
+        return
+    end
+
+    local incomingLen = buffer.len(incoming)
+    local decoded = if _prevIncoming
+        then Channel.xorApply(incoming, incomingLen, _prevIncoming, _prevIncomingLen)
+        else incoming
+    _prevIncoming = decoded
+    _prevIncomingLen = incomingLen
+
+    local ok, err = pcall(Reader.process, decoded, incomingLen, refs, nil, false)
+    if not ok then
+        warn(`[Lync] Client.receive: {err}`)
+    end
+end
+
+local function handleIncomingUnreliable(data: any, refs: any?): ()
+    local incoming = Reader.decodeIncoming(data)
+    if not incoming then
+        return
+    end
+
+    local ok, err = pcall(Reader.process, incoming, buffer.len(incoming), refs, nil, false)
+    if not ok then
+        warn(`[Lync] Client.receiveUnreliable: {err}`)
+    end
+end
+
+-- Public -----------------------------------------------------------------
 
 local Client = {}
 
@@ -27,69 +66,28 @@ function Client.flush(): ()
         Channel.updateTimestamp()
     end
 
-    -- Reliable
     if _reliable.cursor > 0 then
-        local snapshot, refs, byteLen, _ = Channel.sealAndDump(_reliable)
-        Bridge.fireServer(snapshot, refs)
+        local snapshot, refs, byteLen = Channel.sealAndDump(_reliable)
+        local xored = Channel.xorApply(snapshot, byteLen, _reliable.prevDump, _reliable.prevDumpLen)
+        _reliable.prevDump = snapshot
+        _reliable.prevDumpLen = byteLen
+        Bridge.fireServer(xored, refs)
         Channel.reset(_reliable)
     end
 
-    -- Unreliable
     if _unreliable.cursor > 0 then
-        local snapshot, refs, byteLen, _ = Channel.sealAndDump(_unreliable)
+        local snapshot, refs = Channel.sealAndDump(_unreliable)
         Bridge.fireServerUnreliable(snapshot, refs)
         Channel.reset(_unreliable)
     end
 end
 
 function Client.start(): ()
-    local container = game:GetService("ReplicatedStorage"):WaitForChild("LyncRemotes")
+    local container = ReplicatedStorage:WaitForChild(CONTAINER_NAME)
     Bridge.setup(container)
 
-    local reliable = Bridge.reliable()
-    local unreliable = Bridge.unreliable()
-
-    -- Incoming reliable (XOR encoded)
-    reliable.OnClientEvent:Connect(function(data: any, refs: any?)
-        local incoming = Reader.decodeIncoming(data)
-        if not incoming then
-            return
-        end
-
-        local incomingLen = buffer.len(incoming)
-
-        -- XOR decode against previous frame
-        local decoded: buffer
-        if _prevIncoming then
-            decoded = Channel.xorApply(incoming, incomingLen, _prevIncoming, _prevIncomingLen)
-        else
-            decoded = incoming
-        end
-
-        -- Store decoded (not XOR'd) for next frame's XOR base
-        _prevIncoming = decoded
-        _prevIncomingLen = incomingLen
-
-        local ok, err = pcall(Reader.process, decoded, incomingLen, refs :: any, nil, false)
-        if not ok then
-            warn(`[Lync] Client: read error: {err}`)
-        end
-    end)
-
-    -- Incoming unreliable (no XOR)
-    unreliable.OnClientEvent:Connect(function(data: any, refs: any?)
-        local incoming = Reader.decodeIncoming(data)
-        if not incoming then
-            return
-        end
-
-        local incomingLen = buffer.len(incoming)
-
-        local ok, err = pcall(Reader.process, incoming, incomingLen, refs :: any, nil, false)
-        if not ok then
-            warn(`[Lync] Client: read error (unreliable): {err}`)
-        end
-    end)
+    Bridge.reliable().OnClientEvent:Connect(handleIncomingReliable)
+    Bridge.unreliable().OnClientEvent:Connect(handleIncomingUnreliable)
 end
 
 return table.freeze(Client)