@axpecter/lync 2.0.0 → 2.1.0

package/src/internal/Middleware.luau

@@ -1,119 +1,94 @@
 --!strict
 --!optimize 2
--- Ordered intercept chains for send and receive.
+-- Ordered intercept chains returning Connection objects.
 
-type Handler = (data: any, name: string, player: Player?) -> any?
+local Signal = require(script.Parent.Parent.api.Signal)
+local Types = require(script.Parent.Parent.Types)
 
-type Chain = {
-    handlers: { Handler },
-    snapshot: { Handler }?,
-}
+-- State ---------------------------------------------------------------
 
--- Constants -----------------------------------------------------------
+local _sendSignal = Signal.create()
+local _receiveSignal = Signal.create()
+local _dropSignal = Signal.create()
 
-local DROP = table.freeze({ _tag = "drop" })
+-- Public --------------------------------------------------------------
 
--- State ---------------------------------------------------------------
+local Middleware = {}
 
-local _send: Chain = { handlers = {}, snapshot = nil }
-local _receive: Chain = { handlers = {}, snapshot = nil }
+function Middleware.onSend(fn: (data: any, name: string, player: Player?) -> any): Types.Connection
+    return _sendSignal:connect(fn)
+end
 
--- Private -------------------------------------------------------------
+function Middleware.onReceive(
+    fn: (data: any, name: string, player: Player?) -> any
+): Types.Connection
+    return _receiveSignal:connect(fn)
+end
 
-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 or result == DROP then
-            return nil
-        end
-        current = result
-    end
-    return current
+function Middleware.onDrop(
+    fn: (player: Player, reason: string, name: string, data: any?) -> ()
+): Types.Connection
+    return _dropSignal:connect(fn)
 end
 
-local function run(chain: Chain, data: any, name: string, player: Player?): any?
-    local handlers = chain.handlers
-    local count = #handlers
+--[[
+    Runs send middleware chain. Returns transformed data, or DROP sentinel.
+    If no hooks, returns data unchanged (zero overhead).
+]]
+function Middleware.runSend(data: any, name: string, player: Player?): any
+    local count = _sendSignal._count[1]
     if count == 0 then
         return data
     end
 
-    local snapshot = chain.snapshot
-    if not snapshot then
-        snapshot = table.clone(handlers)
-        chain.snapshot = snapshot
-    end
-
-    local ok: boolean
-    local result: any
-
-    if count == 1 then
-        ok, result = pcall(snapshot[1], data, name, player)
-    else
-        ok, result = pcall(runChain, snapshot, data, name, player)
-    end
+    local entries = _sendSignal._entries
+    local result = data
 
-    if not ok then
-        warn(`[Lync] Middleware error on "{name}": {result}`)
-        return nil
-    end
-
-    if result == DROP then
-        return nil
+    for i = 1, count do
+        local entry = entries[i]
+        if entry._state ~= 0 then -- not disconnected
+            local returned = entry.fn(result, name, player)
+            if returned ~= nil then
+                result = returned
+            end
+        end
     end
 
     return result
 end
 
-local function addTo(chain: Chain, fn: Handler): () -> ()
-    table.insert(chain.handlers, fn)
-    chain.snapshot = nil
-
-    return function(): ()
-        local pos = table.find(chain.handlers, fn)
-        if pos then
-            table.remove(chain.handlers, pos)
-            chain.snapshot = nil
-        end
+function Middleware.runReceive(data: any, name: string, player: Player?): any
+    local count = _receiveSignal._count[1]
+    if count == 0 then
+        return data
     end
-end
-
--- Public --------------------------------------------------------------
 
-local Middleware = {}
+    local entries = _receiveSignal._entries
+    local result = data
 
-Middleware.hasSend = false
-Middleware.hasReceive = false
-Middleware.DROP = DROP
-
-function Middleware.addSend(fn: Handler): () -> ()
-    local remover = addTo(_send, fn)
-    Middleware.hasSend = true
-
-    return function(): ()
-        remover()
-        Middleware.hasSend = #_send.handlers > 0
+    for i = 1, count do
+        local entry = entries[i]
+        if entry._state ~= 0 then
+            local returned = entry.fn(result, name, player)
+            if returned ~= nil then
+                result = returned
+            end
+        end
     end
-end
 
-function Middleware.addReceive(fn: Handler): () -> ()
-    local remover = addTo(_receive, fn)
-    Middleware.hasReceive = true
+    return result
+end
 
-    return function(): ()
-        remover()
-        Middleware.hasReceive = #_receive.handlers > 0
-    end
+function Middleware.fireDrop(player: Player, reason: string, name: string, data: any?): ()
+    _dropSignal:fireSync(player, reason, name, data)
 end
 
-function Middleware.runSend(data: any, name: string, player: Player?): any?
-    return run(_send, data, name, player)
+function Middleware.hasSendHooks(): boolean
+    return _sendSignal._count[1] > 0
 end
 
-function Middleware.runReceive(data: any, name: string, player: Player?): any?
-    return run(_receive, data, name, player)
+function Middleware.hasReceiveHooks(): boolean
+    return _receiveSignal._count[1] > 0
 end
 
--- Not frozen: hasSend and hasReceive are mutated at runtime.
-return Middleware
+return table.freeze(Middleware)

package/src/internal/Pool.luau

@@ -1,67 +1,56 @@
 --!strict
 --!optimize 2
--- Stack-based ChannelState pool with warmup support.
+-- Stack-based ChannelState pool for per-player channel reuse.
 
 local Channel = require(script.Parent.Channel)
 local Types = require(script.Parent.Parent.Types)
 
-type ChannelState = Types.ChannelState
-
 -- Constants -----------------------------------------------------------
 
-local DEFAULT_MAX = 16
+local DEFAULT_SIZE = 16
 
 -- State ---------------------------------------------------------------
 
-local _stack = {} :: { ChannelState }
+local _stack: { Types.ChannelState } = {}
 local _depth = 0
-local _maxSize = DEFAULT_MAX
+local _maxSize = DEFAULT_SIZE
 
 -- Public --------------------------------------------------------------
 
 local Pool = {}
 
--- 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}`)
-    end
-    _maxSize = count
-end
-
-function Pool.getMaxSize(): number
-    return _maxSize
-end
-
-function Pool.acquire(): ChannelState
+function Pool.acquire(): Types.ChannelState
     if _depth > 0 then
         local ch = _stack[_depth]
         _stack[_depth] = nil :: any
         _depth -= 1
+        Channel.reset(ch)
         return ch
     end
 
     return Channel.create()
 end
 
-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)
-    ch.prevDump = nil
-
+function Pool.release(ch: Types.ChannelState): ()
     if _depth >= _maxSize then
-        return -- discard; GC will reclaim
+        return
     end
 
     _depth += 1
     _stack[_depth] = ch
 end
 
-function Pool.size(): number
+function Pool.setMaxSize(size: number): ()
+    _maxSize = size
+
+    -- Trim excess
+    while _depth > _maxSize do
+        _stack[_depth] = nil :: any
+        _depth -= 1
+    end
+end
+
+function Pool.count(): number
     return _depth
 end
 

package/src/internal/Registry.luau

@@ -1,79 +1,71 @@
 --!strict
 --!optimize 2
--- Deterministic ID assignment for packets and queries.
+-- Deterministic packet/query ID assignment. Sequential 7-bit IDs.
 
-local Channel = require(script.Parent.Channel)
+local Signal = require(script.Parent.Parent.api.Signal)
 local Types = require(script.Parent.Parent.Types)
 
-type Codec<T> = Types.Codec<T>
-type Registration = Types.Registration
-type RateLimitConfig = Types.RateLimitConfig
-
 -- Constants -----------------------------------------------------------
 
 local KIND_PACKET = 0
 local KIND_REQUEST = 1
 local KIND_RESPONSE = 2
-local MAX_PACKETS = 255
+local MAX_ID = 127
 
 -- State ---------------------------------------------------------------
 
-local _entries = {} :: { Registration }
-local _names = {} :: { [string]: number }
-local _nextId = 1
+local _nextId = 0
+local _byId: { [number]: Types.Registration } = {}
+local _byName: { [string]: Types.Registration } = {}
+
+-- Public --------------------------------------------------------------
+
+local Registry = {}
 
--- Private -------------------------------------------------------------
+Registry.KIND_PACKET = KIND_PACKET
+Registry.KIND_REQUEST = KIND_REQUEST
+Registry.KIND_RESPONSE = KIND_RESPONSE
 
-local function assign(
+function Registry.register(
     name: string,
-    baseName: string,
-    codec: Codec<any>,
-    isUnreliable: boolean,
     kind: number,
-    signal: any,
-    rateLimit: RateLimitConfig?,
+    codec: Types.InternalCodec<any>,
+    isUnreliable: boolean,
+    partner: number?,
+    needsGate: boolean,
+    headerSize: number,
+    timestampMode: number,
+    openFn: (ch: Types.ChannelState, id: number) -> (),
+    rateLimit: Types.RateLimitConfig?,
     validate: ((data: any, player: Player) -> (boolean, string?))?,
-    maxPayloadBytes: number?,
-    timestampMode: number?
-): Registration
-    if _names[name] then
-        error(`[Lync] Duplicate registration: "{name}"`)
-    end
-    if _nextId > MAX_PACKETS then
-        error(`[Lync] Registration limit reached: {MAX_PACKETS} max`)
-    end
+    maxPayloadBytes: number?
+): Types.Registration
+    _nextId += 1
+    local id = _nextId
 
-    if rateLimit then
-        if rateLimit.maxPerSecond <= 0 then
-            error(`[Lync] maxPerSecond must be positive: "{name}"`)
-        end
-        if rateLimit.burstAllowance and rateLimit.burstAllowance <= 0 then
-            error(`[Lync] burstAllowance must be positive: "{name}"`)
-        end
+    if id > MAX_ID then
+        error(`[Lync] Registry: ID limit exceeded ({MAX_ID}), too many packets/queries`)
     end
 
-    if maxPayloadBytes and maxPayloadBytes <= 0 then
-        error(`[Lync] maxPayloadBytes must be positive: "{name}"`)
+    if _byName[name] and kind ~= KIND_RESPONSE then
+        error(`[Lync] Registry: duplicate name "{name}"`)
     end
 
-    local id = _nextId
-    _nextId += 1
-
-    local reg: Registration = {
+    local reg: Types.Registration = {
         id = id,
         name = name,
-        baseName = baseName,
+        kind = kind,
         codec = codec,
         isUnreliable = isUnreliable,
-        kind = kind,
-        partner = nil,
-        signal = signal,
+        partner = partner,
+        signal = Signal.create(),
         rateLimit = rateLimit,
         validate = validate,
-        needsGate = rateLimit ~= nil or validate ~= nil,
+        needsGate = needsGate,
         maxPayloadBytes = maxPayloadBytes,
-        timestampMode = timestampMode or 0,
-        _openFn = Channel.resolveOpenFn(timestampMode or 0),
+        timestampMode = timestampMode,
+        headerSize = headerSize,
+        _openFn = openFn,
         bytesSent = 0,
         bytesReceived = 0,
         fires = 0,
@@ -81,83 +73,34 @@ local function assign(
         drops = 0,
     }
 
-    _entries[id] = reg
-    _names[name] = id
-    return reg
-end
-
--- Public --------------------------------------------------------------
-
-local Registry = {
-    KIND_PACKET = KIND_PACKET,
-    KIND_REQUEST = KIND_REQUEST,
-    KIND_RESPONSE = KIND_RESPONSE,
-}
+    _byId[id] = reg
+    if kind ~= KIND_RESPONSE then
+        _byName[name] = reg
+    end
 
-function Registry.register(
-    name: string,
-    codec: Codec<any>,
-    isUnreliable: boolean,
-    signal: any,
-    rateLimit: RateLimitConfig?,
-    validate: ((data: any, player: Player) -> (boolean, string?))?,
-    maxPayloadBytes: number?,
-    timestampMode: number?
-): Registration
-    return assign(
-        name,
-        name,
-        codec,
-        isUnreliable,
-        KIND_PACKET,
-        signal,
-        rateLimit,
-        validate,
-        maxPayloadBytes,
-        timestampMode
-    )
+    return reg
 end
 
-function Registry.registerQueryPair(
-    name: string,
-    requestCodec: Codec<any>,
-    responseCodec: Codec<any>,
-    requestSignal: any,
-    responseSignal: any,
-    rateLimit: RateLimitConfig?,
-    validate: ((data: any, player: Player) -> (boolean, string?))?
-): (Registration, Registration)
-    local req = assign(
-        `{name}:req`,
-        name,
-        requestCodec,
-        false,
-        KIND_REQUEST,
-        requestSignal,
-        rateLimit,
-        validate
-    )
-    local resp =
-        assign(`{name}:resp`, name, responseCodec, false, KIND_RESPONSE, responseSignal, nil, nil)
-
-    req.partner = resp.id
-    resp.partner = req.id
-    return req, resp
+function Registry.get(id: number): Types.Registration?
+    return _byId[id]
 end
 
-function Registry.get(id: number): Registration?
-    return _entries[id]
+function Registry.getByName(name: string): Types.Registration?
+    return _byName[name]
 end
 
-function Registry.getByName(name: string): Registration?
-    local id = _names[name]
-    return if id then _entries[id] else nil
+function Registry.count(): number
+    return _nextId
 end
 
-function Registry.forEach(fn: (reg: Registration) -> ()): ()
-    for _, reg in _entries do
-        fn(reg)
+function Registry.all(): { Types.Registration }
+    local result = table.create(_nextId)
+    for i = 1, _nextId do
+        if _byId[i] then
+            table.insert(result, _byId[i])
+        end
     end
+    return result
 end
 
 return table.freeze(Registry)

package/src/transport/Bridge.luau

@@ -1,67 +1,88 @@
 --!strict
 --!optimize 2
--- Creates and exposes the network remote instances.
+-- Remote instance creation and access.
 
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local RunService = game:GetService("RunService")
 
 -- Constants -----------------------------------------------------------
 
-local FOLDER = "_lync"
-local RELIABLE = "R"
-local UNRELIABLE = "U"
-local TIMEOUT = 10
+local RELIABLE_NAME = "LyncReliable"
+local UNRELIABLE_NAME = "LyncUnreliable"
 
 -- State ---------------------------------------------------------------
 
-local _reliable: RemoteEvent
-local _unreliable: UnreliableRemoteEvent
+local _reliable: RemoteEvent? = nil
+local _unreliable: UnreliableRemoteEvent? = nil
+local _isServer = RunService:IsServer()
 
 -- Public --------------------------------------------------------------
 
 local Bridge = {}
 
-function Bridge.setup(): ()
-    if RunService:IsServer() then
-        local folder = Instance.new("Folder")
-        folder.Name = FOLDER
+function Bridge.setup(container: Instance): ()
+    if _isServer then
+        local re = Instance.new("RemoteEvent")
+        re.Name = RELIABLE_NAME
+        re.Parent = container
 
-        local reliable = Instance.new("RemoteEvent")
-        reliable.Name = RELIABLE
-        reliable.Parent = folder
+        local ure = Instance.new("UnreliableRemoteEvent")
+        ure.Name = UNRELIABLE_NAME
+        ure.Parent = container
 
-        local unreliable = Instance.new("UnreliableRemoteEvent")
-        unreliable.Name = UNRELIABLE
-        unreliable.Parent = folder
+        _reliable = re
+        _unreliable = ure
+    else
+        _reliable = container:WaitForChild(RELIABLE_NAME) :: RemoteEvent
+        _unreliable = container:WaitForChild(UNRELIABLE_NAME) :: UnreliableRemoteEvent
+    end
+end
+
+function Bridge.reliable(): RemoteEvent
+    return _reliable :: RemoteEvent
+end
 
-        folder.Parent = ReplicatedStorage
+function Bridge.unreliable(): UnreliableRemoteEvent
+    return _unreliable :: UnreliableRemoteEvent
+end
+
+function Bridge.isServer(): boolean
+    return _isServer
+end
 
-        _reliable = reliable
-        _unreliable = unreliable
+function Bridge.fireServer(data: buffer, refs: { Instance }): ()
+    local re = _reliable :: RemoteEvent
+    if #refs > 0 then
+        re:FireServer(data, refs)
     else
-        local folder = ReplicatedStorage:WaitForChild(FOLDER, TIMEOUT)
-        if not folder then
-            error("[Lync] Network folder not found, is the server started?")
-        end
-
-        local reliable = folder:WaitForChild(RELIABLE, TIMEOUT)
-        if not reliable then
-            error("[Lync] Reliable remote not found")
-        end
-
-        local unreliable = folder:WaitForChild(UNRELIABLE, TIMEOUT)
-        if not unreliable then
-            error("[Lync] Unreliable remote not found")
-        end
-
-        _reliable = reliable :: RemoteEvent
-        _unreliable = unreliable :: UnreliableRemoteEvent
+        re:FireServer(data)
     end
+end
 
-    Bridge.reliable = _reliable :: any
-    Bridge.unreliable = _unreliable :: any
-    table.freeze(Bridge)
+function Bridge.fireClient(player: Player, data: buffer, refs: { Instance }): ()
+    local re = _reliable :: RemoteEvent
+    if #refs > 0 then
+        re:FireClient(player, data, refs)
+    else
+        re:FireClient(player, data)
+    end
+end
+
+function Bridge.fireServerUnreliable(data: buffer, refs: { Instance }): ()
+    local ure = _unreliable :: UnreliableRemoteEvent
+    if #refs > 0 then
+        ure:FireServer(data, refs)
+    else
+        ure:FireServer(data)
+    end
+end
+
+function Bridge.fireClientUnreliable(player: Player, data: buffer, refs: { Instance }): ()
+    local ure = _unreliable :: UnreliableRemoteEvent
+    if #refs > 0 then
+        ure:FireClient(player, data, refs)
+    else
+        ure:FireClient(player, data)
+    end
 end
 
--- Not frozen at module level: setup() populates reliable/unreliable then freezes.
-return Bridge
+return table.freeze(Bridge)