@axpecter/lync 2.1.2 → 2.2.0

package/src/codec/datatype/IntVector.luau

@@ -3,35 +3,37 @@
 -- Vector2int16 (4 bytes) and Vector3int16 (6 bytes) codecs.
 
 local Base = require(script.Parent.Parent.Base)
+local Signed = require(script.Parent.Parent.primitive.Signed)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
-local function writeI16(b: buffer, off: number, v: number): ()
-    buffer.writeu16(b, off, if v < 0 then v + 0x10000 else v)
-end
-
-local function readI16(b: buffer, off: number): number
-    local raw = buffer.readu16(b, off)
-    return if raw >= 0x8000 then raw - 0x10000 else raw
-end
-
--- Public --------------------------------------------------------------
+local writeI16 = Signed.writeI16
+local readi16 = buffer.readi16
 
-local IntVectorCodec = {}
-
-IntVectorCodec.vec2int16 = Base.define(4, function(b: buffer, off: number, value: Vector2int16): ()
+local function writeVec2I16(b: buffer, off: number, value: Vector2int16): ()
     writeI16(b, off, value.X)
     writeI16(b, off + 2, value.Y)
-end, function(b: buffer, off: number): Vector2int16
-    return Vector2int16.new(readI16(b, off), readI16(b, off + 2))
-end, { _typeCheck = "Vector2int16" })
+end
+
+local function readVec2I16(b: buffer, off: number): Vector2int16
+    return Vector2int16.new(readi16(b, off), readi16(b, off + 2))
+end
 
-IntVectorCodec.vec3int16 = Base.define(6, function(b: buffer, off: number, value: Vector3int16): ()
+local function writeVec3I16(b: buffer, off: number, value: Vector3int16): ()
     writeI16(b, off, value.X)
     writeI16(b, off + 2, value.Y)
     writeI16(b, off + 4, value.Z)
-end, function(b: buffer, off: number): Vector3int16
-    return Vector3int16.new(readI16(b, off), readI16(b, off + 2), readI16(b, off + 4))
-end, { _typeCheck = "Vector3int16" })
+end
+
+local function readVec3I16(b: buffer, off: number): Vector3int16
+    return Vector3int16.new(readi16(b, off), readi16(b, off + 2), readi16(b, off + 4))
+end
+
+-- Public -----------------------------------------------------------------
+
+local IntVector = {}
+
+IntVector.vec2int16 = Base.define(4, writeVec2I16, readVec2I16, { _typeCheck = "Vector2int16" })
+IntVector.vec3int16 = Base.define(6, writeVec3I16, readVec3I16, { _typeCheck = "Vector3int16" })
 
-return table.freeze(IntVectorCodec)
+return table.freeze(IntVector)

package/src/codec/datatype/NumberRange.luau

@@ -4,20 +4,29 @@
 
 local Base = require(script.Parent.Parent.Base)
 
--- Public --------------------------------------------------------------
+-- Private ----------------------------------------------------------------
+
+local function writeNumberRange(b: buffer, off: number, value: NumberRange): ()
+    buffer.writef32(b, off, value.Min)
+    buffer.writef32(b, off + 4, value.Max)
+end
+
+local function readNumberRange(b: buffer, off: number): NumberRange
+    local minV = buffer.readf32(b, off)
+    local maxV = buffer.readf32(b, off + 4)
+    -- NumberRange.new requires min <= max; swap on corruption rather than throw.
+    if minV > maxV then
+        minV, maxV = maxV, minV
+    end
+    return NumberRange.new(minV, maxV)
+end
+
+-- Public -----------------------------------------------------------------
 
 local NumberRangeCodec = {}
 
-NumberRangeCodec.numberRange = Base.define(
-    8,
-    function(b: buffer, off: number, value: NumberRange): ()
-        buffer.writef32(b, off, value.Min)
-        buffer.writef32(b, off + 4, value.Max)
-    end,
-    function(b: buffer, off: number): NumberRange
-        return NumberRange.new(buffer.readf32(b, off), buffer.readf32(b, off + 4))
-    end,
-    { _typeCheck = "NumberRange" }
-)
+NumberRangeCodec.numberRange = Base.define(8, writeNumberRange, readNumberRange, {
+    _typeCheck = "NumberRange",
+})
 
 return table.freeze(NumberRangeCodec)

package/src/codec/datatype/Ray.luau

@@ -1,14 +1,12 @@
 --!strict
 --!optimize 2
--- Ray codec. 24 bytes: origin + direction as 6x f32.
+-- Ray codec. 24 bytes: Origin (3x f32) + Direction (3x f32).
 
 local Base = require(script.Parent.Parent.Base)
 
--- Public --------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
-local RayCodec = {}
-
-RayCodec.ray = Base.define(24, function(b: buffer, off: number, value: Ray): ()
+local function writeRay(b: buffer, off: number, value: Ray): ()
     local o = value.Origin
     local d = value.Direction
     buffer.writef32(b, off, o.X)
@@ -17,7 +15,9 @@ RayCodec.ray = Base.define(24, function(b: buffer, off: number, value: Ray): ()
     buffer.writef32(b, off + 12, d.X)
     buffer.writef32(b, off + 16, d.Y)
     buffer.writef32(b, off + 20, d.Z)
-end, function(b: buffer, off: number): Ray
+end
+
+local function readRay(b: buffer, off: number): Ray
     return Ray.new(
         Vector3.new(buffer.readf32(b, off), buffer.readf32(b, off + 4), buffer.readf32(b, off + 8)),
         Vector3.new(
@@ -26,6 +26,12 @@ end, function(b: buffer, off: number): Ray
             buffer.readf32(b, off + 20)
         )
     )
-end, { _typeCheck = "Ray" })
+end
+
+-- Public -----------------------------------------------------------------
+
+local RayCodec = {}
+
+RayCodec.ray = Base.define(24, writeRay, readRay, { _typeCheck = "Ray" })
 
 return table.freeze(RayCodec)

package/src/codec/datatype/Rect.luau

@@ -1,25 +1,31 @@
 --!strict
 --!optimize 2
--- Rect codec. 16 bytes: 4x f32.
+-- Rect codec. 16 bytes: 4x f32 (Min.X, Min.Y, Max.X, Max.Y).
 
 local Base = require(script.Parent.Parent.Base)
 
--- Public --------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
-local RectCodec = {}
-
-RectCodec.rect = Base.define(16, function(b: buffer, off: number, value: Rect): ()
+local function writeRect(b: buffer, off: number, value: Rect): ()
     buffer.writef32(b, off, value.Min.X)
     buffer.writef32(b, off + 4, value.Min.Y)
     buffer.writef32(b, off + 8, value.Max.X)
     buffer.writef32(b, off + 12, value.Max.Y)
-end, function(b: buffer, off: number): Rect
+end
+
+local function readRect(b: buffer, off: number): Rect
     return Rect.new(
         buffer.readf32(b, off),
         buffer.readf32(b, off + 4),
         buffer.readf32(b, off + 8),
         buffer.readf32(b, off + 12)
     )
-end, { _typeCheck = "Rect" })
+end
+
+-- Public -----------------------------------------------------------------
+
+local RectCodec = {}
+
+RectCodec.rect = Base.define(16, writeRect, readRect, { _typeCheck = "Rect" })
 
 return table.freeze(RectCodec)

package/src/codec/datatype/Region.luau

@@ -3,23 +3,14 @@
 -- Region3 (24 bytes) and Region3int16 (12 bytes) codecs.
 
 local Base = require(script.Parent.Parent.Base)
+local Signed = require(script.Parent.Parent.primitive.Signed)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
-local function writeI16(b: buffer, off: number, v: number): ()
-    buffer.writeu16(b, off, if v < 0 then v + 0x10000 else v)
-end
-
-local function readI16(b: buffer, off: number): number
-    local raw = buffer.readu16(b, off)
-    return if raw >= 0x8000 then raw - 0x10000 else raw
-end
-
--- Public --------------------------------------------------------------
+local writeI16 = Signed.writeI16
+local readi16 = buffer.readi16
 
-local RegionCodec = {}
-
-RegionCodec.region3 = Base.define(24, function(b: buffer, off: number, value: Region3): ()
+local function writeRegion3(b: buffer, off: number, value: Region3): ()
     local pos = value.CFrame.Position
     local half = value.Size * 0.5
     local minV = pos - half
@@ -30,7 +21,9 @@ RegionCodec.region3 = Base.define(24, function(b: buffer, off: number, value: Re
     buffer.writef32(b, off + 12, maxV.X)
     buffer.writef32(b, off + 16, maxV.Y)
     buffer.writef32(b, off + 20, maxV.Z)
-end, function(b: buffer, off: number): Region3
+end
+
+local function readRegion3(b: buffer, off: number): Region3
     return Region3.new(
         Vector3.new(buffer.readf32(b, off), buffer.readf32(b, off + 4), buffer.readf32(b, off + 8)),
         Vector3.new(
@@ -39,9 +32,9 @@ end, function(b: buffer, off: number): Region3
             buffer.readf32(b, off + 20)
         )
     )
-end, { _typeCheck = "Region3" })
+end
 
-RegionCodec.region3int16 = Base.define(12, function(b: buffer, off: number, value: Region3int16): ()
+local function writeRegion3I16(b: buffer, off: number, value: Region3int16): ()
     local minV = value.Min
     local maxV = value.Max
     writeI16(b, off, minV.X)
@@ -50,11 +43,21 @@ RegionCodec.region3int16 = Base.define(12, function(b: buffer, off: number, valu
     writeI16(b, off + 6, maxV.X)
     writeI16(b, off + 8, maxV.Y)
     writeI16(b, off + 10, maxV.Z)
-end, function(b: buffer, off: number): Region3int16
+end
+
+local function readRegion3I16(b: buffer, off: number): Region3int16
     return Region3int16.new(
-        Vector3int16.new(readI16(b, off), readI16(b, off + 2), readI16(b, off + 4)),
-        Vector3int16.new(readI16(b, off + 6), readI16(b, off + 8), readI16(b, off + 10))
+        Vector3int16.new(readi16(b, off), readi16(b, off + 2), readi16(b, off + 4)),
+        Vector3int16.new(readi16(b, off + 6), readi16(b, off + 8), readi16(b, off + 10))
     )
-end, { _typeCheck = "Region3int16" })
+end
+
+-- Public -----------------------------------------------------------------
+
+local Region = {}
+
+Region.region3 = Base.define(24, writeRegion3, readRegion3, { _typeCheck = "Region3" })
+Region.region3int16 =
+    Base.define(12, writeRegion3I16, readRegion3I16, { _typeCheck = "Region3int16" })
 
-return table.freeze(RegionCodec)
+return table.freeze(Region)

package/src/codec/datatype/Sequence.luau

@@ -1,136 +1,162 @@
 --!strict
 --!optimize 2
--- NumberSequence and ColorSequence codecs with varint count.
+-- NumberSequence (12B/keypoint) and ColorSequence (7B/keypoint) codecs.
 
 local Base = require(script.Parent.Parent.Base)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
--- Private -------------------------------------------------------------
+-- Constants --------------------------------------------------------------
+
+local NUMSEQ_KP_BYTES = 12
+local COLSEQ_KP_BYTES = 7
+local MAX_KEYPOINTS = 20
+
+-- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
 local round = math.round
 local clamp = math.clamp
 
--- Public --------------------------------------------------------------
-
-local SequenceCodec = {}
-
-SequenceCodec.numberSequence = table.freeze({
-    _typeCheck = "NumberSequence",
-
-    write = function(ch: Types.ChannelState, value: NumberSequence): ()
-        local keypoints = value.Keypoints
-        local count = #keypoints
-        Varint.write(ch, count)
-
-        if count == 0 then
-            return
-        end
-
-        local bytes = count * 12
-        local cursor = ch.cursor
-        if cursor + bytes > ch.size then
-            alloc(ch, bytes)
-        end
-        local b = ch.buff
-
-        for i = 1, count do
-            local kp = keypoints[i]
-            local off = cursor + (i - 1) * 12
-            buffer.writef32(b, off, kp.Time)
-            buffer.writef32(b, off + 4, kp.Value)
-            buffer.writef32(b, off + 8, kp.Envelope)
-        end
-
-        ch.cursor = cursor + bytes
-    end,
-
-    read = function(src: buffer, pos: number, _refs: { Instance }?): (NumberSequence, number)
-        local count, lenBytes = Varint.read(src, pos)
-        if count == 0 then
-            return NumberSequence.new(0), lenBytes
-        end
-
-        local bytes = count * 12
-        local dataStart = pos + lenBytes
-        if dataStart + bytes > buffer.len(src) then
-            error("[Lync] NumberSequence: data exceeds buffer")
-        end
-
-        local keypoints = table.create(count)
-        for i = 1, count do
-            local off = dataStart + (i - 1) * 12
-            keypoints[i] = NumberSequenceKeypoint.new(
-                buffer.readf32(src, off),
-                buffer.readf32(src, off + 4),
-                buffer.readf32(src, off + 8)
+local function writeNumberSequence(ch: Types.ChannelState, value: NumberSequence): ()
+    local keypoints = value.Keypoints
+    local count = #keypoints
+    Varint.write(ch, count)
+    if count == 0 then
+        return
+    end
+
+    local bytes = count * NUMSEQ_KP_BYTES
+    local cursor = ch.cursor
+    if cursor + bytes > ch.size then
+        alloc(ch, bytes)
+    end
+    local b = ch.buff
+
+    local off = cursor
+    for i = 1, count do
+        local kp = keypoints[i]
+        buffer.writef32(b, off, kp.Time)
+        buffer.writef32(b, off + 4, kp.Value)
+        buffer.writef32(b, off + 8, kp.Envelope)
+        off += NUMSEQ_KP_BYTES
+    end
+    ch.cursor = cursor + bytes
+end
+
+local function readNumberSequence(
+    src: buffer,
+    pos: number,
+    _refs: { Instance }?
+): (NumberSequence, number)
+    local count, lenBytes = Varint.read(src, pos)
+    if count == 0 then
+        return NumberSequence.new(0), lenBytes
+    end
+    if count > MAX_KEYPOINTS then
+        error(
+            `[Lync] NumberSequence.read: keypoint count {count} exceeds Roblox limit {MAX_KEYPOINTS}`
+        )
+    end
+
+    local bytes = count * NUMSEQ_KP_BYTES
+    local dataStart = pos + lenBytes
+    if dataStart + bytes > buffer.len(src) then
+        error("[Lync] NumberSequence.read: data exceeds buffer")
+    end
+
+    local keypoints = table.create(count)
+    local off = dataStart
+    for i = 1, count do
+        keypoints[i] = NumberSequenceKeypoint.new(
+            buffer.readf32(src, off),
+            buffer.readf32(src, off + 4),
+            buffer.readf32(src, off + 8)
+        )
+        off += NUMSEQ_KP_BYTES
+    end
+    return NumberSequence.new(keypoints), lenBytes + bytes
+end
+
+local function writeColorSequence(ch: Types.ChannelState, value: ColorSequence): ()
+    local keypoints = value.Keypoints
+    local count = #keypoints
+    Varint.write(ch, count)
+    if count == 0 then
+        return
+    end
+
+    local bytes = count * COLSEQ_KP_BYTES
+    local cursor = ch.cursor
+    if cursor + bytes > ch.size then
+        alloc(ch, bytes)
+    end
+    local b = ch.buff
+
+    local off = cursor
+    for i = 1, count do
+        local kp = keypoints[i]
+        local c = kp.Value
+        buffer.writef32(b, off, kp.Time)
+        buffer.writeu8(b, off + 4, round(clamp(c.R, 0, 1) * 255))
+        buffer.writeu8(b, off + 5, round(clamp(c.G, 0, 1) * 255))
+        buffer.writeu8(b, off + 6, round(clamp(c.B, 0, 1) * 255))
+        off += COLSEQ_KP_BYTES
+    end
+    ch.cursor = cursor + bytes
+end
+
+local function readColorSequence(
+    src: buffer,
+    pos: number,
+    _refs: { Instance }?
+): (ColorSequence, number)
+    local count, lenBytes = Varint.read(src, pos)
+    if count == 0 then
+        return ColorSequence.new(Color3.new()), lenBytes
+    end
+    if count > MAX_KEYPOINTS then
+        error(
+            `[Lync] ColorSequence.read: keypoint count {count} exceeds Roblox limit {MAX_KEYPOINTS}`
+        )
+    end
+
+    local bytes = count * COLSEQ_KP_BYTES
+    local dataStart = pos + lenBytes
+    if dataStart + bytes > buffer.len(src) then
+        error("[Lync] ColorSequence.read: data exceeds buffer")
+    end
+
+    local keypoints = table.create(count)
+    local off = dataStart
+    for i = 1, count do
+        keypoints[i] = ColorSequenceKeypoint.new(
+            buffer.readf32(src, off),
+            Color3.fromRGB(
+                buffer.readu8(src, off + 4),
+                buffer.readu8(src, off + 5),
+                buffer.readu8(src, off + 6)
             )
-        end
+        )
+        off += COLSEQ_KP_BYTES
+    end
+    return ColorSequence.new(keypoints), lenBytes + bytes
+end
 
-        return NumberSequence.new(keypoints), lenBytes + bytes
-    end,
-} :: any)
+-- Public -----------------------------------------------------------------
 
-SequenceCodec.colorSequence = table.freeze({
-    _typeCheck = "ColorSequence",
+local Sequence = {}
 
-    write = function(ch: Types.ChannelState, value: ColorSequence): ()
-        local keypoints = value.Keypoints
-        local count = #keypoints
-        Varint.write(ch, count)
-
-        if count == 0 then
-            return
-        end
-
-        local bytes = count * 7
-        local cursor = ch.cursor
-        if cursor + bytes > ch.size then
-            alloc(ch, bytes)
-        end
-        local b = ch.buff
-
-        for i = 1, count do
-            local kp = keypoints[i]
-            local off = cursor + (i - 1) * 7
-            local c = kp.Value
-            buffer.writef32(b, off, kp.Time)
-            buffer.writeu8(b, off + 4, round(clamp(c.R, 0, 1) * 255))
-            buffer.writeu8(b, off + 5, round(clamp(c.G, 0, 1) * 255))
-            buffer.writeu8(b, off + 6, round(clamp(c.B, 0, 1) * 255))
-        end
-
-        ch.cursor = cursor + bytes
-    end,
-
-    read = function(src: buffer, pos: number, _refs: { Instance }?): (ColorSequence, number)
-        local count, lenBytes = Varint.read(src, pos)
-        if count == 0 then
-            return ColorSequence.new(Color3.new()), lenBytes
-        end
-
-        local bytes = count * 7
-        local dataStart = pos + lenBytes
-        if dataStart + bytes > buffer.len(src) then
-            error("[Lync] ColorSequence: data exceeds buffer")
-        end
-
-        local keypoints = table.create(count)
-        for i = 1, count do
-            local off = dataStart + (i - 1) * 7
-            keypoints[i] = ColorSequenceKeypoint.new(
-                buffer.readf32(src, off),
-                Color3.fromRGB(
-                    buffer.readu8(src, off + 4),
-                    buffer.readu8(src, off + 5),
-                    buffer.readu8(src, off + 6)
-                )
-            )
-        end
+Sequence.numberSequence = table.freeze({
+    _typeCheck = "NumberSequence",
+    write = writeNumberSequence,
+    read = readNumberSequence,
+})
 
-        return ColorSequence.new(keypoints), lenBytes + bytes
-    end,
-} :: any)
+Sequence.colorSequence = table.freeze({
+    _typeCheck = "ColorSequence",
+    write = writeColorSequence,
+    read = readColorSequence,
+})
 
-return table.freeze(SequenceCodec)
+return table.freeze(Sequence)