@axpecter/lync 2.2.1 → 2.3.2

package/src/transport/Bridge.luau

@@ -1,9 +1,11 @@
 --!strict
 --!optimize 2
--- RemoteEvent / UnreliableRemoteEvent thin wrapper.
+-- RemoteEvent / UnreliableRemoteEvent wrapper.
 
 local RunService = game:GetService("RunService")
 
+local Log = require(script.Parent.Parent.util.Log)
+
 -- Constants --------------------------------------------------------------
 
 local RELIABLE_NAME = "LyncReliable"
@@ -17,20 +19,41 @@ local _isServer = RunService:IsServer()
 
 -- Private ----------------------------------------------------------------
 
+--[[
+    Captured to a local first so Log.error's `never` return narrows the
+    optional. Reading the module global directly wouldn't narrow.
+]]
 local function ensureReliable(): RemoteEvent
-    local re = _reliable
-    if not re then
-        error("[Lync] Bridge.reliable: not set up; call Lync.start() first")
+    local r = _reliable
+    if not r then
+        Log.error("not set up; call Lync.start() first")
     end
-    return re
+    return r
 end
 
 local function ensureUnreliable(): UnreliableRemoteEvent
-    local ure = _unreliable
-    if not ure then
-        error("[Lync] Bridge.unreliable: not set up; call Lync.start() first")
+    local u = _unreliable
+    if not u then
+        Log.error("not set up; call Lync.start() first")
+    end
+    return u
+end
+
+-- Drop the trailing arg when refs is empty: Roblox serializes empty tables as several wire bytes.
+local function fireToServer(re: any, data: buffer, refs: { Instance }): ()
+    if #refs > 0 then
+        re:FireServer(data, refs)
+    else
+        re:FireServer(data)
+    end
+end
+
+local function fireToClient(re: any, player: Player, data: buffer, refs: { Instance }): ()
+    if #refs > 0 then
+        re:FireClient(player, data, refs)
+    else
+        re:FireClient(player, data)
     end
-    return ure
 end
 
 -- Public -----------------------------------------------------------------
@@ -58,39 +81,30 @@ Bridge.reliable = ensureReliable
 Bridge.unreliable = ensureUnreliable
 
 function Bridge.fireServer(data: buffer, refs: { Instance }): ()
-    local re = ensureReliable()
-    if #refs > 0 then
-        re:FireServer(data, refs)
-    else
-        re:FireServer(data)
-    end
+    fireToServer(ensureReliable(), data, refs)
 end
 
 function Bridge.fireClient(player: Player, data: buffer, refs: { Instance }): ()
-    local re = ensureReliable()
-    if #refs > 0 then
-        re:FireClient(player, data, refs)
-    else
-        re:FireClient(player, data)
-    end
+    fireToClient(ensureReliable(), player, data, refs)
 end
 
 function Bridge.fireServerUnreliable(data: buffer, refs: { Instance }): ()
-    local ure = ensureUnreliable()
-    if #refs > 0 then
-        ure:FireServer(data, refs)
-    else
-        ure:FireServer(data)
-    end
+    fireToServer(ensureUnreliable(), data, refs)
 end
 
 function Bridge.fireClientUnreliable(player: Player, data: buffer, refs: { Instance }): ()
-    local ure = ensureUnreliable()
-    if #refs > 0 then
-        ure:FireClient(player, data, refs)
-    else
-        ure:FireClient(player, data)
-    end
+    fireToClient(ensureUnreliable(), player, data, refs)
+end
+
+-- Test injection point: harnesses substitute fake remotes.
+function Bridge.attach(reliable: any, unreliable: any): ()
+    _reliable = reliable
+    _unreliable = unreliable
+end
+
+function Bridge.reset(): ()
+    _reliable = nil
+    _unreliable = nil
 end
 
 return table.freeze(Bridge)

package/src/transport/Client.luau

@@ -1,6 +1,6 @@
 --!strict
 --!optimize 2
--- Client-side transport: single channel pair, flush, with outbound XOR delta.
+-- Client transport: single channel pair with outbound XOR delta.
 
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
 
@@ -18,10 +18,14 @@ local CONTAINER_NAME = "LyncRemotes"
 local _reliable: Types.ChannelState = Channel.create()
 local _unreliable: Types.ChannelState = Channel.create()
 local _prevIncoming: buffer? = nil
-local _prevIncomingLen = 0
+local _prevIncomingLen: number = 0
 
 -- Private ----------------------------------------------------------------
 
+local xorApply = Channel.xorApply
+local sealAndDump = Channel.sealAndDump
+local resetCh = Channel.reset
+
 local function handleIncomingReliable(data: any, refs: any?): ()
     local incoming = Reader.decodeIncoming(data)
     if not incoming then
@@ -29,15 +33,19 @@ local function handleIncomingReliable(data: any, refs: any?): ()
     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}`)
+    local decoded = xorApply(incoming, incomingLen, _prevIncoming, _prevIncomingLen)
+
+    --[[
+        Mirror Server: only adopt `decoded` as the next baseline on success.
+        A failed parse means the wire is suspect; reusing it would poison
+        every subsequent packet.
+    ]]
+    if Reader.process(decoded, incomingLen, refs, nil, false) then
+        _prevIncoming = decoded
+        _prevIncomingLen = incomingLen
+    else
+        _prevIncoming = nil
+        _prevIncomingLen = 0
     end
 end
 
@@ -46,11 +54,7 @@ local function handleIncomingUnreliable(data: any, refs: any?): ()
     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
+    Reader.process(incoming, buffer.len(incoming), refs, nil, false)
 end
 
 -- Public -----------------------------------------------------------------
@@ -67,18 +71,18 @@ function Client.flush(): ()
     end
 
     if _reliable.cursor > 0 then
-        local snapshot, refs, byteLen = Channel.sealAndDump(_reliable)
-        local xored = Channel.xorApply(snapshot, byteLen, _reliable.prevDump, _reliable.prevDumpLen)
+        local snapshot, refs, byteLen = sealAndDump(_reliable)
+        local xored = xorApply(snapshot, byteLen, _reliable.prevDump, _reliable.prevDumpLen)
         _reliable.prevDump = snapshot
         _reliable.prevDumpLen = byteLen
         Bridge.fireServer(xored, refs)
-        Channel.reset(_reliable)
+        resetCh(_reliable)
     end
 
     if _unreliable.cursor > 0 then
-        local snapshot, refs = Channel.sealAndDump(_unreliable)
+        local snapshot, refs = sealAndDump(_unreliable)
         Bridge.fireServerUnreliable(snapshot, refs)
-        Channel.reset(_unreliable)
+        resetCh(_unreliable)
     end
 end