@axpecter/lync 2.1.1 → 2.2.0

package/src/codec/datatype/String.luau

@@ -1,16 +1,14 @@
 --!strict
 --!native
--- Variable-length string codec with __call for bounded variant.
+-- Variable-length UTF-8 string codec with __call factory for bounded variant.
 
 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 writeu8 = buffer.writeu8
-local readu8 = buffer.readu8
 local INLINE = Varint.INLINE_MAX
 
 local function writeString(ch: Types.ChannelState, value: string): ()
@@ -18,100 +16,72 @@ local function writeString(ch: Types.ChannelState, value: string): ()
     local cursor = ch.cursor
 
     if len <= INLINE then
-        -- Short strings (<= 191 bytes) use a single-byte prefix, avoiding Varint.write overhead
         if cursor + 1 + len > ch.size then
             alloc(ch, 1 + len)
         end
         local b = ch.buff
-        writeu8(b, cursor, len)
+        buffer.writeu8(b, cursor, len)
         if len > 0 then
             buffer.writestring(b, cursor + 1, value)
         end
         ch.cursor = cursor + 1 + len
-    else
-        -- Long strings need multi-byte length encoding
-        Varint.write(ch, len)
-        cursor = ch.cursor
-        if cursor + len > ch.size then
-            alloc(ch, len)
-        end
-        buffer.writestring(ch.buff, cursor, value)
-        ch.cursor = cursor + len
+        return
     end
-end
 
-local function readString(src: buffer, pos: number, _refs: { Instance }?): (string, number)
-    local b0 = readu8(src, pos)
-    local len: number
-    local lenBytes: number
-
-    if b0 <= INLINE then
-        len = b0
-        lenBytes = 1
-    else
-        len, lenBytes = Varint.read(src, pos)
+    Varint.write(ch, len)
+    cursor = ch.cursor
+    if cursor + len > ch.size then
+        alloc(ch, len)
     end
+    buffer.writestring(ch.buff, cursor, value)
+    ch.cursor = cursor + len
+end
 
+local readLengthPrefix = Varint.readLengthPrefix
+
+local function readString(src: buffer, pos: number, _refs: { Instance }?): (string, number)
+    local len, lenBytes = readLengthPrefix(src, pos)
     if len == 0 then
         return "", lenBytes
     end
 
     local dataStart = pos + lenBytes
     if dataStart + len > buffer.len(src) then
-        error("[Lync] String: length exceeds remaining buffer")
+        error("[Lync] String.read: length exceeds remaining buffer")
     end
-
     return buffer.readstring(src, dataStart, len), lenBytes + len
 end
 
--- Bounded variant shares the write function to avoid per-call closure allocation
-local function boundedFactory(_self: any, maxLength: number): Types.InternalCodec<string>
+local function boundedFactory(_self, maxLength: number): Types.InternalCodec<string>
     if maxLength <= 0 then
         error("[Lync] Lync.string: maxLength must be positive")
     end
 
     return table.freeze({
+        _typeCheck = "string",
         write = writeString,
-
-        read = function(src: buffer, pos: number, refs: { Instance }?): (string, number)
-            local b0 = readu8(src, pos)
-            local len: number
-            local lenBytes: number
-
-            if b0 <= INLINE then
-                len = b0
-                lenBytes = 1
-            else
-                len, lenBytes = Varint.read(src, pos)
-            end
-
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
+            local len, lenBytes = readLengthPrefix(src, pos)
             if len > maxLength then
-                error(`[Lync] String: length {len} exceeds max {maxLength}`)
+                error(`[Lync] String.read: length {len} exceeds max {maxLength}`)
             end
-
             if len == 0 then
                 return "", lenBytes
             end
 
             local dataStart = pos + lenBytes
             if dataStart + len > buffer.len(src) then
-                error("[Lync] String: length exceeds remaining buffer")
+                error("[Lync] String.read: length exceeds remaining buffer")
             end
-
             return buffer.readstring(src, dataStart, len), lenBytes + len
         end,
-    } :: any)
+    })
 end
 
--- Public --------------------------------------------------------------
-
-local StringCodec = setmetatable(
-    {
-        write = writeString,
-        read = readString,
-        _typeCheck = "string",
-    } :: any,
-    { __call = boundedFactory }
-)
+-- Public -----------------------------------------------------------------
 
-return StringCodec
+return table.freeze(setmetatable({
+    _typeCheck = "string",
+    write = writeString,
+    read = readString,
+}, table.freeze({ __call = boundedFactory })))

package/src/codec/datatype/UDim.luau

@@ -1,45 +1,44 @@
 --!strict
 --!optimize 2
--- UDim (8 bytes) and UDim2 (16 bytes) codecs.
+-- UDim (8 bytes) and UDim2 (16 bytes) codecs. Scale is f32, Offset is i32.
 
 local Base = require(script.Parent.Parent.Base)
+local Signed = require(script.Parent.Parent.primitive.Signed)
 
--- Public --------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
-local UDimCodec = {}
+local writeI32 = Signed.writeI32
+local readi32 = buffer.readi32
 
-UDimCodec.udim = Base.define(8, function(b: buffer, off: number, value: UDim): ()
+local function writeUDim(b: buffer, off: number, value: UDim): ()
     buffer.writef32(b, off, value.Scale)
-    buffer.writeu32(
-        b,
-        off + 4,
-        if value.Offset < 0 then value.Offset + 0x100000000 else value.Offset
-    )
-end, function(b: buffer, off: number): UDim
-    local rawOff = buffer.readu32(b, off + 4)
-    return UDim.new(
-        buffer.readf32(b, off),
-        if rawOff >= 0x80000000 then rawOff - 0x100000000 else rawOff
-    )
-end, { _typeCheck = "UDim" })
+    writeI32(b, off + 4, value.Offset)
+end
 
-UDimCodec.udim2 = Base.define(16, function(b: buffer, off: number, value: UDim2): ()
-    local x = value.X
-    local y = value.Y
+local function readUDim(b: buffer, off: number): UDim
+    return UDim.new(buffer.readf32(b, off), readi32(b, off + 4))
+end
+
+local function writeUDim2(b: buffer, off: number, value: UDim2): ()
+    local x, y = value.X, value.Y
     buffer.writef32(b, off, x.Scale)
-    buffer.writeu32(b, off + 4, if x.Offset < 0 then x.Offset + 0x100000000 else x.Offset)
+    writeI32(b, off + 4, x.Offset)
     buffer.writef32(b, off + 8, y.Scale)
-    buffer.writeu32(b, off + 12, if y.Offset < 0 then y.Offset + 0x100000000 else y.Offset)
-end, function(b: buffer, off: number): UDim2
-    local xOff = buffer.readu32(b, off + 4)
-    local yOff = buffer.readu32(b, off + 12)
+    writeI32(b, off + 12, y.Offset)
+end
+
+local function readUDim2(b: buffer, off: number): UDim2
     return UDim2.new(
-        UDim.new(buffer.readf32(b, off), if xOff >= 0x80000000 then xOff - 0x100000000 else xOff),
-        UDim.new(
-            buffer.readf32(b, off + 8),
-            if yOff >= 0x80000000 then yOff - 0x100000000 else yOff
-        )
+        UDim.new(buffer.readf32(b, off), readi32(b, off + 4)),
+        UDim.new(buffer.readf32(b, off + 8), readi32(b, off + 12))
     )
-end, { _typeCheck = "UDim2" })
+end
+
+-- Public -----------------------------------------------------------------
+
+local UDimCodec = {}
+
+UDimCodec.udim = Base.define(8, writeUDim, readUDim, { _typeCheck = "UDim" })
+UDimCodec.udim2 = Base.define(16, writeUDim2, readUDim2, { _typeCheck = "UDim2" })
 
 return table.freeze(UDimCodec)

package/src/codec/datatype/Vector.luau

@@ -1,22 +1,25 @@
 --!strict
 --!optimize 2
--- Vector2 and Vector3 codecs with __call for quantized variants.
+-- Vector2 and Vector3 codecs with __call factory for quantized variants.
 
 local Base = require(script.Parent.Parent.Base)
+local Types = require(script.Parent.Parent.Parent.Types)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
+local alloc = Base.alloc
 local ceil = math.ceil
 local clamp = math.clamp
 local round = math.round
-local max = math.max
-local min = math.min
+local maxN = math.max
+local minN = math.min
 
 --[[
-    Shared quantization setup used by both vec2/vec3 __call and Float.luau.
-    Returns compBytes, writeFn, readFn, scale, invScale.
+    Pick the narrowest u8/u16/u32 wire form for a quantized component
+    range. Returns (compBytes, writeFn, readFn, scale, invScale).
 ]]
 local function quantizeSetup(
+    apiName: string,
     rangeMin: number,
     rangeMax: number,
     precision: number
@@ -28,40 +31,24 @@ local function quantizeSetup(
     number
 )
     if rangeMin > rangeMax then
-        error("[Lync] Lync.vec2/vec3: min must be <= max")
+        error(`[Lync] {apiName}: min must be <= max`)
     end
     if precision <= 0 then
-        error("[Lync] Lync.vec2/vec3: precision must be positive")
+        error(`[Lync] {apiName}: precision must be positive`)
     end
 
     local delta = rangeMax - rangeMin
-    local maxInt = min(0xFFFFFFFF, max(1, ceil(delta / precision)))
-
-    local compBytes: number
-    local wfn: (buffer, number, number) -> ()
-    local rfn: (buffer, number) -> number
+    local maxInt = minN(0xFFFFFFFF, maxN(1, ceil(delta / precision)))
 
     if maxInt <= 0xFF then
-        compBytes = 1
-        wfn = buffer.writeu8
-        rfn = buffer.readu8
-    elseif maxInt <= 0xFFFF then
-        compBytes = 2
-        wfn = buffer.writeu16
-        rfn = buffer.readu16
-    else
-        compBytes = 4
-        wfn = buffer.writeu32
-        rfn = buffer.readu32
+        return 1, buffer.writeu8, buffer.readu8, maxInt / delta, delta / maxInt
     end
-
-    local scale = maxInt / delta
-    local invScale = delta / maxInt
-    return compBytes, wfn, rfn, scale, invScale
+    if maxInt <= 0xFFFF then
+        return 2, buffer.writeu16, buffer.readu16, maxInt / delta, delta / maxInt
+    end
+    return 4, buffer.writeu32, buffer.readu32, maxInt / delta, delta / maxInt
 end
 
--- Vec2 ----------------------------------------------------------------
-
 local function writeVec2(b: buffer, off: number, value: Vector2): ()
     buffer.writef32(b, off, value.X)
     buffer.writef32(b, off + 4, value.Y)
@@ -71,29 +58,6 @@ local function readVec2(b: buffer, off: number): Vector2
     return Vector2.new(buffer.readf32(b, off), buffer.readf32(b, off + 4))
 end
 
-local function quantizeVec2(_self: any, rangeMin: number, rangeMax: number, precision: number): any
-    local delta = rangeMax - rangeMin
-    if delta == 0 then
-        local constant = Vector2.new(rangeMin, rangeMin)
-        return Base.zero() :: any -- constant value, zero bytes
-    end
-
-    local compBytes, wfn, rfn, scale, invScale = quantizeSetup(rangeMin, rangeMax, precision)
-    local totalSize = compBytes * 2
-
-    return Base.define(totalSize, function(b: buffer, off: number, value: Vector2): ()
-        wfn(b, off, round(clamp(value.X - rangeMin, 0, delta) * scale))
-        wfn(b, off + compBytes, round(clamp(value.Y - rangeMin, 0, delta) * scale))
-    end, function(b: buffer, off: number): Vector2
-        return Vector2.new(
-            rfn(b, off) * invScale + rangeMin,
-            rfn(b, off + compBytes) * invScale + rangeMin
-        )
-    end, { _typeCheck = "Vector2", _min = rangeMin, _max = rangeMax })
-end
-
--- Vec3 ----------------------------------------------------------------
-
 local function writeVec3(b: buffer, off: number, value: Vector3): ()
     buffer.writef32(b, off, value.X)
     buffer.writef32(b, off + 4, value.Y)
@@ -108,14 +72,46 @@ local function readVec3(b: buffer, off: number): Vector3
     )
 end
 
-local function quantizeVec3(_self: any, rangeMin: number, rangeMax: number, precision: number): any
+local function quantizeVec2(
+    _self,
+    rangeMin: number,
+    rangeMax: number,
+    precision: number
+): Types.InternalCodec<Vector2>
+    if rangeMax - rangeMin == 0 then
+        return Base.constant(Vector2.new(rangeMin, rangeMin))
+    end
+
+    local compBytes, wfn, rfn, scale, invScale =
+        quantizeSetup("Lync.vec2", rangeMin, rangeMax, precision)
+    local totalSize = compBytes * 2
     local delta = rangeMax - rangeMin
-    if delta == 0 then
-        return Base.zero() :: any
+
+    return Base.define(totalSize, function(b: buffer, off: number, value: Vector2): ()
+        wfn(b, off, round(clamp(value.X - rangeMin, 0, delta) * scale))
+        wfn(b, off + compBytes, round(clamp(value.Y - rangeMin, 0, delta) * scale))
+    end, function(b: buffer, off: number): Vector2
+        return Vector2.new(
+            rfn(b, off) * invScale + rangeMin,
+            rfn(b, off + compBytes) * invScale + rangeMin
+        )
+    end, { _typeCheck = "Vector2", _min = rangeMin, _max = rangeMax })
+end
+
+local function quantizeVec3(
+    _self,
+    rangeMin: number,
+    rangeMax: number,
+    precision: number
+): Types.InternalCodec<Vector3>
+    if rangeMax - rangeMin == 0 then
+        return Base.constant(Vector3.new(rangeMin, rangeMin, rangeMin))
     end
 
-    local compBytes, wfn, rfn, scale, invScale = quantizeSetup(rangeMin, rangeMax, precision)
+    local compBytes, wfn, rfn, scale, invScale =
+        quantizeSetup("Lync.vec3", rangeMin, rangeMax, precision)
     local totalSize = compBytes * 3
+    local delta = rangeMax - rangeMin
 
     return Base.define(totalSize, function(b: buffer, off: number, value: Vector3): ()
         wfn(b, off, round(clamp(value.X - rangeMin, 0, delta) * scale))
@@ -130,56 +126,44 @@ local function quantizeVec3(_self: any, rangeMin: number, rangeMax: number, prec
     end, { _typeCheck = "Vector3", _min = rangeMin, _max = rangeMax })
 end
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local VectorCodec = {}
 
-VectorCodec.vec2 = setmetatable(
-    {
-        _size = 8,
-        _directWrite = writeVec2,
-        _directRead = readVec2,
-        _typeCheck = "Vector2",
-
-        write = function(ch: Types.ChannelState, value: Vector2): ()
-            local cursor = ch.cursor
-            if cursor + 8 > ch.size then
-                alloc(ch, 8)
-            end
-            writeVec2(ch.buff, cursor, value)
-            ch.cursor = cursor + 8
-        end,
-
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector2, number)
-            return readVec2(src, pos), 8
-        end,
-    } :: any,
-    { __call = quantizeVec2 }
-)
-
-VectorCodec.vec3 = setmetatable(
-    {
-        _size = 12,
-        _directWrite = writeVec3,
-        _directRead = readVec3,
-        _typeCheck = "Vector3",
-
-        write = function(ch: Types.ChannelState, value: Vector3): ()
-            local cursor = ch.cursor
-            if cursor + 12 > ch.size then
-                alloc(ch, 12)
-            end
-            writeVec3(ch.buff, cursor, value)
-            ch.cursor = cursor + 12
-        end,
-
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector3, number)
-            return readVec3(src, pos), 12
-        end,
-    } :: any,
-    { __call = quantizeVec3 }
-)
-
-VectorCodec.quantizeSetup = quantizeSetup
+VectorCodec.vec2 = table.freeze(setmetatable({
+    _size = 8,
+    _directWrite = writeVec2,
+    _directRead = readVec2,
+    _typeCheck = "Vector2",
+    write = function(ch: Types.ChannelState, value: Vector2): ()
+        local cursor = ch.cursor
+        if cursor + 8 > ch.size then
+            alloc(ch, 8)
+        end
+        writeVec2(ch.buff, cursor, value)
+        ch.cursor = cursor + 8
+    end,
+    read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector2, number)
+        return readVec2(src, pos), 8
+    end,
+}, table.freeze({ __call = quantizeVec2 })))
+
+VectorCodec.vec3 = table.freeze(setmetatable({
+    _size = 12,
+    _directWrite = writeVec3,
+    _directRead = readVec3,
+    _typeCheck = "Vector3",
+    write = function(ch: Types.ChannelState, value: Vector3): ()
+        local cursor = ch.cursor
+        if cursor + 12 > ch.size then
+            alloc(ch, 12)
+        end
+        writeVec3(ch.buff, cursor, value)
+        ch.cursor = cursor + 12
+    end,
+    read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector3, number)
+        return readVec3(src, pos), 12
+    end,
+}, table.freeze({ __call = quantizeVec3 })))
 
 return table.freeze(VectorCodec)