@axpecter/lync 2.3.3 → 3.0.0

package/src/internal/Registry.luau

@@ -1,119 +0,0 @@
---!strict
---!optimize 2
--- Sequential 7-bit packet/query ID assignment.
-
-local Log = require(script.Parent.Parent.util.Log)
-local Signal = require(script.Parent.Parent.api.Signal)
-local Types = require(script.Parent.Parent.Types)
-
--- Constants --------------------------------------------------------------
-
-local KIND_PACKET = 0
-local KIND_REQUEST = 1
-local KIND_RESPONSE = 2
-
--- 7-bit id leaves the MSB free for the frame single/multi flag (see Constants.FRAME_MSB).
-local MAX_ID = 127
-
--- State ------------------------------------------------------------------
-
-local _nextId = 0
-local _registrationsById: { [number]: Types.Registration } = {}
-local _registrationsByName: { [string]: Types.Registration } = {}
-
--- Public -----------------------------------------------------------------
-
-local Registry = {}
-
-Registry.KIND_PACKET = KIND_PACKET
-Registry.KIND_REQUEST = KIND_REQUEST
-Registry.KIND_RESPONSE = KIND_RESPONSE
-Registry.MAX_ID = MAX_ID
-
-export type RegisterOptions = {
-    name: string,
-    kind: number,
-    codec: Types.InternalCodec<any>,
-    isUnreliable: boolean,
-    partner: number?,
-    needsGate: boolean,
-    headerSize: number,
-    timestampMode: number,
-    openFn: (ch: Types.ChannelState, id: number) -> (),
-    rateLimit: Types.RateLimitConfig?,
-    validate: Types.ValidateFn?,
-    maxPayloadBytes: number?,
-}
-
-function Registry.register(opts: RegisterOptions): Types.Registration
-    local nextCandidate = _nextId + 1
-    if nextCandidate > MAX_ID then
-        Log.error(`ID limit ({MAX_ID}) exceeded; cannot register "{opts.name}"`)
-    end
-    --[[
-        RESPONSE entries share their request's name with a "\0resp" suffix; only
-        request/packet names need uniqueness in the by-name index.
-    ]]
-    if opts.kind ~= KIND_RESPONSE and _registrationsByName[opts.name] ~= nil then
-        Log.error(`duplicate name "{opts.name}"`)
-    end
-
-    _nextId = nextCandidate
-
-    local reg: Types.Registration = {
-        id = nextCandidate,
-        name = opts.name,
-        kind = opts.kind,
-        codec = opts.codec,
-        isUnreliable = opts.isUnreliable,
-        partner = opts.partner,
-        signal = Signal.create(),
-        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,
-        recvFires = 0,
-        drops = 0,
-    }
-
-    _registrationsById[nextCandidate] = reg
-    if opts.kind ~= KIND_RESPONSE then
-        _registrationsByName[opts.name] = reg
-    end
-    return reg
-end
-
-function Registry.get(id: number): Types.Registration?
-    return _registrationsById[id]
-end
-
-function Registry.getByName(name: string): Types.Registration?
-    return _registrationsByName[name]
-end
-
-function Registry.count(): number
-    return _nextId
-end
-
--- IDs are sequential and never freed, so the table has no holes.
-function Registry.all(): { Types.Registration }
-    local result = table.create(_nextId)
-    for i = 1, _nextId do
-        result[i] = _registrationsById[i]
-    end
-    return result
-end
-
-function Registry.reset(): ()
-    table.clear(_registrationsById)
-    table.clear(_registrationsByName)
-    _nextId = 0
-end
-
-return table.freeze(Registry)

package/src/internal/Transport.luau

@@ -1,28 +0,0 @@
---!strict
---!optimize 2
--- Lazy Server/Client require 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/transport/Bridge.luau

@@ -1,110 +0,0 @@
---!strict
---!optimize 2
--- RemoteEvent / UnreliableRemoteEvent wrapper.
-
-local RunService = game:GetService("RunService")
-
-local Log = require(script.Parent.Parent.util.Log)
-
--- Constants --------------------------------------------------------------
-
-local RELIABLE_NAME = "LyncReliable"
-local UNRELIABLE_NAME = "LyncUnreliable"
-
--- State ------------------------------------------------------------------
-
-local _reliable: RemoteEvent? = nil
-local _unreliable: UnreliableRemoteEvent? = nil
-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 r = _reliable
-    if not r then
-        Log.error("not set up; call Lync.start() first")
-    end
-    return r
-end
-
-local function ensureUnreliable(): UnreliableRemoteEvent
-    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
-end
-
--- Public -----------------------------------------------------------------
-
-local Bridge = {}
-
-function Bridge.setup(container: Instance): ()
-    if _isServer then
-        local re = Instance.new("RemoteEvent")
-        re.Name = RELIABLE_NAME
-        re.Parent = container
-
-        local ure = Instance.new("UnreliableRemoteEvent")
-        ure.Name = UNRELIABLE_NAME
-        ure.Parent = container
-
-        _reliable, _unreliable = re, ure
-        return
-    end
-    _reliable = container:WaitForChild(RELIABLE_NAME) :: RemoteEvent
-    _unreliable = container:WaitForChild(UNRELIABLE_NAME) :: UnreliableRemoteEvent
-end
-
-Bridge.reliable = ensureReliable
-Bridge.unreliable = ensureUnreliable
-
-function Bridge.fireServer(data: buffer, refs: { Instance }): ()
-    fireToServer(ensureReliable(), data, refs)
-end
-
-function Bridge.fireClient(player: Player, data: buffer, refs: { Instance }): ()
-    fireToClient(ensureReliable(), player, data, refs)
-end
-
-function Bridge.fireServerUnreliable(data: buffer, refs: { Instance }): ()
-    fireToServer(ensureUnreliable(), data, refs)
-end
-
-function Bridge.fireClientUnreliable(player: Player, data: buffer, refs: { Instance }): ()
-    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,97 +0,0 @@
---!strict
---!optimize 2
--- Client transport: single channel pair 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)
-
--- Constants --------------------------------------------------------------
-
-local CONTAINER_NAME = "LyncRemotes"
-
--- State ------------------------------------------------------------------
-
-local _reliable: Types.ChannelState = Channel.create()
-local _unreliable: Types.ChannelState = Channel.create()
-local _prevIncoming: buffer? = nil
-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
-        return
-    end
-
-    local incomingLen = buffer.len(incoming)
-    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
-
-local function handleIncomingUnreliable(data: any, refs: any?): ()
-    local incoming = Reader.decodeIncoming(data)
-    if not incoming then
-        return
-    end
-    Reader.process(incoming, buffer.len(incoming), refs, nil, false)
-end
-
--- Public -----------------------------------------------------------------
-
-local Client = {}
-
-function Client.getChannel(isUnreliable: boolean): Types.ChannelState
-    return if isUnreliable then _unreliable else _reliable
-end
-
-function Client.flush(): ()
-    if Channel.hasTimestamps() then
-        Channel.updateTimestamp()
-    end
-
-    if _reliable.cursor > 0 then
-        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)
-        resetCh(_reliable)
-    end
-
-    if _unreliable.cursor > 0 then
-        local snapshot, refs = sealAndDump(_unreliable)
-        Bridge.fireServerUnreliable(snapshot, refs)
-        resetCh(_unreliable)
-    end
-end
-
-function Client.start(): ()
-    local container = ReplicatedStorage:WaitForChild(CONTAINER_NAME)
-    Bridge.setup(container)
-
-    Bridge.reliable().OnClientEvent:Connect(handleIncomingReliable)
-    Bridge.unreliable().OnClientEvent:Connect(handleIncomingUnreliable)
-end
-
-return table.freeze(Client)