@axpecter/lync 1.4.3 → 1.5.0

package/src/codec/primitive/Varint.luau

@@ -2,14 +2,14 @@
 --!native
 -- LEB128 variable-length integer encoding and decoding.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
 local CONT = 0x80
 local MASK = 0x7F
@@ -21,56 +21,56 @@ local bor = bit32.bor
 local rshift = bit32.rshift
 local lshift = bit32.lshift
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Varint = {}
 
-function Varint.write (ch: ChannelState, value: number): ()
+function Varint.write(ch: ChannelState, value: number): ()
     if value < 0 or value > MAX_VALUE then
-        error (`[Lync] Varint value out of range: {value}`)
+        error(`[Lync] Varint value out of range: {value}`)
     end
 
-    -- Fast path: ~80%+ of real-world varints are single-byte (lengths, counts)
+    -- Fast path: ~80%+ of real-world varints are single-byte(lengths, counts)
     if value < CONT then
         local c = ch.cursor
         if c + 1 > ch.size then
-            alloc (ch, 1)
+            alloc(ch, 1)
         end
-        buffer.writeu8 (ch.buff, c, value)
+        buffer.writeu8(ch.buff, c, value)
         ch.cursor = c + 1
         return
     end
 
     local c = ch.cursor
     if c + MAX_BYTES > ch.size then
-        alloc (ch, MAX_BYTES)
+        alloc(ch, MAX_BYTES)
     end
     local b = ch.buff
 
     while value >= CONT do
-        buffer.writeu8 (b, c, bor (band (value, MASK), CONT))
-        value = rshift (value, 7)
+        buffer.writeu8(b, c, bor(band(value, MASK), CONT))
+        value = rshift(value, 7)
         c += 1
     end
 
-    buffer.writeu8 (b, c, value)
+    buffer.writeu8(b, c, value)
     ch.cursor = c + 1
 end
 
 -- Reads rely on buffer.readu8 throwing on OOB. MAX_BYTES rejects malformed loops.
-function Varint.read (src: buffer, pos: number): (number, number)
+function Varint.read(src: buffer, pos: number): (number, number)
     local result = 0
 
     for offset = 0, MAX_BYTES - 1 do
-        local byte = buffer.readu8 (src, pos + offset)
-        result = bor (result, lshift (band (byte, MASK), offset * 7))
+        local byte = buffer.readu8(src, pos + offset)
+        result = bor(result, lshift(band(byte, MASK), offset * 7))
 
-        if band (byte, CONT) == 0 then
+        if band(byte, CONT) == 0 then
             return result, offset + 1
         end
     end
 
-    error (`[Lync] Varint exceeds {MAX_BYTES} bytes at position {pos}`)
+    error(`[Lync] Varint exceeds {MAX_BYTES} bytes at position {pos}`)
 end
 
-return table.freeze (Varint)
+return table.freeze(Varint)

package/src/init.luau

@@ -2,97 +2,117 @@
 --!optimize 2
 -- Public API.
 
-local RunService = game:GetService ("RunService")
+local RunService = game:GetService("RunService")
 
 -- Codec: primitive
-local BoolCodec = require (script.codec.primitive.Bool)
-local Float16 = require (script.codec.primitive.Float16)
-local NumberCodec = require (script.codec.primitive.Number)
+local BoolCodec = require(script.codec.primitive.Bool)
+local Float16 = require(script.codec.primitive.Float16)
+local NumberCodec = require(script.codec.primitive.Number)
 
 -- Codec: datatype
-local BufferCodec = require (script.codec.datatype.Buffer)
-local CFrameCodec = require (script.codec.datatype.CFrame)
-local ColorCodec = require (script.codec.datatype.Color)
-local InstanceCodec = require (script.codec.datatype.Instance)
-local IntVectorCodec = require (script.codec.datatype.IntVector)
-local NumberRangeCodec = require (script.codec.datatype.NumberRange)
-local RayCodec = require (script.codec.datatype.Ray)
-local RectCodec = require (script.codec.datatype.Rect)
-local RegionCodec = require (script.codec.datatype.Region)
-local SequenceCodec = require (script.codec.datatype.Sequence)
-local StringCodec = require (script.codec.datatype.String)
-local UDimCodec = require (script.codec.datatype.UDim)
-local VectorCodec = require (script.codec.datatype.Vector)
+local BufferCodec = require(script.codec.datatype.Buffer)
+local CFrameCodec = require(script.codec.datatype.CFrame)
+local ColorCodec = require(script.codec.datatype.Color)
+local InstanceCodec = require(script.codec.datatype.Instance)
+local IntVectorCodec = require(script.codec.datatype.IntVector)
+local NumberRangeCodec = require(script.codec.datatype.NumberRange)
+local RayCodec = require(script.codec.datatype.Ray)
+local RectCodec = require(script.codec.datatype.Rect)
+local RegionCodec = require(script.codec.datatype.Region)
+local SequenceCodec = require(script.codec.datatype.Sequence)
+local StringCodec = require(script.codec.datatype.String)
+local UDimCodec = require(script.codec.datatype.UDim)
+local VectorCodec = require(script.codec.datatype.Vector)
 
 -- Codec: composite
-local Array = require (script.codec.composite.Array)
-local Map = require (script.codec.composite.Map)
-local Optional = require (script.codec.composite.Optional)
-local Struct = require (script.codec.composite.Struct)
-local Tagged = require (script.codec.composite.Tagged)
-local Tuple = require (script.codec.composite.Tuple)
+local Array = require(script.codec.composite.Array)
+local Map = require(script.codec.composite.Map)
+local Optional = require(script.codec.composite.Optional)
+local Struct = require(script.codec.composite.Struct)
+local Tagged = require(script.codec.composite.Tagged)
+local Tuple = require(script.codec.composite.Tuple)
 
 -- Codec: meta
-local Auto = require (script.codec.meta.Auto)
-local Bitfield = require (script.codec.meta.Bitfield)
-local Custom = require (script.codec.meta.Custom)
-local EnumCodec = require (script.codec.meta.Enum)
-local Nothing = require (script.codec.meta.Nothing)
-local Quantized = require (script.codec.meta.Quantized)
-local Unknown = require (script.codec.meta.Unknown)
+local Auto = require(script.codec.meta.Auto)
+local Bitfield = require(script.codec.meta.Bitfield)
+local Custom = require(script.codec.meta.Custom)
+local EnumCodec = require(script.codec.meta.Enum)
+local Nothing = require(script.codec.meta.Nothing)
+local Quantized = require(script.codec.meta.Quantized)
+local Unknown = require(script.codec.meta.Unknown)
 
 -- Internal
-local Channel = require (script.internal.Channel)
-local Middleware = require (script.internal.Middleware)
-local Pool = require (script.internal.Pool)
+local Channel = require(script.internal.Channel)
+local Middleware = require(script.internal.Middleware)
+local Pool = require(script.internal.Pool)
 
 -- Transport
-local Client = require (script.transport.Client)
-local Gate = require (script.transport.Gate)
-local Server = require (script.transport.Server)
+local Client = require(script.transport.Client)
+local Gate = require(script.transport.Gate)
+local Server = require(script.transport.Server)
 
 -- API
-local Group = require (script.api.Group)
-local Namespace = require (script.api.Namespace)
-local Packet = require (script.api.Packet)
-local Query = require (script.api.Query)
-local Scope = require (script.api.Scope)
+local GroupModule = require(script.api.Group)
+local NamespaceModule = require(script.api.Namespace)
+local PacketModule = require(script.api.Packet)
+local QueryModule = require(script.api.Query)
+local ScopeModule = require(script.api.Scope)
+local SignalModule = require(script.api.Signal)
 
--- Constants ----------------------------------------------------------
+-- Type re-exports -----------------------------------------------------
 
-local ALL = table.freeze ({ _tag = "all" })
+local Types = require(script.Types)
 
--- Private ------------------------------------------------------------
+export type Codec<T> = Types.Codec<T>
+export type InternalCodec<T> = Types.InternalCodec<T>
+export type Connection = Types.Connection
+export type RateLimitConfig = Types.RateLimitConfig
+export type PacketConfig<T> = Types.PacketConfig<T>
+export type QueryConfig<R, S> = Types.QueryConfig<R, S>
 
-local function except (...: any): any
-    local count = select ("#", ...)
+export type Packet = PacketModule.Packet
+export type Query = QueryModule.Query
+export type Group = GroupModule.Group
+export type Scope = ScopeModule.Scope
+export type Namespace = NamespaceModule.Namespace
+export type Signal = SignalModule.Signal
+export type NamespaceConfig = Types.NamespaceConfig
+
+-- Constants -----------------------------------------------------------
+
+local ALL = table.freeze({ _tag = "all" })
+
+-- Private -------------------------------------------------------------
+
+local function except(...: any): any
+    local count = select("#", ...)
     local set = {} :: { [Player]: true }
     for i = 1, count do
-        set[select (i, ...)] = true
+        set[select(i, ...)] = true
     end
     return { _tag = "except", _set = set }
 end
 
-local function start (): ()
-    if RunService:IsServer () then
-        Server.start ()
+local function start(): ()
+    if RunService:IsServer() then
+        Server.start()
     else
-        Client.start ()
+        Client.start()
     end
 end
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Lync = {
-    VERSION = "1.4.2",
+    VERSION = "1.5.0",
 
     -- Lifecycle
     start = start,
 
     -- Definition
-    definePacket = Packet.define,
-    defineQuery = Query.define,
-    defineNamespace = Namespace.define,
+    definePacket = PacketModule.define,
+    defineQuery = QueryModule.define,
+    defineNamespace = NamespaceModule.define,
 
     -- Primitives
     u8 = NumberCodec.u8,
@@ -162,19 +182,19 @@ local Lync = {
     DROP = Middleware.DROP,
 
     -- Groups
-    createGroup = Group.create,
+    createGroup = GroupModule.create,
 
     -- Scope
-    scope = Scope.create,
+    scope = ScopeModule.create,
 
-    -- Configuration (call before start)
+    -- Configuration(call before start)
     setChannelMaxSize = Channel.setMaxSize,
     setValidationDepth = Gate.setMaxDepth,
     setPoolSize = Pool.setMaxSize,
 
     -- Introspection
-    queryPendingCount = Query.pendingCount,
+    queryPendingCount = QueryModule.pendingCount,
 }
 
 Lync.default = Lync
-return table.freeze (Lync)
+return table.freeze(Lync)

package/src/internal/Baseline.luau

@@ -1,13 +1,13 @@
 --!strict
 --!optimize 2
--- Read-side baseline cache keyed by source (player or client sentinel).
+-- Read-side baseline cache keyed by source(player or client sentinel).
 
--- State --------------------------------------------------------------
+-- State ---------------------------------------------------------------
 
 local _readKey = false :: any
 local _readCaches = {} :: { [any]: { [number]: any } }
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Baseline = {}
 
@@ -16,16 +16,16 @@ local Baseline = {}
 -- cheap branch once deltas are first used in the session.
 Baseline.hasDelta = false
 
-function Baseline.setReadKey (key: any): ()
+function Baseline.setReadKey(key: any): ()
     _readKey = key
 end
 
-function Baseline.getCache (deltaId: number): any
+function Baseline.getCache(deltaId: number): any
     local map = _readCaches[_readKey]
     return map and map[deltaId]
 end
 
-function Baseline.setCache (deltaId: number, data: any): ()
+function Baseline.setCache(deltaId: number, data: any): ()
     if not Baseline.hasDelta then
         Baseline.hasDelta = true
     end
@@ -37,7 +37,7 @@ function Baseline.setCache (deltaId: number, data: any): ()
     map[deltaId] = data
 end
 
-function Baseline.clearSource (key: any): ()
+function Baseline.clearSource(key: any): ()
     _readCaches[key] = nil
 end
 

package/src/internal/Channel.luau

@@ -2,11 +2,11 @@
 --!native
 -- Per-channel buffer state with batching, delta cache, frame XOR.
 
-local Types = require (script.Parent.Parent.Types)
+local Types = require(script.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
 local INITIAL_SIZE = 1024
 local MAX_SIZE = 262144
@@ -18,7 +18,7 @@ local band32 = bit32.band
 local countlz = bit32.countlz
 local lshift = bit32.lshift
 
--- State --------------------------------------------------------------
+-- State ---------------------------------------------------------------
 
 local _maxSize = MAX_SIZE
 
@@ -26,25 +26,25 @@ local _maxSize = MAX_SIZE
 -- serializers may overwrite before the error fires.
 local _currentPacket = ""
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Channel = {}
 
 -- Override the maximum buffer size. Call before start(). Range: 4096–1048576.
-function Channel.setMaxSize (bytes: number): ()
+function Channel.setMaxSize(bytes: number): ()
     if bytes < 4096 or bytes > 1048576 then
-        error (`[Lync] Channel max size must be 4096–1048576, got {bytes}`)
+        error(`[Lync] Channel max size must be 4096–1048576, got {bytes}`)
     end
     _maxSize = bytes
 end
 
-function Channel.getMaxSize (): number
+function Channel.getMaxSize(): number
     return _maxSize
 end
 
-function Channel.create (): ChannelState
+function Channel.create(): ChannelState
     return {
-        buff = buffer.create (INITIAL_SIZE),
+        buff = buffer.create(INITIAL_SIZE),
         cursor = 0,
         size = INITIAL_SIZE,
         refs = {},
@@ -57,21 +57,21 @@ function Channel.create (): ChannelState
 end
 
 -- Grows the channel buffer to fit the requested bytes. Power-of-two sizing.
-function Channel.alloc (ch: ChannelState, bytes: number): ()
+function Channel.alloc(ch: ChannelState, bytes: number): ()
     local needed = ch.cursor + bytes
     if needed <= ch.size then
         return
     end
     if needed > _maxSize then
-        error (
-            `[Lync] Channel overflow writing "{_currentPacket}": {needed} bytes > {_maxSize} max (call Channel.setMaxSize to raise)`
+        error(
+            `[Lync] Channel overflow writing "{_currentPacket}": {needed} bytes > {_maxSize} max(call Channel.setMaxSize to raise)`
         )
     end
 
-    local newSize = lshift (1, 32 - countlz (needed - 1))
+    local newSize = lshift(1, 32 - countlz(needed - 1))
 
-    local newBuff = buffer.create (newSize)
-    buffer.copy (newBuff, 0, ch.buff, 0, ch.cursor)
+    local newBuff = buffer.create(newSize)
+    buffer.copy(newBuff, 0, ch.buff, 0, ch.cursor)
     ch.buff = newBuff
     ch.size = newSize
 end
@@ -79,38 +79,38 @@ end
 local alloc = Channel.alloc
 
 -- Seals the open batch header and returns a snapshot of the buffer + refs.
-function Channel.sealAndDump (ch: ChannelState): (buffer, { Instance })
+function Channel.sealAndDump(ch: ChannelState): (buffer, { Instance })
     if ch.lastId >= 0 then
-        buffer.writeu16 (ch.buff, ch.countPos, ch.itemCount)
+        buffer.writeu16(ch.buff, ch.countPos, ch.itemCount)
         ch.lastId = -1
         ch.countPos = 0
         ch.itemCount = 0
     end
 
     local cur = ch.cursor
-    local out = buffer.create (cur)
-    buffer.copy (out, 0, ch.buff, 0, cur)
+    local out = buffer.create(cur)
+    buffer.copy(out, 0, ch.buff, 0, cur)
 
     local refs = ch.refs
-    return out, if #refs > 0 then table.clone (refs) else {}
+    return out, if #refs > 0 then table.clone(refs) else {}
 end
 
 -- Sets the packet name for overflow diagnostics.
-function Channel.setCurrentPacket (name: string): ()
+function Channel.setCurrentPacket(name: string): ()
     _currentPacket = name
 end
 
 -- Writes a single value into the batch. Opens a new header on ID change or overflow.
-function Channel.writeBatch (ch: ChannelState, id: number, name: string, codec: any, data: any): ()
+function Channel.writeBatch(ch: ChannelState, id: number, name: string, codec: any, data: any): ()
     if id ~= ch.lastId or ch.itemCount >= MAX_BATCH then
         if ch.lastId >= 0 then
-            buffer.writeu16 (ch.buff, ch.countPos, ch.itemCount)
+            buffer.writeu16(ch.buff, ch.countPos, ch.itemCount)
         end
 
         _currentPacket = name
-        alloc (ch, 3)
+        alloc(ch, 3)
         local c = ch.cursor
-        buffer.writeu8 (ch.buff, c, id)
+        buffer.writeu8(ch.buff, c, id)
         ch.countPos = c + 1
         ch.cursor = c + 3
         ch.lastId = id
@@ -118,11 +118,11 @@ function Channel.writeBatch (ch: ChannelState, id: number, name: string, codec:
     end
 
     ch.itemCount += 1
-    codec.write (ch, data)
+    codec.write(ch, data)
 end
 
 -- Appends pre-serialized bytes into a batch. Used by broadcast fan-out.
-function Channel.writeBatchRaw (
+function Channel.writeBatchRaw(
     ch: ChannelState,
     id: number,
     src: buffer,
@@ -131,12 +131,12 @@ function Channel.writeBatchRaw (
 ): ()
     if id ~= ch.lastId or ch.itemCount >= MAX_BATCH then
         if ch.lastId >= 0 then
-            buffer.writeu16 (ch.buff, ch.countPos, ch.itemCount)
+            buffer.writeu16(ch.buff, ch.countPos, ch.itemCount)
         end
 
-        alloc (ch, 3)
+        alloc(ch, 3)
         local c = ch.cursor
-        buffer.writeu8 (ch.buff, c, id)
+        buffer.writeu8(ch.buff, c, id)
         ch.countPos = c + 1
         ch.cursor = c + 3
         ch.lastId = id
@@ -146,20 +146,20 @@ function Channel.writeBatchRaw (
     ch.itemCount += 1
 
     if srcLen > 0 then
-        alloc (ch, srcLen)
-        buffer.copy (ch.buff, ch.cursor, src, 0, srcLen)
+        alloc(ch, srcLen)
+        buffer.copy(ch.buff, ch.cursor, src, 0, srcLen)
         ch.cursor += srcLen
     end
 
     if srcRefs then
         local refs = ch.refs
-        table.move (srcRefs, 1, #srcRefs, #refs + 1, refs)
+        table.move(srcRefs, 1, #srcRefs, #refs + 1, refs)
     end
 end
 
-local function sealOpen (ch: ChannelState): ()
+local function sealOpen(ch: ChannelState): ()
     if ch.lastId >= 0 then
-        buffer.writeu16 (ch.buff, ch.countPos, ch.itemCount)
+        buffer.writeu16(ch.buff, ch.countPos, ch.itemCount)
         ch.lastId = -1
         ch.countPos = 0
         ch.itemCount = 0
@@ -168,10 +168,10 @@ end
 
 --[[
     Writes a query frame. Seals any open batch, then writes:
-        id (u8) + correlationId (u16) + status (u8)
+        id(u8) + correlationId(u16) + status(u8)
     Status 0 = payload follows. Status 1 = nil response.
 ]]
-function Channel.writeQuery (
+function Channel.writeQuery(
     ch: ChannelState,
     id: number,
     name: string,
@@ -180,61 +180,61 @@ function Channel.writeQuery (
     data: any?
 ): ()
     _currentPacket = name
-    sealOpen (ch)
+    sealOpen(ch)
 
-    alloc (ch, 4)
+    alloc(ch, 4)
     local c = ch.cursor
-    buffer.writeu8 (ch.buff, c, id)
-    buffer.writeu16 (ch.buff, c + 1, correlationId)
+    buffer.writeu8(ch.buff, c, id)
+    buffer.writeu16(ch.buff, c + 1, correlationId)
 
     if codec then
-        buffer.writeu8 (ch.buff, c + 3, 0)
+        buffer.writeu8(ch.buff, c + 3, 0)
         ch.cursor = c + 4
-        codec.write (ch, data)
+        codec.write(ch, data)
     else
-        buffer.writeu8 (ch.buff, c + 3, 1)
+        buffer.writeu8(ch.buff, c + 3, 1)
         ch.cursor = c + 4
     end
 end
 
 -- XOR current frame against previous. Produces zero-heavy output for deflate.
-function Channel.xorApply (current: buffer, previous: buffer?): buffer
-    local curLen = buffer.len (current)
+function Channel.xorApply(current: buffer, previous: buffer?): buffer
+    local curLen = buffer.len(current)
     if not previous then
         return current
     end
 
-    local prevLen = buffer.len (previous :: buffer)
+    local prevLen = buffer.len(previous :: buffer)
     if prevLen == 0 then
         return current
     end
 
-    local result = buffer.create (curLen)
-    local overlap = min (curLen, prevLen)
+    local result = buffer.create(curLen)
+    local overlap = min(curLen, prevLen)
     local prev = previous :: buffer
 
-    local aligned = band32 (overlap, 0xFFFFFFFC)
+    local aligned = band32(overlap, 0xFFFFFFFC)
     for i = 0, aligned - 4, 4 do
-        buffer.writeu32 (result, i, bxor (buffer.readu32 (current, i), buffer.readu32 (prev, i)))
+        buffer.writeu32(result, i, bxor(buffer.readu32(current, i), buffer.readu32(prev, i)))
     end
 
     for i = aligned, overlap - 1 do
-        buffer.writeu8 (result, i, bxor (buffer.readu8 (current, i), buffer.readu8 (prev, i)))
+        buffer.writeu8(result, i, bxor(buffer.readu8(current, i), buffer.readu8(prev, i)))
     end
 
     if curLen > overlap then
-        buffer.copy (result, overlap, current, overlap, curLen - overlap)
+        buffer.copy(result, overlap, current, overlap, curLen - overlap)
     end
 
     return result
 end
 
-function Channel.reset (ch: ChannelState): ()
+function Channel.reset(ch: ChannelState): ()
     ch.cursor = 0
     ch.lastId = -1
     ch.countPos = 0
     ch.itemCount = 0
-    table.clear (ch.refs)
+    table.clear(ch.refs)
 end
 
-return table.freeze (Channel)
+return table.freeze(Channel)