@axpecter/lync 2.2.1 → 2.3.2

package/src/codec/datatype/Buffer.luau

@@ -1,29 +1,29 @@
 --!strict
---!optimize 2
+--!native
 -- Raw buffer codec with dense-prefix-varint length prefix.
 
 local Base = require(script.Parent.Parent.Base)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
 -- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
-local INLINE = Varint.INLINE_MAX
+local INLINE_MAX = Varint.INLINE_MAX
 
 local function writeBuffer(ch: Types.ChannelState, value: buffer): ()
     local len = buffer.len(value)
     local cursor = ch.cursor
 
-    if len <= INLINE then
+    -- Single-byte length fast path skips the full varint encode.
+    if len <= INLINE_MAX 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
+        buffer.copy(b, cursor + 1, value, 0, len)
         ch.cursor = cursor + 1 + len
         return
     end
@@ -45,7 +45,7 @@ local function readBuffer(src: buffer, pos: number, _refs: { Instance }?): (buff
 
     local dataStart = pos + lenBytes
     if dataStart + len > buffer.len(src) then
-        error("[Lync] Buffer.read: length exceeds remaining buffer")
+        Log.error(`length {len}B exceeds remaining buffer`)
     end
 
     local out = buffer.create(len)

package/src/codec/datatype/CFrame.luau

@@ -1,8 +1,9 @@
 --!strict
 --!native
--- CFrame codec with __call factory for smallest-three quaternion compression.
+-- CFrame codec. Default lossless (24B); __call yields smallest-three quat (16B).
 
 local Base = require(script.Parent.Parent.Base)
+local Quat = require(script.Parent.Parent.Parent.util.Quat)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Constants --------------------------------------------------------------
@@ -10,51 +11,43 @@ local Types = require(script.Parent.Parent.Parent.Types)
 local EPSILON = 2.4e-7
 local EPSILON_SQ = EPSILON * EPSILON
 
-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 writef32 = buffer.writef32
+local readf32 = buffer.readf32
+local writeu32 = buffer.writeu32
+local readu32 = buffer.readu32
 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
+local quatPack = Quat.pack
+local quatUnpack = Quat.unpack
+local quatFromCFrame = Quat.fromCFrame
 
 local function writeLossless(b: buffer, off: number, value: CFrame): ()
     local pos = value.Position
-    buffer.writef32(b, off, pos.X)
-    buffer.writef32(b, off + 4, pos.Y)
-    buffer.writef32(b, off + 8, pos.Z)
+    writef32(b, off, pos.X)
+    writef32(b, off + 4, pos.Y)
+    writef32(b, off + 8, pos.Z)
 
     local axis, angle = value:ToAxisAngle()
     if angle < EPSILON then
-        buffer.writef32(b, off + 12, 0)
-        buffer.writef32(b, off + 16, 0)
-        buffer.writef32(b, off + 20, 0)
+        writef32(b, off + 12, 0)
+        writef32(b, off + 16, 0)
+        writef32(b, off + 20, 0)
         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)
+    writef32(b, off + 12, axis.X * angle)
+    writef32(b, off + 16, axis.Y * angle)
+    writef32(b, off + 20, axis.Z * angle)
 end
 
 local function readLossless(b: buffer, off: number): CFrame
-    local px = buffer.readf32(b, off)
-    local py = buffer.readf32(b, off + 4)
-    local pz = buffer.readf32(b, off + 8)
-    local rx = buffer.readf32(b, off + 12)
-    local ry = buffer.readf32(b, off + 16)
-    local rz = buffer.readf32(b, off + 20)
+    local px = readf32(b, off)
+    local py = readf32(b, off + 4)
+    local pz = readf32(b, off + 8)
+    local rx = readf32(b, off + 12)
+    local ry = readf32(b, off + 16)
+    local rz = readf32(b, off + 20)
 
     local sqLen = rx * rx + ry * ry + rz * rz
     if sqLen < EPSILON_SQ then
@@ -68,104 +61,23 @@ local function readLossless(b: buffer, off: number): CFrame
 end
 
 --[[
-    Compressed wire layout (16 bytes total):
+    Compressed wire (16B):
       [0..11]  position 3x f32
-      [12..15] packed [largest:2][a:10][b:10][c:10] — smallest-three quat
+      [12..15] packed [largest:2][a:10][b:10][c:10] (smallest-three quat)
 ]]
 local function writeCompressed(b: buffer, off: number, value: CFrame): ()
     local pos = value.Position
-    buffer.writef32(b, off, pos.X)
-    buffer.writef32(b, off + 4, pos.Y)
-    buffer.writef32(b, off + 8, pos.Z)
-
-    local axis, angle = value:ToAxisAngle()
-    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(h)
-
-    local ax, ay, az, aw = abs(qx), abs(qy), abs(qz), abs(qw)
-    local largest, maxVal = 3, aw
-    if ax > maxVal then
-        largest, maxVal = 0, ax
-    end
-    if ay > maxVal then
-        largest, maxVal = 1, ay
-    end
-    if az > maxVal then
-        largest = 2
-    end
-
-    local sign: number
-    if largest == 0 then
-        sign = if qx < 0 then -1 else 1
-    elseif largest == 1 then
-        sign = if qy < 0 then -1 else 1
-    elseif largest == 2 then
-        sign = if qz < 0 then -1 else 1
-    else
-        sign = if qw < 0 then -1 else 1
-    end
-    qx, qy, qz, qw = qx * sign, qy * sign, qz * sign, qw * sign
-
-    local a, bComp, c: number
-    if largest == 0 then
-        a, bComp, c = qy, qz, qw
-    elseif largest == 1 then
-        a, bComp, c = qx, qz, qw
-    elseif largest == 2 then
-        a, bComp, c = qx, qy, qw
-    else
-        a, bComp, c = qx, qy, qz
-    end
-
-    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)
-
-    buffer.writeu32(b, off + 12, bor(lshift(largest, 30), lshift(qa, 20), lshift(qb, 10), qc))
+    writef32(b, off, pos.X)
+    writef32(b, off + 4, pos.Y)
+    writef32(b, off + 8, pos.Z)
+    writeu32(b, off + 12, quatPack(quatFromCFrame(value)))
 end
 
 local function readCompressed(b: buffer, off: number): CFrame
-    local px = buffer.readf32(b, off)
-    local py = buffer.readf32(b, off + 4)
-    local pz = buffer.readf32(b, off + 8)
-
-    local packed = buffer.readu32(b, off + 12)
-    local largest = rshift(packed, 30)
-    local qa = band(rshift(packed, 20), 0x3FF)
-    local qb = band(rshift(packed, 10), 0x3FF)
-    local qc = band(packed, 0x3FF)
-
-    local a = qa * Q_INV - INV_SQRT2
-    local bComp = qb * Q_INV - INV_SQRT2
-    local c = qc * Q_INV - INV_SQRT2
-
-    local sqSum = a * a + bComp * bComp + c * c
-    local d = sqrt(if sqSum < 1 then 1 - sqSum else 0)
-
-    local qx, qy, qz, qw: number
-    if largest == 0 then
-        qx, qy, qz, qw = d, a, bComp, c
-    elseif largest == 1 then
-        qx, qy, qz, qw = a, d, bComp, c
-    elseif largest == 2 then
-        qx, qy, qz, qw = a, bComp, d, c
-    else
-        qx, qy, qz, qw = a, bComp, c, d
-    end
-
-    local origin = CFrame.new(px, py, pz)
-    if qx * qx + qy * qy + qz * qz < EPSILON_SQ then
-        return origin
-    end
-
-    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)
+    local px = readf32(b, off)
+    local py = readf32(b, off + 4)
+    local pz = readf32(b, off + 8)
+    return CFrame.new(px, py, pz) * quatUnpack(readu32(b, off + 12))
 end
 
 local function compressedFactory(_self): Types.InternalCodec<CFrame>

package/src/codec/datatype/Color.luau

@@ -1,26 +1,26 @@
 --!strict
---!optimize 2
--- Color3 codec. 3 bytes, R/G/B u8 per channel, clamped to [0, 1].
+--!native
+-- Color3 codec. 3 bytes (R/G/B u8 per channel), clamped to [0, 1].
 
 local Base = require(script.Parent.Parent.Base)
+local Constants = require(script.Parent.Parent.Parent.util.Constants)
 
 -- Private ----------------------------------------------------------------
 
+local U8_MAX = Constants.U8_MAX
+local writeu8 = buffer.writeu8
+local readu8 = buffer.readu8
 local round = math.round
 local clamp = math.clamp
 
 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))
+    writeu8(b, off, round(clamp(value.R, 0, 1) * U8_MAX))
+    writeu8(b, off + 1, round(clamp(value.G, 0, 1) * U8_MAX))
+    writeu8(b, off + 2, round(clamp(value.B, 0, 1) * U8_MAX))
 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)
-    )
+    return Color3.fromRGB(readu8(b, off), readu8(b, off + 1), readu8(b, off + 2))
 end
 
 -- Public -----------------------------------------------------------------

package/src/codec/datatype/Instance.luau

@@ -1,8 +1,9 @@
 --!strict
---!optimize 2
--- Instance codec via sidecar reference array.
+--!native
+-- Instance codec via the channel's sidecar reference array.
 
 local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Private ----------------------------------------------------------------
@@ -15,18 +16,23 @@ local function writeInstance(ch: Types.ChannelState, value: Instance): ()
 end
 
 local function readInstance(src: buffer, pos: number, refs: { Instance }?): (Instance, number)
-    if not refs then
-        error("[Lync] Instance.read: refs array is required")
+    local r = refs
+    if not r then
+        Log.error("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`)
+    if idx < 1 or idx > #r then
+        Log.error(`ref index {idx} out of bounds`)
     end
 
-    local inst = refs[idx]
+    --[[
+        Crafted clients can name a slot we never wrote; reject non-Instances.
+        Unknown codec skips this since it can legitimately hold any sidecar value.
+    ]]
+    local inst = r[idx]
     if typeof(inst) ~= "Instance" then
-        error("[Lync] Instance.read: ref is not an Instance")
+        Log.error("ref is not an Instance")
     end
     return inst, 2
 end
@@ -35,10 +41,7 @@ end
 
 local InstanceCodec = {}
 
---[[
-    No _directWrite/_directRead: write needs ch.refs, so structs/arrays
-    cannot use the all-direct fast path with this codec.
-]]
+-- No _directWrite/_directRead: write needs ch.refs (no fast path).
 InstanceCodec.inst = table.freeze({
     _size = 2,
     _typeCheck = "Instance",

package/src/codec/datatype/IntVector.luau

@@ -1,6 +1,6 @@
 --!strict
---!optimize 2
--- Vector2int16 (4 bytes) and Vector3int16 (6 bytes) codecs.
+--!native
+-- Vector2int16 (4B) and Vector3int16 (6B) codecs.
 
 local Base = require(script.Parent.Parent.Base)
 local Signed = require(script.Parent.Parent.primitive.Signed)

package/src/codec/datatype/NumberRange.luau

@@ -1,22 +1,29 @@
 --!strict
---!optimize 2
--- NumberRange codec. 8 bytes: Min f32 + Max f32.
+--!native
+-- NumberRange codec. 8B: Min f32 + Max f32.
 
 local Base = require(script.Parent.Parent.Base)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 
 -- Private ----------------------------------------------------------------
 
+local writef32 = buffer.writef32
+local readf32 = buffer.readf32
+
 local function writeNumberRange(b: buffer, off: number, value: NumberRange): ()
-    buffer.writef32(b, off, value.Min)
-    buffer.writef32(b, off + 4, value.Max)
+    writef32(b, off, value.Min)
+    writef32(b, off + 4, value.Max)
 end
 
+--[[
+    Reject min > max instead of silently swapping. A swap masks a desync;
+    erroring aborts the frame so the transport can reset its baseline.
+]]
 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.
+    local minV = readf32(b, off)
+    local maxV = readf32(b, off + 4)
     if minV > maxV then
-        minV, maxV = maxV, minV
+        Log.error(`min ({minV}) > max ({maxV})`)
     end
     return NumberRange.new(minV, maxV)
 end

package/src/codec/datatype/Ray.luau

@@ -1,30 +1,29 @@
 --!strict
---!optimize 2
--- Ray codec. 24 bytes: Origin (3x f32) + Direction (3x f32).
+--!native
+-- Ray codec. 24B: Origin (3x f32) + Direction (3x f32).
 
 local Base = require(script.Parent.Parent.Base)
 
 -- Private ----------------------------------------------------------------
 
+local writef32 = buffer.writef32
+local readf32 = buffer.readf32
+
 local function writeRay(b: buffer, off: number, value: Ray): ()
     local o = value.Origin
     local d = value.Direction
-    buffer.writef32(b, off, o.X)
-    buffer.writef32(b, off + 4, o.Y)
-    buffer.writef32(b, off + 8, o.Z)
-    buffer.writef32(b, off + 12, d.X)
-    buffer.writef32(b, off + 16, d.Y)
-    buffer.writef32(b, off + 20, d.Z)
+    writef32(b, off, o.X)
+    writef32(b, off + 4, o.Y)
+    writef32(b, off + 8, o.Z)
+    writef32(b, off + 12, d.X)
+    writef32(b, off + 16, d.Y)
+    writef32(b, off + 20, d.Z)
 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(
-            buffer.readf32(b, off + 12),
-            buffer.readf32(b, off + 16),
-            buffer.readf32(b, off + 20)
-        )
+        Vector3.new(readf32(b, off), readf32(b, off + 4), readf32(b, off + 8)),
+        Vector3.new(readf32(b, off + 12), readf32(b, off + 16), readf32(b, off + 20))
     )
 end
 

package/src/codec/datatype/Rect.luau

@@ -1,25 +1,25 @@
 --!strict
---!optimize 2
--- Rect codec. 16 bytes: 4x f32 (Min.X, Min.Y, Max.X, Max.Y).
+--!native
+-- Rect codec. 16B: 4x f32 (Min.X, Min.Y, Max.X, Max.Y).
 
 local Base = require(script.Parent.Parent.Base)
 
 -- Private ----------------------------------------------------------------
 
+local writef32 = buffer.writef32
+local readf32 = buffer.readf32
+
 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)
+    local minV = value.Min
+    local maxV = value.Max
+    writef32(b, off, minV.X)
+    writef32(b, off + 4, minV.Y)
+    writef32(b, off + 8, maxV.X)
+    writef32(b, off + 12, maxV.Y)
 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)
-    )
+    return Rect.new(readf32(b, off), readf32(b, off + 4), readf32(b, off + 8), readf32(b, off + 12))
 end
 
 -- Public -----------------------------------------------------------------

package/src/codec/datatype/Region.luau

@@ -1,36 +1,35 @@
 --!strict
---!optimize 2
--- Region3 (24 bytes) and Region3int16 (12 bytes) codecs.
+--!native
+-- Region3 (24B) and Region3int16 (12B) codecs.
 
 local Base = require(script.Parent.Parent.Base)
 local Signed = require(script.Parent.Parent.primitive.Signed)
 
 -- Private ----------------------------------------------------------------
 
+local writef32 = buffer.writef32
+local readf32 = buffer.readf32
 local writeI16 = Signed.writeI16
 local readi16 = buffer.readi16
 
+-- Region3 has no Min/Max accessors; reconstruct from CFrame.Position +/- Size/2.
 local function writeRegion3(b: buffer, off: number, value: Region3): ()
     local pos = value.CFrame.Position
     local half = value.Size * 0.5
     local minV = pos - half
     local maxV = pos + half
-    buffer.writef32(b, off, minV.X)
-    buffer.writef32(b, off + 4, minV.Y)
-    buffer.writef32(b, off + 8, minV.Z)
-    buffer.writef32(b, off + 12, maxV.X)
-    buffer.writef32(b, off + 16, maxV.Y)
-    buffer.writef32(b, off + 20, maxV.Z)
+    writef32(b, off, minV.X)
+    writef32(b, off + 4, minV.Y)
+    writef32(b, off + 8, minV.Z)
+    writef32(b, off + 12, maxV.X)
+    writef32(b, off + 16, maxV.Y)
+    writef32(b, off + 20, maxV.Z)
 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(
-            buffer.readf32(b, off + 12),
-            buffer.readf32(b, off + 16),
-            buffer.readf32(b, off + 20)
-        )
+        Vector3.new(readf32(b, off), readf32(b, off + 4), readf32(b, off + 8)),
+        Vector3.new(readf32(b, off + 12), readf32(b, off + 16), readf32(b, off + 20))
     )
 end