@axpecter/lync 2.0.0 → 2.1.1

package/src/codec/datatype/CFrame.luau

@@ -1,52 +1,229 @@
 --!strict
 --!native
--- Axis-angle CFrame codec. Zero axis at identity for clean deltas.
+-- CFrame codec with __call for smallest-three compressed variant.
 
 local Base = require(script.Parent.Parent.Base)
 
-local sqrt = math.sqrt
+-- Constants -----------------------------------------------------------
 
--- f32 machine epsilon * 2 to absorb round-trip noise.
 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
 
-local function writeCFrame(b: buffer, c: number, value: CFrame): ()
-    local position = value.Position
-    local axis, angle = value:ToAxisAngle()
+-- Smallest-three quantization constants
+local INV_SQRT2 = 1 / SQRT(2)
+local Q_SCALE = 1023 / (2 * INV_SQRT2)
+local Q_INV = (2 * INV_SQRT2) / 1023
+
+local band = bit32.band
+local bor = bit32.bor
+local lshift = bit32.lshift
+local rshift = bit32.rshift
+
+-- Private: Lossless axis-angle (24 bytes) -----------------------------
 
-    buffer.writef32(b, c, position.X)
-    buffer.writef32(b, c + 4, position.Y)
-    buffer.writef32(b, c + 8, position.Z)
+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)
 
+    local axis, angle = value:ToAxisAngle()
     if angle < EPSILON then
-        buffer.writef32(b, c + 12, 0)
-        buffer.writef32(b, c + 16, 0)
-        buffer.writef32(b, c + 20, 0)
+        buffer.writef32(b, off + 12, 0)
+        buffer.writef32(b, off + 16, 0)
+        buffer.writef32(b, off + 20, 0)
     else
-        buffer.writef32(b, c + 12, axis.X * angle)
-        buffer.writef32(b, c + 16, axis.Y * angle)
-        buffer.writef32(b, c + 20, axis.Z * angle)
+        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
 end
 
-local function readCFrame(b: buffer, pos: number): CFrame
-    local px = buffer.readf32(b, pos)
-    local py = buffer.readf32(b, pos + 4)
-    local pz = buffer.readf32(b, pos + 8)
-    local rx = buffer.readf32(b, pos + 12)
-    local ry = buffer.readf32(b, pos + 16)
-    local rz = buffer.readf32(b, pos + 20)
+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 angle = sqrt(rx * rx + ry * ry + rz * rz)
-    local origin = CFrame.new(px, py, pz)
+    local sqLen = rx * rx + ry * ry + rz * rz
+    if sqLen < EPSILON_SQ then
+        return CFrame.new(px, py, pz)
+    end
 
-    if angle < EPSILON then
+    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) -----------------------
+
+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 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
+
+    if ax > maxVal then
+        largest = 0
+        maxVal = ax
+    end
+    if ay > maxVal then
+        largest = 1
+        maxVal = 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
+    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 *= sign
+    qy *= sign
+    qz *= sign
+    qw *= sign
+
+    -- Select the three smallest components
+    local a, b2, c: number
+    if largest == 0 then
+        a, b2, c = qy, qz, qw
+    elseif largest == 1 then
+        a, b2, c = qx, qz, qw
+    elseif largest == 2 then
+        a, b2, c = qx, qy, qw
+    else
+        a, b2, 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
+
+    -- 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)
+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)
+
+    -- 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 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)
+
+    -- Place components
+    local qx, qy, qz, qw: number
+    if largest == 0 then
+        qx, qy, qz, qw = d, a, b2, c
+    elseif largest == 1 then
+        qx, qy, qz, qw = a, d, b2, c
+    elseif largest == 2 then
+        qx, qy, qz, qw = a, b2, d, c
+    else
+        qx, qy, qz, qw = a, b2, 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
 
-    local inv = 1 / angle
-    return origin * CFrame.fromAxisAngle(Vector3.new(rx * inv, ry * inv, rz * inv), angle)
+    -- 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 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",
+    })
 end
 
-return table.freeze({
-    cframe = Base.define(24, writeCFrame, readCFrame),
-})
+-- 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 }
+)
+
+return table.freeze(CFrameCodec)

package/src/codec/datatype/Color.luau

@@ -1,18 +1,28 @@
 --!strict
---!native
--- Color3 codec. 3 bytes, 0-255 per channel, clamped.
+--!optimize 2
+-- Color3 codec. 3 bytes, RGB u8 per channel, clamped.
 
 local Base = require(script.Parent.Parent.Base)
 
+-- Private -------------------------------------------------------------
+
 local round = math.round
 local clamp = math.clamp
 
-return table.freeze({
-    color3 = Base.define(3, function(b: buffer, o: number, v: Color3): ()
-        buffer.writeu8(b, o, round(clamp(v.R, 0, 1) * 255))
-        buffer.writeu8(b, o + 1, round(clamp(v.G, 0, 1) * 255))
-        buffer.writeu8(b, o + 2, round(clamp(v.B, 0, 1) * 255))
-    end, function(b: buffer, o: number): Color3
-        return Color3.fromRGB(buffer.readu8(b, o), buffer.readu8(b, o + 1), buffer.readu8(b, o + 2))
-    end),
-})
+-- Public --------------------------------------------------------------
+
+local ColorCodec = {}
+
+ColorCodec.color3 = Base.define(3, function(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
+    return Color3.fromRGB(
+        buffer.readu8(b, off),
+        buffer.readu8(b, off + 1),
+        buffer.readu8(b, off + 2)
+    )
+end, { _typeCheck = "Color3" })
+
+return table.freeze(ColorCodec)

package/src/codec/datatype/Instance.luau

@@ -1,52 +1,59 @@
 --!strict
---!native
+--!optimize 2
 -- Instance codec via sidecar reference array.
 
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Base = require(script.Parent.Parent.Base)
 local Types = require(script.Parent.Parent.Parent.Types)
 
-type ChannelState = Types.ChannelState
+-- Private -------------------------------------------------------------
 
-local alloc = Channel.alloc
+local alloc = Base.alloc
+local writeu16 = buffer.writeu16
+local readu16 = buffer.readu16
 
 -- Public --------------------------------------------------------------
 
 local InstanceCodec = {}
 
+-- No _directWrite/_directRead: write needs ch.refs, so structs can't use the all-direct path
 InstanceCodec.inst = table.freeze({
     _size = 2,
-    write = function(ch: ChannelState, value: Instance): ()
-        local refs = ch.refs
-        local idx = #refs + 1
-        if idx > 65535 then
-            error(`[Lync] Instance ref overflow: {idx} exceeds u16 max`)
+    _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
 
-        refs[idx] = value
+        ch.refs[idx] = value
+        ch.refCount = idx
 
-        local c = ch.cursor
-        if c + 2 > ch.size then
+        local cursor = ch.cursor
+        if cursor + 2 > ch.size then
             alloc(ch, 2)
         end
-        buffer.writeu16(ch.buff, c, idx)
-        ch.cursor = c + 2
+        writeu16(ch.buff, cursor, idx)
+        ch.cursor = cursor + 2
     end,
+
     read = function(src: buffer, pos: number, refs: { Instance }?): (Instance, number)
-        local idx = buffer.readu16(src, pos)
         if not refs then
-            error("[Lync] Instance read requires refs array")
+            error("[Lync] Instance: read requires refs array")
         end
 
-        local inst = refs[idx]
-        if not inst then
-            error(`[Lync] Instance ref index out of bounds: {idx}`)
+        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] Invalid ref: expected Instance")
+            error("[Lync] Instance: invalid ref (expected Instance)")
         end
 
         return inst, 2
     end,
-})
+} :: any)
 
 return table.freeze(InstanceCodec)

package/src/codec/datatype/IntVector.luau

@@ -1,25 +1,37 @@
 --!strict
---!native
--- Vector2int16(4B) and Vector3int16(6B) codecs.
+--!optimize 2
+-- Vector2int16 (4 bytes) and Vector3int16 (6 bytes) codecs.
 
 local Base = require(script.Parent.Parent.Base)
 
-return table.freeze({
-    vec2int16 = Base.define(4, function(b: buffer, o: number, v: Vector2int16): ()
-        buffer.writei16(b, o, v.X)
-        buffer.writei16(b, o + 2, v.Y)
-    end, function(b: buffer, o: number): Vector2int16
-        return Vector2int16.new(buffer.readi16(b, o), buffer.readi16(b, o + 2))
-    end),
-    vec3int16 = Base.define(6, function(b: buffer, o: number, v: Vector3int16): ()
-        buffer.writei16(b, o, v.X)
-        buffer.writei16(b, o + 2, v.Y)
-        buffer.writei16(b, o + 4, v.Z)
-    end, function(b: buffer, o: number): Vector3int16
-        return Vector3int16.new(
-            buffer.readi16(b, o),
-            buffer.readi16(b, o + 2),
-            buffer.readi16(b, o + 4)
-        )
-    end),
-})
+-- 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 IntVectorCodec = {}
+
+IntVectorCodec.vec2int16 = Base.define(4, function(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" })
+
+IntVectorCodec.vec3int16 = Base.define(6, function(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" })
+
+return table.freeze(IntVectorCodec)

package/src/codec/datatype/NumberRange.luau

@@ -1,14 +1,23 @@
 --!strict
---!native
--- NumberRange codec. 8 bytes: min f32 + max f32.
+--!optimize 2
+-- NumberRange codec. 8 bytes: Min f32 + Max f32.
 
 local Base = require(script.Parent.Parent.Base)
 
-return table.freeze({
-    numberRange = Base.define(8, function(b: buffer, o: number, v: NumberRange): ()
-        buffer.writef32(b, o, v.Min)
-        buffer.writef32(b, o + 4, v.Max)
-    end, function(b: buffer, o: number): NumberRange
-        return NumberRange.new(buffer.readf32(b, o), buffer.readf32(b, o + 4))
-    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" }
+)
+
+return table.freeze(NumberRangeCodec)

package/src/codec/datatype/Ray.luau

@@ -1,27 +1,31 @@
 --!strict
---!native
--- Ray codec. 24 bytes: origin vec3 + direction vec3.
+--!optimize 2
+-- Ray codec. 24 bytes: origin + direction as 6x f32.
 
 local Base = require(script.Parent.Parent.Base)
 
-return table.freeze({
-    ray = Base.define(24, function(b: buffer, o: number, v: Ray): ()
-        local origin = v.Origin
-        local direction = v.Direction
-        buffer.writef32(b, o, origin.X)
-        buffer.writef32(b, o + 4, origin.Y)
-        buffer.writef32(b, o + 8, origin.Z)
-        buffer.writef32(b, o + 12, direction.X)
-        buffer.writef32(b, o + 16, direction.Y)
-        buffer.writef32(b, o + 20, direction.Z)
-    end, function(b: buffer, o: number): Ray
-        return Ray.new(
-            Vector3.new(buffer.readf32(b, o), buffer.readf32(b, o + 4), buffer.readf32(b, o + 8)),
-            Vector3.new(
-                buffer.readf32(b, o + 12),
-                buffer.readf32(b, o + 16),
-                buffer.readf32(b, o + 20)
-            )
+-- Public --------------------------------------------------------------
+
+local RayCodec = {}
+
+RayCodec.ray = Base.define(24, function(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)
+end, function(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)
         )
-    end),
-})
+    )
+end, { _typeCheck = "Ray" })
+
+return table.freeze(RayCodec)

package/src/codec/datatype/Rect.luau

@@ -1,21 +1,25 @@
 --!strict
---!native
+--!optimize 2
 -- Rect codec. 16 bytes: 4x f32.
 
 local Base = require(script.Parent.Parent.Base)
 
-return table.freeze({
-    rect = Base.define(16, function(b: buffer, o: number, v: Rect): ()
-        buffer.writef32(b, o, v.Min.X)
-        buffer.writef32(b, o + 4, v.Min.Y)
-        buffer.writef32(b, o + 8, v.Max.X)
-        buffer.writef32(b, o + 12, v.Max.Y)
-    end, function(b: buffer, o: number): Rect
-        return Rect.new(
-            buffer.readf32(b, o),
-            buffer.readf32(b, o + 4),
-            buffer.readf32(b, o + 8),
-            buffer.readf32(b, o + 12)
-        )
-    end),
-})
+-- Public --------------------------------------------------------------
+
+local RectCodec = {}
+
+RectCodec.rect = Base.define(16, function(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
+    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" })
+
+return table.freeze(RectCodec)