@axpecter/lync 1.4.3 → 1.5.0

package/src/internal/Middleware.luau

@@ -9,21 +9,21 @@ type Chain = {
     snapshot: { Handler }?,
 }
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
-local DROP = table.freeze ({ _tag = "drop" })
+local DROP = table.freeze({ _tag = "drop" })
 
--- State --------------------------------------------------------------
+-- 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 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)
+        local result = chain[i](current, name, player)
         if result == nil or result == DROP then
             return nil
         end
@@ -32,7 +32,7 @@ local function runChain (chain: { Handler }, data: any, name: string, player: Pl
     return current
 end
 
-local function run (chain: Chain, data: any, name: string, player: Player?): any?
+local function run(chain: Chain, data: any, name: string, player: Player?): any?
     local handlers = chain.handlers
     local count = #handlers
     if count == 0 then
@@ -41,7 +41,7 @@ local function run (chain: Chain, data: any, name: string, player: Player?): any
 
     local snapshot = chain.snapshot
     if not snapshot then
-        snapshot = table.clone (handlers)
+        snapshot = table.clone(handlers)
         chain.snapshot = snapshot
     end
 
@@ -49,13 +49,13 @@ local function run (chain: Chain, data: any, name: string, player: Player?): any
     local result: any
 
     if count == 1 then
-        ok, result = pcall (snapshot[1], data, name, player)
+        ok, result = pcall(snapshot[1], data, name, player)
     else
-        ok, result = pcall (runChain, snapshot, data, name, player)
+        ok, result = pcall(runChain, snapshot, data, name, player)
     end
 
     if not ok then
-        warn (`[Lync] Middleware error on "{name}": {result}`)
+        warn(`[Lync] Middleware error on "{name}": {result}`)
         return nil
     end
 
@@ -66,20 +66,20 @@ local function run (chain: Chain, data: any, name: string, player: Player?): any
     return result
 end
 
-local function addTo (chain: Chain, fn: Handler): () -> ()
-    table.insert (chain.handlers, fn)
+local function addTo(chain: Chain, fn: Handler): () -> ()
+    table.insert(chain.handlers, fn)
     chain.snapshot = nil
 
-    return function (): ()
-        local pos = table.find (chain.handlers, fn)
+    return function(): ()
+        local pos = table.find(chain.handlers, fn)
         if pos then
-            table.remove (chain.handlers, pos)
+            table.remove(chain.handlers, pos)
             chain.snapshot = nil
         end
     end
 end
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Middleware = {}
 
@@ -87,32 +87,32 @@ Middleware.hasSend = false
 Middleware.hasReceive = false
 Middleware.DROP = DROP
 
-function Middleware.addSend (fn: Handler): () -> ()
-    local remover = addTo (_send, fn)
+function Middleware.addSend(fn: Handler): () -> ()
+    local remover = addTo(_send, fn)
     Middleware.hasSend = true
 
-    return function (): ()
-        remover ()
+    return function(): ()
+        remover()
         Middleware.hasSend = #_send.handlers > 0
     end
 end
 
-function Middleware.addReceive (fn: Handler): () -> ()
-    local remover = addTo (_receive, fn)
+function Middleware.addReceive(fn: Handler): () -> ()
+    local remover = addTo(_receive, fn)
     Middleware.hasReceive = true
 
-    return function (): ()
-        remover ()
+    return function(): ()
+        remover()
         Middleware.hasReceive = #_receive.handlers > 0
     end
 end
 
-function Middleware.runSend (data: any, name: string, player: Player?): any?
-    return run (_send, data, name, player)
+function Middleware.runSend(data: any, name: string, player: Player?): any?
+    return run(_send, data, name, player)
 end
 
-function Middleware.runReceive (data: any, name: string, player: Player?): any?
-    return run (_receive, data, name, player)
+function Middleware.runReceive(data: any, name: string, player: Player?): any?
+    return run(_receive, data, name, player)
 end
 
 -- Not frozen: hasSend and hasReceive are mutated at runtime.

package/src/internal/Pool.luau

@@ -2,38 +2,38 @@
 --!optimize 2
 -- Stack-based ChannelState pool with warmup support.
 
-local Channel = require (script.Parent.Channel)
-local Types = require (script.Parent.Parent.Types)
+local Channel = require(script.Parent.Channel)
+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.
-function Pool.setMaxSize (count: number): ()
+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
 
-function Pool.getMaxSize (): number
+function Pool.getMaxSize(): number
     return _maxSize
 end
 
-function Pool.acquire (): ChannelState
+function Pool.acquire(): ChannelState
     if _depth > 0 then
         local ch = _stack[_depth]
         _stack[_depth] = nil :: any
@@ -41,16 +41,16 @@ function Pool.acquire (): ChannelState
         return ch
     end
 
-    return Channel.create ()
+    return Channel.create()
 end
 
-function Pool.release (ch: ChannelState): ()
+function Pool.release(ch: ChannelState): ()
     ch.cursor = 0
     ch.lastId = -1
     ch.countPos = 0
     ch.itemCount = 0
-    table.clear (ch.refs)
-    table.clear (ch.deltas)
+    table.clear(ch.refs)
+    table.clear(ch.deltas)
     ch.prevDump = nil
 
     if _depth >= _maxSize then
@@ -61,8 +61,8 @@ function Pool.release (ch: ChannelState): ()
     _stack[_depth] = ch
 end
 
-function Pool.size (): number
+function Pool.size(): number
     return _depth
 end
 
-return table.freeze (Pool)
+return table.freeze(Pool)

package/src/internal/Registry.luau

@@ -2,28 +2,28 @@
 --!optimize 2
 -- Deterministic ID assignment for packets and queries.
 
-local Types = require (script.Parent.Parent.Types)
+local Types = require(script.Parent.Parent.Types)
 
 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 (
+local function assign(
     name: string,
     baseName: string,
     codec: Codec<any>,
@@ -35,23 +35,23 @@ local function assign (
     maxPayloadBytes: number?
 ): Registration
     if _names[name] then
-        error (`[Lync] Duplicate registration: "{name}"`)
+        error(`[Lync] Duplicate registration: "{name}"`)
     end
     if _nextId > MAX_PACKETS then
-        error (`[Lync] Registration limit reached: {MAX_PACKETS} max`)
+        error(`[Lync] Registration limit reached: {MAX_PACKETS} max`)
     end
 
     if rateLimit then
         if rateLimit.maxPerSecond <= 0 then
-            error (`[Lync] maxPerSecond must be positive: "{name}"`)
+            error(`[Lync] maxPerSecond must be positive: "{name}"`)
         end
         if rateLimit.burstAllowance and rateLimit.burstAllowance <= 0 then
-            error (`[Lync] burstAllowance must be positive: "{name}"`)
+            error(`[Lync] burstAllowance must be positive: "{name}"`)
         end
     end
 
     if maxPayloadBytes and maxPayloadBytes <= 0 then
-        error (`[Lync] maxPayloadBytes must be positive: "{name}"`)
+        error(`[Lync] maxPayloadBytes must be positive: "{name}"`)
     end
 
     local id = _nextId
@@ -77,7 +77,7 @@ local function assign (
     return reg
 end
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Registry = {
     KIND_PACKET = KIND_PACKET,
@@ -85,7 +85,7 @@ local Registry = {
     KIND_RESPONSE = KIND_RESPONSE,
 }
 
-function Registry.register (
+function Registry.register(
     name: string,
     codec: Codec<any>,
     isUnreliable: boolean,
@@ -94,7 +94,7 @@ function Registry.register (
     validate: ((data: any, player: Player) -> (boolean, string?))?,
     maxPayloadBytes: number?
 ): Registration
-    return assign (
+    return assign(
         name,
         name,
         codec,
@@ -107,7 +107,7 @@ function Registry.register (
     )
 end
 
-function Registry.registerQueryPair (
+function Registry.registerQueryPair(
     name: string,
     requestCodec: Codec<any>,
     responseCodec: Codec<any>,
@@ -116,7 +116,7 @@ function Registry.registerQueryPair (
     rateLimit: RateLimitConfig?,
     validate: ((data: any, player: Player) -> (boolean, string?))?
 ): (Registration, Registration)
-    local req = assign (
+    local req = assign(
         `{name}:req`,
         name,
         requestCodec,
@@ -127,20 +127,20 @@ function Registry.registerQueryPair (
         validate
     )
     local resp =
-        assign (`{name}:resp`, name, responseCodec, false, KIND_RESPONSE, responseSignal, nil, nil)
+        assign(`{name}:resp`, name, responseCodec, false, KIND_RESPONSE, responseSignal, nil, nil)
 
     req.partner = resp.id
     resp.partner = req.id
     return req, resp
 end
 
-function Registry.get (id: number): Registration?
+function Registry.get(id: number): Registration?
     return _entries[id]
 end
 
-function Registry.getByName (name: string): Registration?
+function Registry.getByName(name: string): Registration?
     local id = _names[name]
     return if id then _entries[id] else nil
 end
 
-return table.freeze (Registry)
+return table.freeze(Registry)

package/src/transport/Bridge.luau

@@ -2,35 +2,35 @@
 --!optimize 2
 -- Creates and exposes the network remote instances.
 
-local ReplicatedStorage = game:GetService ("ReplicatedStorage")
-local RunService = game:GetService ("RunService")
+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 = {}
 
-function Bridge.setup (): ()
-    if RunService:IsServer () then
-        local folder = Instance.new ("Folder")
+function Bridge.setup(): ()
+    if RunService:IsServer() then
+        local folder = Instance.new("Folder")
         folder.Name = FOLDER
 
-        local reliable = Instance.new ("RemoteEvent")
+        local reliable = Instance.new("RemoteEvent")
         reliable.Name = RELIABLE
         reliable.Parent = folder
 
-        local unreliable = Instance.new ("UnreliableRemoteEvent")
+        local unreliable = Instance.new("UnreliableRemoteEvent")
         unreliable.Name = UNRELIABLE
         unreliable.Parent = folder
 
@@ -39,19 +39,19 @@ function Bridge.setup (): ()
         _reliable = reliable
         _unreliable = unreliable
     else
-        local folder = ReplicatedStorage:WaitForChild (FOLDER, TIMEOUT)
+        local folder = ReplicatedStorage:WaitForChild(FOLDER, TIMEOUT)
         if not folder then
-            error ("[Lync] Network folder not found, is the server started?")
+            error("[Lync] Network folder not found, is the server started?")
         end
 
-        local reliable = folder:WaitForChild (RELIABLE, TIMEOUT)
+        local reliable = folder:WaitForChild(RELIABLE, TIMEOUT)
         if not reliable then
-            error ("[Lync] Reliable remote not found")
+            error("[Lync] Reliable remote not found")
         end
 
-        local unreliable = folder:WaitForChild (UNRELIABLE, TIMEOUT)
+        local unreliable = folder:WaitForChild(UNRELIABLE, TIMEOUT)
         if not unreliable then
-            error ("[Lync] Unreliable remote not found")
+            error("[Lync] Unreliable remote not found")
         end
 
         _reliable = reliable :: RemoteEvent
@@ -60,7 +60,7 @@ function Bridge.setup (): ()
 
     Bridge.reliable = _reliable :: any
     Bridge.unreliable = _unreliable :: any
-    table.freeze (Bridge)
+    table.freeze(Bridge)
 end
 
 -- Not frozen at module level: setup() populates reliable/unreliable then freezes.

package/src/transport/Client.luau

@@ -2,18 +2,18 @@
 --!optimize 2
 -- Client-side transport with batching, frame XOR on reliable.
 
-local RunService = game:GetService ("RunService")
+local RunService = game:GetService("RunService")
 
-local Bridge = require (script.Parent.Bridge)
-local Channel = require (script.Parent.Parent.internal.Channel)
-local Middleware = require (script.Parent.Parent.internal.Middleware)
-local Reader = require (script.Parent.Reader)
-local Types = require (script.Parent.Parent.Types)
+local Bridge = require(script.Parent.Bridge)
+local Channel = require(script.Parent.Parent.internal.Channel)
+local Middleware = require(script.Parent.Parent.internal.Middleware)
+local Reader = require(script.Parent.Reader)
+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"
 
@@ -22,77 +22,77 @@ 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)
+local function receive(data: any, refs: any, applyXor: boolean): ()
+    local buf = Reader.decodeIncoming(data)
     if not buf then
         return
     end
 
     local raw: buffer
     if applyXor then
-        raw = Channel.xorApply (buf, _prevRecv)
+        raw = Channel.xorApply(buf, _prevRecv)
         _prevRecv = raw
     else
         raw = buf
     end
 
-    local safeRefs: { Instance }? = if typeof (refs) == "table" then refs else nil
-    local ok, err = pcall (Reader.process, raw, safeRefs, nil, 0)
+    local safeRefs: { Instance }? = if typeof(refs) == "table" then refs else nil
+    local ok, err = pcall(Reader.process, raw, safeRefs, nil, 0)
     if not ok then
-        warn (`[Lync] Read failed: {err}`)
+        warn(`[Lync] Read failed: {err}`)
     end
 end
 
-local function flushChannel (remote: any, ch: ChannelState, applyXor: boolean): ()
+local function flushChannel(remote: any, ch: ChannelState, applyXor: boolean): ()
     if ch.cursor == 0 then
         return
     end
 
-    local raw, refs = Channel.sealAndDump (ch)
+    local raw, refs = Channel.sealAndDump(ch)
 
     if applyXor then
-        local xored = Channel.xorApply (raw, ch.prevDump)
+        local xored = Channel.xorApply(raw, ch.prevDump)
         ch.prevDump = raw
-        remote:FireServer (xored, refs)
+        remote:FireServer(xored, refs)
     else
-        remote:FireServer (raw, refs)
+        remote:FireServer(raw, refs)
     end
 
-    Channel.reset (ch)
+    Channel.reset(ch)
 end
 
-local function flush (): ()
-    flushChannel (Bridge.reliable, _reliable :: ChannelState, true)
-    flushChannel (Bridge.unreliable, _unreliable :: ChannelState, false)
+local function flush(): ()
+    flushChannel(Bridge.reliable, _reliable :: ChannelState, true)
+    flushChannel(Bridge.unreliable, _unreliable :: ChannelState, false)
 end
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Client = {}
 
-function Client.start (): ()
+function Client.start(): ()
     if _isStarted then
         return
     end
     _isStarted = true
 
-    Bridge.setup ()
+    Bridge.setup()
 
-    _reliable = Channel.create ()
-    _unreliable = Channel.create ()
+    _reliable = Channel.create()
+    _unreliable = Channel.create()
 
-    Bridge.reliable.OnClientEvent:Connect (function (data: any, refs: any): ()
-        receive (data, refs, true)
+    Bridge.reliable.OnClientEvent:Connect(function(data: any, refs: any): ()
+        receive(data, refs, true)
     end)
-    Bridge.unreliable.OnClientEvent:Connect (function (data: any, refs: any): ()
-        receive (data, refs, false)
+    Bridge.unreliable.OnClientEvent:Connect(function(data: any, refs: any): ()
+        receive(data, refs, false)
     end)
-    RunService.Heartbeat:Connect (flush)
+    RunService.Heartbeat:Connect(flush)
 end
 
-function Client.write (
+function Client.write(
     id: number,
     name: string,
     codec: Codec<any>,
@@ -100,12 +100,12 @@ function Client.write (
     isUnreliable: boolean
 ): ()
     if not _isStarted then
-        error (NOT_STARTED)
+        error(NOT_STARTED)
     end
 
     local final: any
     if Middleware.hasSend then
-        final = Middleware.runSend (data, name, nil)
+        final = Middleware.runSend(data, name, nil)
         if final == nil then
             return
         end
@@ -114,11 +114,11 @@ function Client.write (
     end
 
     local ch = if isUnreliable then _unreliable :: ChannelState else _reliable :: ChannelState
-    Channel.writeBatch (ch, id, name, codec, final)
+    Channel.writeBatch(ch, id, name, codec, final)
 end
 
--- Shared for both query requests and responses (identical wire format).
-function Client.writeQuery (
+-- Shared for both query requests and responses(identical wire format).
+function Client.writeQuery(
     id: number,
     name: string,
     correlationId: number,
@@ -126,12 +126,12 @@ function Client.writeQuery (
     data: any
 ): ()
     if not _isStarted then
-        error (NOT_STARTED)
+        error(NOT_STARTED)
     end
 
     local final: any
     if Middleware.hasSend then
-        final = Middleware.runSend (data, name, nil)
+        final = Middleware.runSend(data, name, nil)
         if final == nil then
             return
         end
@@ -139,14 +139,14 @@ function Client.writeQuery (
         final = data
     end
 
-    Channel.writeQuery (_reliable :: ChannelState, id, name, correlationId, codec, final)
+    Channel.writeQuery(_reliable :: ChannelState, id, name, correlationId, codec, final)
 end
 
-function Client.writeQueryNil (id: number, name: string, correlationId: number): ()
+function Client.writeQueryNil(id: number, name: string, correlationId: number): ()
     if not _isStarted then
-        error (NOT_STARTED)
+        error(NOT_STARTED)
     end
-    Channel.writeQuery (_reliable :: ChannelState, id, name, correlationId, nil, nil)
+    Channel.writeQuery(_reliable :: ChannelState, id, name, correlationId, nil, nil)
 end
 
-return table.freeze (Client)
+return table.freeze(Client)