@axpecter/lync 2.2.1 → 2.3.1

package/src/codec/datatype/CFrame.luau

@@ -1,6 +1,6 @@
 --!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 Types = require(script.Parent.Parent.Parent.Types)
@@ -17,6 +17,11 @@ 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
@@ -32,29 +37,29 @@ local rshift = bit32.rshift
 
 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,15 +73,15 @@ 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)
+    writef32(b, off, pos.X)
+    writef32(b, off + 4, pos.Y)
+    writef32(b, off + 8, pos.Z)
 
     local axis, angle = value:ToAxisAngle()
     local h = angle * 0.5
@@ -86,6 +91,7 @@ local function writeCompressed(b: buffer, off: number, value: CFrame): ()
     local qz = axis.Z * s
     local qw = cos(h)
 
+    -- Smallest-three: drop the largest |component|; track index alongside maxVal.
     local ax, ay, az, aw = abs(qx), abs(qy), abs(qz), abs(qw)
     local largest, maxVal = 3, aw
     if ax > maxVal then
@@ -95,29 +101,34 @@ local function writeCompressed(b: buffer, off: number, value: CFrame): ()
         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
+        largest, maxVal = 2, az
     end
-    qx, qy, qz, qw = qx * sign, qy * sign, qz * sign, qw * sign
 
-    local a, bComp, c: number
+    --[[
+        Force the dropped component non-negative so the decoder's
+        +sqrt(1 - a^2 - b^2 - c^2) reconstructs the right sign. Dispatch on
+        `largest` instead of building a 4-element table per call.
+    ]]
+    local a: number, bComp: number, c: number
     if largest == 0 then
+        if qx < 0 then
+            qy, qz, qw = -qy, -qz, -qw
+        end
         a, bComp, c = qy, qz, qw
     elseif largest == 1 then
+        if qy < 0 then
+            qx, qz, qw = -qx, -qz, -qw
+        end
         a, bComp, c = qx, qz, qw
     elseif largest == 2 then
+        if qz < 0 then
+            qx, qy, qw = -qx, -qy, -qw
+        end
         a, bComp, c = qx, qy, qw
     else
+        if qw < 0 then
+            qx, qy, qz = -qx, -qy, -qz
+        end
         a, bComp, c = qx, qy, qz
     end
 
@@ -125,15 +136,15 @@ local function writeCompressed(b: buffer, off: number, value: CFrame): ()
     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))
+    writeu32(b, off + 12, bor(lshift(largest, 30), lshift(qa, 20), lshift(qb, 10), qc))
 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 px = readf32(b, off)
+    local py = readf32(b, off + 4)
+    local pz = readf32(b, off + 8)
 
-    local packed = buffer.readu32(b, off + 12)
+    local packed = readu32(b, off + 12)
     local largest = rshift(packed, 30)
     local qa = band(rshift(packed, 20), 0x3FF)
     local qb = band(rshift(packed, 10), 0x3FF)
@@ -146,7 +157,8 @@ local function readCompressed(b: buffer, off: number): CFrame
     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
+    -- Mirror encoder: dropped index gets `d`, others receive (a, bComp, c).
+    local qx: number, qy: number, qz: number, qw: number
     if largest == 0 then
         qx, qy, qz, qw = d, a, bComp, c
     elseif largest == 1 then
@@ -158,13 +170,13 @@ local function readCompressed(b: buffer, off: number): CFrame
     end
 
     local origin = CFrame.new(px, py, pz)
-    if qx * qx + qy * qy + qz * qz < EPSILON_SQ then
+    local sqLen = qx * qx + qy * qy + qz * qz
+    if sqLen < 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
+    local inv = 1 / sqrt(sqLen)
     return origin * CFrame.fromAxisAngle(Vector3.new(qx * inv, qy * inv, qz * inv), angle)
 end
 

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