@axpecter/lync 2.3.2 → 3.0.0

package/src/internal/Channel.luau

@@ -1,390 +0,0 @@
---!strict
---!native
--- Per-channel buffer state with MSB batch framing, XOR delta, timestamps.
-
-local Base = require(script.Parent.Parent.codec.Base)
-local Buf = require(script.Parent.Parent.util.Buffer)
-local Constants = require(script.Parent.Parent.util.Constants)
-local Log = require(script.Parent.Parent.util.Log)
-local Types = require(script.Parent.Parent.Types)
-local Varint = require(script.Parent.Parent.codec.primitive.Varint)
-
--- Constants --------------------------------------------------------------
-
-local TS_NONE = 0
-local TS_FRAME = 1
-local TS_OFFSET = 2
-local TS_FULL = 3
-
-local INITIAL_BUF = 1024
-local HEADER_BYTE = 1
-local FRAME_MSB = Constants.FRAME_MSB
-local U8_MAX = Constants.U8_MAX
-local U16_MAX = Constants.U16_MAX
-local MAX_BATCH_ITEMS = Constants.MAX_BATCH_ITEMS
-
--- 65.535s window so round((clock % win) * 1000) cannot overflow u16.
-local OFFSET_WIN = 65.535
-
-local TS_BYTES = table.freeze({
-    [TS_NONE] = 0,
-    [TS_FRAME] = 1,
-    [TS_OFFSET] = 2,
-    [TS_FULL] = 8,
-})
-
--- State ------------------------------------------------------------------
-
-local _timestampsEnabled = false
-local _statsEnabled = false
-
--- Refreshed by updateTimestamp once per flush.
-local _frameCounter = 0
-local _offsetMs = 0
-local _clock = 0.0
-
-local EMPTY_REFS = table.freeze({}) :: { Instance }
-
--- Private ----------------------------------------------------------------
-
-local alloc = Base.alloc
-local ensure = Base.ensure
-local band = bit32.band
-local bor = bit32.bor
-local bufCopy = buffer.copy
-local writeu8 = buffer.writeu8
-local writeu16 = buffer.writeu16
-local writef64 = buffer.writef64
-local round = math.round
-local osClock = os.clock
-
-local function writeTimestamp(b: buffer, off: number, mode: number): ()
-    if mode == TS_FRAME then
-        writeu8(b, off, _frameCounter)
-    elseif mode == TS_OFFSET then
-        writeu16(b, off, _offsetMs)
-    elseif mode == TS_FULL then
-        writef64(b, off, _clock)
-    end
-end
-
---[[
-    Single -> multi upgrade. Patches the previously-emitted single-item
-    header, splices a 2-byte count cell after the timestamp, and shifts the
-    payload right. Hot only when a packet fires twice in a row to the same
-    channel without an intervening flush.
-]]
-local function upgradeSingleToMulti(ch: Types.ChannelState, regId: number, headerSize: number): ()
-    local headerPos = ch.singlePos
-    writeu8(ch.buff, headerPos, regId)
-
-    local afterTs = headerPos + headerSize
-    local cursor = ch.cursor
-    local payloadLen = cursor - afterTs
-    ensure(ch, 2)
-    -- Re-bind: ensure() may have realloced the buffer.
-    local b = ch.buff
-    bufCopy(b, afterTs + 2, b, afterTs, payloadLen)
-
-    ch.countPos = afterTs
-    writeu16(b, afterTs, 0)
-    ch.cursor = cursor + 2
-    ch.singleMode = false
-end
-
--- itemCount bump is left to the caller, AFTER the body write succeeds.
-local function openOrUpgrade(ch: Types.ChannelState, reg: Types.Registration): ()
-    if reg.id ~= ch.lastId or ch.itemCount >= MAX_BATCH_ITEMS then
-        reg._openFn(ch, reg.id)
-    elseif ch.singleMode then
-        upgradeSingleToMulti(ch, reg.id, reg.headerSize)
-    end
-end
-
-local function spliceEncoded(ch: Types.ChannelState, payload: buffer, payloadLen: number): ()
-    local cursor = ch.cursor
-    if cursor + payloadLen > ch.size then
-        alloc(ch, payloadLen)
-    end
-    bufCopy(ch.buff, cursor, payload, 0, payloadLen)
-    ch.cursor = cursor + payloadLen
-end
-
---[[
-    Hot-swapped by enableStats() so the per-item dispatch avoids a runtime
-    branch on the stats flag. itemCount bumps AFTER codec.write so a
-    throwing codec leaves the count consistent with the buffer.
-]]
-local writeBatchPlain: (Types.ChannelState, Types.Registration, any) -> ()
-local writeBatchStats: (Types.ChannelState, Types.Registration, any) -> ()
-
-writeBatchPlain = function(ch: Types.ChannelState, reg: Types.Registration, data: any): ()
-    openOrUpgrade(ch, reg)
-    reg.codec.write(ch, data)
-    ch.itemCount += 1
-end
-
-writeBatchStats = function(ch: Types.ChannelState, reg: Types.Registration, data: any): ()
-    openOrUpgrade(ch, reg)
-    local before = ch.cursor
-    reg.codec.write(ch, data)
-    ch.itemCount += 1
-    reg.bytesSent += ch.cursor - before
-end
-
---[[
-    Splice a pre-encoded payload into the channel. Used by Packet.broadcast
-    to encode the codec output once per fanout instead of N times.
-]]
-local writeBatchEncodedPlain: (Types.ChannelState, Types.Registration, buffer, number) -> ()
-local writeBatchEncodedStats: (Types.ChannelState, Types.Registration, buffer, number) -> ()
-
-writeBatchEncodedPlain = function(
-    ch: Types.ChannelState,
-    reg: Types.Registration,
-    payload: buffer,
-    payloadLen: number
-): ()
-    openOrUpgrade(ch, reg)
-    spliceEncoded(ch, payload, payloadLen)
-    ch.itemCount += 1
-end
-
-writeBatchEncodedStats = function(
-    ch: Types.ChannelState,
-    reg: Types.Registration,
-    payload: buffer,
-    payloadLen: number
-): ()
-    openOrUpgrade(ch, reg)
-    spliceEncoded(ch, payload, payloadLen)
-    ch.itemCount += 1
-    reg.bytesSent += payloadLen
-end
-
--- Public -----------------------------------------------------------------
-
--- Module table is intentionally unfrozen: enableStats() hot-swaps writeBatch.
-local Channel = {}
-
-Channel.TS_NONE = TS_NONE
-Channel.TS_FRAME = TS_FRAME
-Channel.TS_OFFSET = TS_OFFSET
-Channel.TS_FULL = TS_FULL
-
-function Channel.create(): Types.ChannelState
-    return {
-        buff = buffer.create(INITIAL_BUF),
-        cursor = 0,
-        size = INITIAL_BUF,
-        refs = {},
-        refCount = 0,
-        lastId = -1,
-        countPos = -1,
-        itemCount = 0,
-        singleMode = false,
-        singlePos = 0,
-        deltas = {},
-        prevDump = nil,
-        prevDumpLen = 0,
-        currentPacket = nil,
-    }
-end
-
-function Channel.writeByte(ch: Types.ChannelState, byte: number): ()
-    local cursor = ch.cursor
-    if cursor + HEADER_BYTE > ch.size then
-        alloc(ch, HEADER_BYTE)
-    end
-    writeu8(ch.buff, cursor, byte)
-    ch.cursor = cursor + HEADER_BYTE
-end
-
--- Append `value` to the sidecar refs, write its 1-based u16 index.
-function Channel.pushRef(ch: Types.ChannelState, value: any): ()
-    local idx = ch.refCount + 1
-    Log.assert(idx <= U16_MAX, "ref overflow, max 65535")
-    ch.refs[idx] = value
-    ch.refCount = idx
-
-    local cursor = ch.cursor
-    if cursor + 2 > ch.size then
-        alloc(ch, 2)
-    end
-    writeu16(ch.buff, cursor, idx)
-    ch.cursor = cursor + 2
-end
-
---[[
-    Per-flush reset. Preserves prevDump/prevDumpLen (XOR baseline) and
-    ch.deltas (delta caches): both must outlive flushes for the same owner.
-]]
-function Channel.reset(ch: Types.ChannelState): ()
-    ch.cursor = 0
-    ch.lastId = -1
-    ch.countPos = -1
-    ch.itemCount = 0
-    ch.singleMode = false
-    ch.singlePos = 0
-    ch.currentPacket = nil
-    if ch.refCount > 0 then
-        table.clear(ch.refs)
-        ch.refCount = 0
-    end
-end
-
---[[
-    Full reset including XOR baseline and delta caches. Pool.acquire calls
-    this so a recycled state cannot leak the previous owner's baseline.
-]]
-function Channel.fullReset(ch: Types.ChannelState): ()
-    Channel.reset(ch)
-    ch.prevDump = nil
-    ch.prevDumpLen = 0
-    table.clear(ch.deltas)
-end
-
---[[
-    Resolve the batch-open closure for a given timestamp mode and packet
-    name. Returned function seals the prior batch, writes the single-mode
-    header [0x80 | id] + optional timestamp, and records the cursor so
-    writeBatch can upgrade single -> multi later.
-]]
-function Channel.resolveOpenFn(
-    timestampMode: number,
-    name: string
-): (ch: Types.ChannelState, id: number) -> ()
-    local headerLen = HEADER_BYTE + TS_BYTES[timestampMode]
-
-    return function(ch: Types.ChannelState, id: number): ()
-        --[[
-            Inline sealCount: this is the only call site that can take the
-            multi-mode branch on a non-fresh channel.
-        ]]
-        if ch.lastId >= 0 and not ch.singleMode then
-            writeu16(ch.buff, ch.countPos, ch.itemCount)
-        end
-
-        ch.currentPacket = name
-        ch.lastId = id
-        ch.itemCount = 0
-
-        local cursor = ch.cursor
-        if cursor + headerLen > ch.size then
-            alloc(ch, headerLen)
-        end
-        local b = ch.buff
-        writeu8(b, cursor, bor(FRAME_MSB, id))
-        writeTimestamp(b, cursor + 1, timestampMode)
-
-        ch.singleMode = true
-        ch.singlePos = cursor
-        ch.cursor = cursor + headerLen
-    end
-end
-
-Channel.writeBatch = writeBatchPlain
-Channel.writeBatchEncoded = writeBatchEncodedPlain
-
---[[
-    Every caller (Server.flushReliable / flushUnreliable, Client.flush)
-    pre-checks `ch.cursor > 0`, so cursor here is always positive.
-]]
-function Channel.sealAndDump(ch: Types.ChannelState): (buffer, { Instance }, number, number)
-    if ch.lastId >= 0 and not ch.singleMode then
-        writeu16(ch.buff, ch.countPos, ch.itemCount)
-    end
-
-    local cursor = ch.cursor
-    local snapshot = buffer.create(cursor)
-    bufCopy(snapshot, 0, ch.buff, 0, cursor)
-
-    local refCount = ch.refCount
-    local refs = if refCount > 0 then table.clone(ch.refs) else EMPTY_REFS
-    return snapshot, refs, cursor, refCount
-end
-
-Channel.xorApply = Buf.xorApply
-
---[[
-    Query frame. MSB on the id byte = nil response; cleared = payload follows.
-    Correlation IDs are varint-encoded.
-]]
-function Channel.writeQuery(
-    ch: Types.ChannelState,
-    id: number,
-    correlationId: number,
-    codec: Types.InternalCodec<any>?,
-    data: any
-): ()
-    if ch.lastId >= 0 and not ch.singleMode then
-        writeu16(ch.buff, ch.countPos, ch.itemCount)
-    end
-    --[[
-        lastId = -1 forces the next writeBatch to call _openFn (which resets
-        singleMode). Every other reader of singleMode (writeQuery,
-        sealAndDump) is gated by `lastId >= 0` first, so stamping singleMode
-        here would never be observed before the next reset overwrites it.
-    ]]
-    ch.lastId = -1
-
-    local hasPayload = codec ~= nil and data ~= nil
-    local headerByte = if hasPayload then id else bor(FRAME_MSB, id)
-
-    local cursor = ch.cursor
-    if cursor + 1 > ch.size then
-        alloc(ch, 1)
-    end
-    writeu8(ch.buff, cursor, headerByte)
-    ch.cursor = cursor + 1
-
-    Varint.write(ch, correlationId)
-    if hasPayload then
-        (codec :: Types.InternalCodec<any>).write(ch, data)
-    end
-end
-
--- Configuration ----------------------------------------------------------
-
-function Channel.setMaxSize(bytes: number): ()
-    Base.setMaxSize(bytes)
-end
-
-function Channel.updateTimestamp(): ()
-    _frameCounter = band(_frameCounter + 1, U8_MAX)
-    local now = osClock()
-    _offsetMs = round((now % OFFSET_WIN) * 1000)
-    _clock = now
-end
-
-function Channel.enableTimestamps(): ()
-    _timestampsEnabled = true
-end
-
-function Channel.hasTimestamps(): boolean
-    return _timestampsEnabled
-end
-
-function Channel.enableStats(): ()
-    _statsEnabled = true
-    Channel.writeBatch = writeBatchStats
-    Channel.writeBatchEncoded = writeBatchEncodedStats
-end
-
-function Channel.statsEnabled(): boolean
-    return _statsEnabled
-end
-
--- Module-level config + timestamp counters. Distinct from Channel.reset(ch).
-function Channel.resetGlobals(): ()
-    Base.reset()
-    _timestampsEnabled = false
-    _statsEnabled = false
-    _frameCounter = 0
-    _offsetMs = 0
-    _clock = 0.0
-    Channel.writeBatch = writeBatchPlain
-    Channel.writeBatchEncoded = writeBatchEncodedPlain
-end
-
-return Channel

package/src/internal/Middleware.luau

@@ -1,100 +0,0 @@
---!strict
---!optimize 2
--- Ordered intercept chains for send/receive/drop hooks.
-
-local Signal = require(script.Parent.Parent.api.Signal)
-local Types = require(script.Parent.Parent.Types)
-
--- State ------------------------------------------------------------------
-
-local _sendSignal = Signal.create()
-local _receiveSignal = Signal.create()
-local _dropSignal = Signal.create()
-
--- Private ----------------------------------------------------------------
-
--- Mirrors Signal's STATE_DISCONNECTED. Entries in this state are mid-fire disconnects.
-local STATE_DISCONNECTED = 0
-
---[[
-    Snapshot before iterating: a handler can disconnect itself or others,
-    and a fresh chain pull would skip or double-fire entries depending on
-    swap direction. Snapshotting locks the per-frame view.
-]]
-local function runChain(
-    signal: { _count: number, _entries: { any } },
-    value: any,
-    name: string,
-    player: Player?
-): any
-    local count = signal._count
-    if count == 0 then
-        return value
-    end
-
-    local entries = signal._entries
-    local snapshot = table.create(count)
-    table.move(entries, 1, count, 1, snapshot)
-
-    local result = value
-    for i = 1, count do
-        local entry = snapshot[i]
-        if entry._state ~= STATE_DISCONNECTED then
-            local returned = entry.fn(result, name, player)
-            -- Hooks return non-nil to replace the value; nil keeps the prior result.
-            if returned ~= nil then
-                result = returned
-            end
-        end
-    end
-    return result
-end
-
--- Public -----------------------------------------------------------------
-
-local Middleware = {}
-
-function Middleware.onSend(fn: (data: any, name: string, player: Player?) -> any): Types.Connection
-    return _sendSignal:connect(fn)
-end
-
-function Middleware.onReceive(
-    fn: (data: any, name: string, player: Player?) -> any
-): Types.Connection
-    return _receiveSignal:connect(fn)
-end
-
-function Middleware.onDrop(
-    fn: (player: Player, reason: string, name: string, data: any?) -> ()
-): Types.Connection
-    return _dropSignal:connect(fn)
-end
-
-function Middleware.runSend(data: any, name: string, player: Player?): any
-    return runChain(_sendSignal, data, name, player)
-end
-
-function Middleware.runReceive(data: any, name: string, player: Player?): any
-    return runChain(_receiveSignal, data, name, player)
-end
-
-function Middleware.fireDrop(player: Player, reason: string, name: string, data: any?): ()
-    _dropSignal:fireSync(player, reason, name, data)
-end
-
--- Hot-path callers gate on these to skip runChain's snapshot allocation.
-function Middleware.hasSendHooks(): boolean
-    return _sendSignal:hasListeners()
-end
-
-function Middleware.hasReceiveHooks(): boolean
-    return _receiveSignal:hasListeners()
-end
-
-function Middleware.reset(): ()
-    _sendSignal = Signal.create()
-    _receiveSignal = Signal.create()
-    _dropSignal = Signal.create()
-end
-
-return table.freeze(Middleware)

package/src/internal/Pool.luau

@@ -1,65 +0,0 @@
---!strict
---!optimize 2
--- ChannelState pool. Acquire fullResets to wipe prior owner state.
-
-local Channel = require(script.Parent.Channel)
-local Log = require(script.Parent.Parent.util.Log)
-local Types = require(script.Parent.Parent.Types)
-
--- Constants --------------------------------------------------------------
-
-local DEFAULT_SIZE = 16
-
--- State ------------------------------------------------------------------
-
-local _stack: { Types.ChannelState } = {}
-local _depth = 0
-local _maxSize = DEFAULT_SIZE
-
--- Public -----------------------------------------------------------------
-
-local Pool = {}
-
--- fullReset wipes the prior owner's XOR baseline and delta caches.
-function Pool.acquire(): Types.ChannelState
-    if _depth > 0 then
-        local ch = _stack[_depth]
-        _stack[_depth] = nil
-        _depth -= 1
-        Channel.fullReset(ch)
-        return ch
-    end
-    return Channel.create()
-end
-
--- Above the cap, drop on the floor; the GC reclaims the buffer.
-function Pool.release(ch: Types.ChannelState): ()
-    if _depth >= _maxSize then
-        return
-    end
-    _depth += 1
-    _stack[_depth] = ch
-end
-
-function Pool.setMaxSize(size: number): ()
-    if size < 0 then
-        Log.error(`size must be non-negative, got {size}`)
-    end
-    _maxSize = size
-    while _depth > _maxSize do
-        _stack[_depth] = nil
-        _depth -= 1
-    end
-end
-
-function Pool.count(): number
-    return _depth
-end
-
-function Pool.reset(): ()
-    table.clear(_stack)
-    _depth = 0
-    _maxSize = DEFAULT_SIZE
-end
-
-return table.freeze(Pool)

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)