@axpecter/lync 2.1.2 → 2.2.1

package/src/codec/composite/Tuple.luau

@@ -1,15 +1,15 @@
 --!strict
 --!optimize 2
--- Positional ordered codec. Like struct but indexed, not keyed.
+-- Positional ordered codec. Like struct but indexed.
 
 local Base = require(script.Parent.Parent.Base)
 local Types = require(script.Parent.Parent.Parent.Types)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Tuple = {}
 
@@ -20,46 +20,41 @@ function Tuple.define(...: Types.InternalCodec<any>): Types.InternalCodec<any>
         error("[Lync] Lync.tuple: requires at least one codec")
     end
 
-    -- Check if all codecs are direct
-    local allDirect = true
-    local totalSize = 0
-    local hasUnknown = false
-
+    local allDirect, totalSize, hasUnknown = true, 0, false
     for i = 1, count do
-        local c = codecs[i] :: any
+        local c = codecs[i]
         if c._hasUnknown then
             hasUnknown = true
         end
         if not c._size or not c._directWrite or not c._directRead then
             allDirect = false
-        else
+        elseif allDirect then
             totalSize += c._size
         end
     end
-
     table.freeze(codecs)
 
     if allDirect then
-        -- Build precomputed offsets
         local offsets = table.create(count)
         local directWrites = table.create(count)
         local directReads = table.create(count)
         local cursor = 0
 
         for i = 1, count do
-            local c = codecs[i] :: any
+            local c = codecs[i]
             offsets[i] = cursor
             directWrites[i] = c._directWrite
             directReads[i] = c._directRead
-            cursor += c._size
+            cursor += c._size :: number
         end
-
         table.freeze(offsets)
         table.freeze(directWrites)
         table.freeze(directReads)
 
-        local codec: any = {
+        local codec: Types.InternalCodec<any> = {
             _size = totalSize,
+            _isTuple = true,
+            _elements = codecs,
 
             _directWrite = function(b: buffer, off: number, value: any): ()
                 for i = 1, count do
@@ -95,15 +90,16 @@ function Tuple.define(...: Types.InternalCodec<any>): Types.InternalCodec<any>
                 return result, totalSize
             end,
         }
-
         if hasUnknown then
             codec._hasUnknown = true
         end
         return table.freeze(codec)
     end
 
-    -- Generic path
-    local codec: any = {
+    local codec: Types.InternalCodec<any> = {
+        _isTuple = true,
+        _elements = codecs,
+
         write = function(ch: Types.ChannelState, value: any): ()
             for i = 1, count do
                 codecs[i].write(ch, value[i])
@@ -121,7 +117,6 @@ function Tuple.define(...: Types.InternalCodec<any>): Types.InternalCodec<any>
             return result, total
         end,
     }
-
     if hasUnknown then
         codec._hasUnknown = true
     end

package/src/codec/datatype/Buffer.luau

@@ -6,68 +6,61 @@ local Base = require(script.Parent.Parent.Base)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
 local INLINE = Varint.INLINE_MAX
 
--- Public --------------------------------------------------------------
+local function writeBuffer(ch: Types.ChannelState, value: buffer): ()
+    local len = buffer.len(value)
+    local cursor = ch.cursor
 
-local BufferCodec = {}
+    if len <= INLINE then
+        if cursor + 1 + len > ch.size then
+            alloc(ch, 1 + len)
+        end
+        local b = ch.buff
+        buffer.writeu8(b, cursor, len)
+        if len > 0 then
+            buffer.copy(b, cursor + 1, value, 0, len)
+        end
+        ch.cursor = cursor + 1 + len
+        return
+    end
 
-BufferCodec.buff = table.freeze({
-    _typeCheck = "buffer",
+    Varint.write(ch, len)
+    cursor = ch.cursor
+    if cursor + len > ch.size then
+        alloc(ch, len)
+    end
+    buffer.copy(ch.buff, cursor, value, 0, len)
+    ch.cursor = cursor + len
+end
 
-    write = function(ch: Types.ChannelState, value: buffer): ()
-        local len = buffer.len(value)
-        local cursor = ch.cursor
+local function readBuffer(src: buffer, pos: number, _refs: { Instance }?): (buffer, number)
+    local len, lenBytes = Varint.readLengthPrefix(src, pos)
+    if len == 0 then
+        return buffer.create(0), lenBytes
+    end
 
-        if len <= INLINE then
-            if cursor + 1 + len > ch.size then
-                alloc(ch, 1 + len)
-            end
-            local b = ch.buff
-            buffer.writeu8(b, cursor, len)
-            if len > 0 then
-                buffer.copy(b, cursor + 1, value, 0, len)
-            end
-            ch.cursor = cursor + 1 + len
-        else
-            Varint.write(ch, len)
-            cursor = ch.cursor
-            if cursor + len > ch.size then
-                alloc(ch, len)
-            end
-            buffer.copy(ch.buff, cursor, value, 0, len)
-            ch.cursor = cursor + len
-        end
-    end,
+    local dataStart = pos + lenBytes
+    if dataStart + len > buffer.len(src) then
+        error("[Lync] Buffer.read: length exceeds remaining buffer")
+    end
 
-    read = function(src: buffer, pos: number, _refs: { Instance }?): (buffer, number)
-        local b0 = buffer.readu8(src, pos)
-        local len: number
-        local lenBytes: number
+    local out = buffer.create(len)
+    buffer.copy(out, 0, src, dataStart, len)
+    return out, lenBytes + len
+end
 
-        if b0 <= INLINE then
-            len = b0
-            lenBytes = 1
-        else
-            len, lenBytes = Varint.read(src, pos)
-        end
+-- Public -----------------------------------------------------------------
 
-        if len == 0 then
-            return buffer.create(0), lenBytes
-        end
-
-        local dataStart = pos + lenBytes
-        if dataStart + len > buffer.len(src) then
-            error("[Lync] Buffer: length exceeds remaining buffer")
-        end
+local BufferCodec = {}
 
-        local out = buffer.create(len)
-        buffer.copy(out, 0, src, dataStart, len)
-        return out, lenBytes + len
-    end,
-} :: any)
+BufferCodec.buff = table.freeze({
+    _typeCheck = "buffer",
+    write = writeBuffer,
+    read = readBuffer,
+})
 
 return table.freeze(BufferCodec)

package/src/codec/datatype/CFrame.luau

@@ -1,32 +1,35 @@
 --!strict
 --!native
--- CFrame codec with __call for smallest-three compressed variant.
+-- CFrame codec with __call factory for smallest-three quaternion compression.
 
 local Base = require(script.Parent.Parent.Base)
+local Types = require(script.Parent.Parent.Parent.Types)
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local EPSILON = 2.4e-7
 local EPSILON_SQ = EPSILON * EPSILON
-local SQRT = math.sqrt
-local COS = math.cos
-local SIN = math.sin
-local ABS = math.abs
-local ROUND = math.round
-local ACOS = math.acos
-
--- Smallest-three quantization constants
-local INV_SQRT2 = 1 / SQRT(2)
+
+local INV_SQRT2 = 1 / math.sqrt(2)
 local Q_SCALE = 1023 / (2 * INV_SQRT2)
 local Q_INV = (2 * INV_SQRT2) / 1023
 
+-- Private ----------------------------------------------------------------
+
+local alloc = Base.alloc
+local sqrt = math.sqrt
+local cos = math.cos
+local sin = math.sin
+local abs = math.abs
+local round = math.round
+local acos = math.acos
+local clamp = math.clamp
+
 local band = bit32.band
 local bor = bit32.bor
 local lshift = bit32.lshift
 local rshift = bit32.rshift
 
--- Private: Lossless axis-angle (24 bytes) -----------------------------
-
 local function writeLossless(b: buffer, off: number, value: CFrame): ()
     local pos = value.Position
     buffer.writef32(b, off, pos.X)
@@ -38,11 +41,11 @@ local function writeLossless(b: buffer, off: number, value: CFrame): ()
         buffer.writef32(b, off + 12, 0)
         buffer.writef32(b, off + 16, 0)
         buffer.writef32(b, off + 20, 0)
-    else
-        buffer.writef32(b, off + 12, axis.X * angle)
-        buffer.writef32(b, off + 16, axis.Y * angle)
-        buffer.writef32(b, off + 20, axis.Z * angle)
+        return
     end
+    buffer.writef32(b, off + 12, axis.X * angle)
+    buffer.writef32(b, off + 16, axis.Y * angle)
+    buffer.writef32(b, off + 20, axis.Z * angle)
 end
 
 local function readLossless(b: buffer, off: number): CFrame
@@ -58,53 +61,43 @@ local function readLossless(b: buffer, off: number): CFrame
         return CFrame.new(px, py, pz)
     end
 
-    local angle = SQRT(sqLen)
+    local angle = sqrt(sqLen)
     local inv = 1 / angle
     return CFrame.new(px, py, pz)
         * CFrame.fromAxisAngle(Vector3.new(rx * inv, ry * inv, rz * inv), angle)
 end
 
--- Private: Smallest-three compressed (16 bytes) -----------------------
-
+--[[
+    Compressed wire layout (16 bytes total):
+      [0..11]  position 3x f32
+      [12..15] packed [largest:2][a:10][b:10][c:10] — smallest-three quat
+]]
 local function writeCompressed(b: buffer, off: number, value: CFrame): ()
-    -- Position: 3x f32
     local pos = value.Position
     buffer.writef32(b, off, pos.X)
     buffer.writef32(b, off + 4, pos.Y)
     buffer.writef32(b, off + 8, pos.Z)
 
-    --[[
-        Convert CFrame rotation to quaternion via axis-angle.
-        Then apply smallest-three: drop the largest component,
-        quantize the other three into 10 bits each, pack into u32.
-    ]]
     local axis, angle = value:ToAxisAngle()
-    local halfAngle = angle * 0.5
-    local s = SIN(halfAngle)
+    local h = angle * 0.5
+    local s = sin(h)
     local qx = axis.X * s
     local qy = axis.Y * s
     local qz = axis.Z * s
-    local qw = COS(halfAngle)
-
-    -- Find largest component
-    local ax, ay, az, aw = ABS(qx), ABS(qy), ABS(qz), ABS(qw)
-    local largest = 3
-    local maxVal = aw
+    local qw = cos(h)
 
+    local ax, ay, az, aw = abs(qx), abs(qy), abs(qz), abs(qw)
+    local largest, maxVal = 3, aw
     if ax > maxVal then
-        largest = 0
-        maxVal = ax
+        largest, maxVal = 0, ax
     end
     if ay > maxVal then
-        largest = 1
-        maxVal = ay
+        largest, maxVal = 1, ay
     end
     if az > maxVal then
         largest = 2
-        maxVal = az
     end
 
-    -- Negate quaternion if largest component is negative
     local sign: number
     if largest == 0 then
         sign = if qx < 0 then -1 else 1
@@ -115,36 +108,24 @@ local function writeCompressed(b: buffer, off: number, value: CFrame): ()
     else
         sign = if qw < 0 then -1 else 1
     end
-    qx *= sign
-    qy *= sign
-    qz *= sign
-    qw *= sign
+    qx, qy, qz, qw = qx * sign, qy * sign, qz * sign, qw * sign
 
-    -- Select the three smallest components
-    local a, b2, c: number
+    local a, bComp, c: number
     if largest == 0 then
-        a, b2, c = qy, qz, qw
+        a, bComp, c = qy, qz, qw
     elseif largest == 1 then
-        a, b2, c = qx, qz, qw
+        a, bComp, c = qx, qz, qw
     elseif largest == 2 then
-        a, b2, c = qx, qy, qw
+        a, bComp, c = qx, qy, qw
     else
-        a, b2, c = qx, qy, qz
+        a, bComp, c = qx, qy, qz
     end
 
-    -- Quantize from [-1/sqrt(2), 1/sqrt(2)] to [0, 1023]
-    local qa = ROUND((a + INV_SQRT2) * Q_SCALE)
-    local qb = ROUND((b2 + INV_SQRT2) * Q_SCALE)
-    local qc = ROUND((c + INV_SQRT2) * Q_SCALE)
-
-    -- Clamp to [0, 1023]
-    qa = if qa < 0 then 0 elseif qa > 1023 then 1023 else qa
-    qb = if qb < 0 then 0 elseif qb > 1023 then 1023 else qb
-    qc = if qc < 0 then 0 elseif qc > 1023 then 1023 else qc
+    local qa = clamp(round((a + INV_SQRT2) * Q_SCALE), 0, 1023)
+    local qb = clamp(round((bComp + INV_SQRT2) * Q_SCALE), 0, 1023)
+    local qc = clamp(round((c + INV_SQRT2) * Q_SCALE), 0, 1023)
 
-    -- Pack: [index:2][a:10][b:10][c:10] = 32 bits
-    local packed = bor(lshift(largest, 30), lshift(qa, 20), lshift(qb, 10), qc)
-    buffer.writeu32(b, off + 12, packed)
+    buffer.writeu32(b, off + 12, bor(lshift(largest, 30), lshift(qa, 20), lshift(qb, 10), qc))
 end
 
 local function readCompressed(b: buffer, off: number): CFrame
@@ -158,72 +139,59 @@ local function readCompressed(b: buffer, off: number): CFrame
     local qb = band(rshift(packed, 10), 0x3FF)
     local qc = band(packed, 0x3FF)
 
-    -- Dequantize from [0, 1023] to [-1/sqrt(2), 1/sqrt(2)]
     local a = qa * Q_INV - INV_SQRT2
-    local b2 = qb * Q_INV - INV_SQRT2
+    local bComp = qb * Q_INV - INV_SQRT2
     local c = qc * Q_INV - INV_SQRT2
 
-    -- Reconstruct largest component
-    local sqSum = a * a + b2 * b2 + c * c
-    local d = SQRT(if sqSum < 1 then 1 - sqSum else 0)
+    local sqSum = a * a + bComp * bComp + c * c
+    local d = sqrt(if sqSum < 1 then 1 - sqSum else 0)
 
-    -- Place components
     local qx, qy, qz, qw: number
     if largest == 0 then
-        qx, qy, qz, qw = d, a, b2, c
+        qx, qy, qz, qw = d, a, bComp, c
     elseif largest == 1 then
-        qx, qy, qz, qw = a, d, b2, c
+        qx, qy, qz, qw = a, d, bComp, c
     elseif largest == 2 then
-        qx, qy, qz, qw = a, b2, d, c
+        qx, qy, qz, qw = a, bComp, d, c
     else
-        qx, qy, qz, qw = a, b2, c, d
+        qx, qy, qz, qw = a, bComp, c, d
     end
 
-    -- Build CFrame from position + quaternion
     local origin = CFrame.new(px, py, pz)
     if qx * qx + qy * qy + qz * qz < EPSILON_SQ then
         return origin
     end
 
-    -- Convert quaternion to axis-angle for CFrame construction
-    local len = SQRT(qx * qx + qy * qy + qz * qz)
-    local angle = 2 * ACOS(if qw > 1 then 1 elseif qw < -1 then -1 else qw)
+    local len = sqrt(qx * qx + qy * qy + qz * qz)
+    local angle = 2 * acos(clamp(qw, -1, 1))
     local inv = 1 / len
     return origin * CFrame.fromAxisAngle(Vector3.new(qx * inv, qy * inv, qz * inv), angle)
 end
 
--- __call factory for compressed variant
-local function compressedFactory(_self: any): any
-    return Base.define(16, writeCompressed, readCompressed, {
-        _typeCheck = "CFrame",
-    })
+local function compressedFactory(_self): Types.InternalCodec<CFrame>
+    return Base.define(16, writeCompressed, readCompressed, { _typeCheck = "CFrame" })
 end
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local CFrameCodec = {}
 
-CFrameCodec.cframe = setmetatable(
-    {
-        _size = 24,
-        _directWrite = writeLossless,
-        _directRead = readLossless,
-        _typeCheck = "CFrame",
-
-        write = function(ch: Types.ChannelState, value: CFrame): ()
-            local cursor = ch.cursor
-            if cursor + 24 > ch.size then
-                alloc(ch, 24)
-            end
-            writeLossless(ch.buff, cursor, value)
-            ch.cursor = cursor + 24
-        end,
-
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (CFrame, number)
-            return readLossless(src, pos), 24
-        end,
-    } :: any,
-    { __call = compressedFactory }
-)
+CFrameCodec.cframe = table.freeze(setmetatable({
+    _size = 24,
+    _directWrite = writeLossless,
+    _directRead = readLossless,
+    _typeCheck = "CFrame",
+    write = function(ch: Types.ChannelState, value: CFrame): ()
+        local cursor = ch.cursor
+        if cursor + 24 > ch.size then
+            alloc(ch, 24)
+        end
+        writeLossless(ch.buff, cursor, value)
+        ch.cursor = cursor + 24
+    end,
+    read = function(src: buffer, pos: number, _refs: { Instance }?): (CFrame, number)
+        return readLossless(src, pos), 24
+    end,
+}, table.freeze({ __call = compressedFactory })))
 
 return table.freeze(CFrameCodec)

package/src/codec/datatype/Color.luau

@@ -1,28 +1,32 @@
 --!strict
 --!optimize 2
--- Color3 codec. 3 bytes, RGB u8 per channel, clamped.
+-- Color3 codec. 3 bytes, R/G/B u8 per channel, clamped to [0, 1].
 
 local Base = require(script.Parent.Parent.Base)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local round = math.round
 local clamp = math.clamp
 
--- Public --------------------------------------------------------------
-
-local ColorCodec = {}
-
-ColorCodec.color3 = Base.define(3, function(b: buffer, off: number, value: Color3): ()
+local function writeColor3(b: buffer, off: number, value: Color3): ()
     buffer.writeu8(b, off, round(clamp(value.R, 0, 1) * 255))
     buffer.writeu8(b, off + 1, round(clamp(value.G, 0, 1) * 255))
     buffer.writeu8(b, off + 2, round(clamp(value.B, 0, 1) * 255))
-end, function(b: buffer, off: number): Color3
+end
+
+local function readColor3(b: buffer, off: number): Color3
     return Color3.fromRGB(
         buffer.readu8(b, off),
         buffer.readu8(b, off + 1),
         buffer.readu8(b, off + 2)
     )
-end, { _typeCheck = "Color3" })
+end
+
+-- Public -----------------------------------------------------------------
+
+local Color = {}
+
+Color.color3 = Base.define(3, writeColor3, readColor3, { _typeCheck = "Color3" })
 
-return table.freeze(ColorCodec)
+return table.freeze(Color)

package/src/codec/datatype/Instance.luau

@@ -2,58 +2,48 @@
 --!optimize 2
 -- Instance codec via sidecar reference array.
 
-local Base = require(script.Parent.Parent.Base)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
 local Types = require(script.Parent.Parent.Parent.Types)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
-local alloc = Base.alloc
-local writeu16 = buffer.writeu16
+local pushRef = Channel.pushRef
 local readu16 = buffer.readu16
 
--- Public --------------------------------------------------------------
+local function writeInstance(ch: Types.ChannelState, value: Instance): ()
+    pushRef(ch, value)
+end
+
+local function readInstance(src: buffer, pos: number, refs: { Instance }?): (Instance, number)
+    if not refs then
+        error("[Lync] Instance.read: refs array is required")
+    end
+
+    local idx = readu16(src, pos)
+    if idx < 1 or idx > #refs then
+        error(`[Lync] Instance.read: ref index {idx} out of bounds`)
+    end
+
+    local inst = refs[idx]
+    if typeof(inst) ~= "Instance" then
+        error("[Lync] Instance.read: ref is not an Instance")
+    end
+    return inst, 2
+end
+
+-- Public -----------------------------------------------------------------
 
 local InstanceCodec = {}
 
--- No _directWrite/_directRead: write needs ch.refs, so structs can't use the all-direct path
+--[[
+    No _directWrite/_directRead: write needs ch.refs, so structs/arrays
+    cannot use the all-direct fast path with this codec.
+]]
 InstanceCodec.inst = table.freeze({
     _size = 2,
     _typeCheck = "Instance",
-
-    write = function(ch: Types.ChannelState, value: Instance): ()
-        local idx = ch.refCount + 1
-        if idx > 0xFFFF then
-            error("[Lync] Instance: ref overflow (>65535)")
-        end
-
-        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,
-
-    read = function(src: buffer, pos: number, refs: { Instance }?): (Instance, number)
-        if not refs then
-            error("[Lync] Instance: read requires refs array")
-        end
-
-        local idx = readu16(src, pos)
-        if idx < 1 or idx > #refs then
-            error(`[Lync] Instance: ref index {idx} out of bounds`)
-        end
-
-        local inst = refs[idx]
-        if typeof(inst) ~= "Instance" then
-            error("[Lync] Instance: invalid ref (expected Instance)")
-        end
-
-        return inst, 2
-    end,
-} :: any)
+    write = writeInstance,
+    read = readInstance,
+})
 
 return table.freeze(InstanceCodec)