@axpecter/lync 2.2.1 → 2.3.1

package/src/codec/datatype/Sequence.luau

@@ -1,8 +1,10 @@
 --!strict
---!optimize 2
+--!native
 -- NumberSequence (12B/keypoint) and ColorSequence (7B/keypoint) codecs.
 
 local Base = require(script.Parent.Parent.Base)
+local Constants = require(script.Parent.Parent.Parent.util.Constants)
+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)
 
@@ -14,34 +16,88 @@ local MAX_KEYPOINTS = 20
 
 -- Private ----------------------------------------------------------------
 
+local U8_MAX = Constants.U8_MAX
 local alloc = Base.alloc
+local writef32 = buffer.writef32
+local readf32 = buffer.readf32
+local writeu8 = buffer.writeu8
+local readu8 = buffer.readu8
 local round = math.round
 local clamp = math.clamp
-
-local function writeNumberSequence(ch: Types.ChannelState, value: NumberSequence): ()
-    local keypoints = value.Keypoints
-    local count = #keypoints
-    Varint.write(ch, count)
+local varintRead = Varint.read
+local varintWrite = Varint.write
+
+--[[
+    Common write prelude: count cap check, varint count, payload alloc.
+    Returns (cursor, b) for the per-keypoint writer; (nil, nil) when count
+    is 0 so callers short-circuit.
+]]
+local function beginSeqWrite(
+    ch: Types.ChannelState,
+    label: string,
+    count: number,
+    kpBytes: number
+): (number?, buffer?)
+    if count > MAX_KEYPOINTS then
+        Log.error(`{label}.write: keypoint count {count} exceeds Roblox limit {MAX_KEYPOINTS}`)
+    end
+    varintWrite(ch, count)
     if count == 0 then
-        return
+        return nil, nil
     end
 
-    local bytes = count * NUMSEQ_KP_BYTES
+    local bytes = count * kpBytes
     local cursor = ch.cursor
     if cursor + bytes > ch.size then
         alloc(ch, bytes)
     end
-    local b = ch.buff
+    ch.cursor = cursor + bytes
+    return cursor, ch.buff
+end
 
-    local off = cursor
+--[[
+    Common read prelude: varint count, cap check, bounds check. Returns
+    (count, dataStart, lenBytes) for the per-keypoint reader; (0, _, lenBytes)
+    when payload is empty.
+]]
+local function beginSeqRead(
+    src: buffer,
+    pos: number,
+    label: string,
+    kpBytes: number
+): (number, number, number)
+    local count, lenBytes = varintRead(src, pos)
+    if count == 0 then
+        return 0, pos + lenBytes, lenBytes
+    end
+    if count > MAX_KEYPOINTS then
+        Log.error(`{label}.read: keypoint count {count} exceeds Roblox limit {MAX_KEYPOINTS}`)
+    end
+
+    local bytes = count * kpBytes
+    local dataStart = pos + lenBytes
+    if dataStart + bytes > buffer.len(src) then
+        Log.error(`{label}.read: payload {bytes}B exceeds remaining buffer`)
+    end
+    return count, dataStart, lenBytes
+end
+
+local function writeNumberSequence(ch: Types.ChannelState, value: NumberSequence): ()
+    local keypoints = value.Keypoints
+    local count = #keypoints
+    local cursor, b = beginSeqWrite(ch, "NumberSequence", count, NUMSEQ_KP_BYTES)
+    if not cursor then
+        return
+    end
+    local off = cursor :: number
+    local buf = b :: buffer
     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)
+        writef32(buf, off, kp.Time)
+        writef32(buf, off + 4, kp.Value)
+        writef32(buf, off + 8, kp.Envelope)
         off += NUMSEQ_KP_BYTES
     end
-    ch.cursor = cursor + bytes
 end
 
 local function readNumberSequence(
@@ -49,61 +105,42 @@ local function readNumberSequence(
     pos: number,
     _refs: { Instance }?
 ): (NumberSequence, number)
-    local count, lenBytes = Varint.read(src, pos)
+    local count, dataStart, lenBytes = beginSeqRead(src, pos, "NumberSequence", NUMSEQ_KP_BYTES)
     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)
+            readf32(src, off),
+            readf32(src, off + 4),
+            readf32(src, off + 8)
         )
         off += NUMSEQ_KP_BYTES
     end
-    return NumberSequence.new(keypoints), lenBytes + bytes
+    return NumberSequence.new(keypoints), lenBytes + count * NUMSEQ_KP_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
+    local cursor, b = beginSeqWrite(ch, "ColorSequence", count, COLSEQ_KP_BYTES)
+    if not cursor 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
+    local off = cursor :: number
+    local buf = b :: buffer
     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))
+        writef32(buf, off, kp.Time)
+        writeu8(buf, off + 4, round(clamp(c.R, 0, 1) * U8_MAX))
+        writeu8(buf, off + 5, round(clamp(c.G, 0, 1) * U8_MAX))
+        writeu8(buf, off + 6, round(clamp(c.B, 0, 1) * U8_MAX))
         off += COLSEQ_KP_BYTES
     end
-    ch.cursor = cursor + bytes
 end
 
 local function readColorSequence(
@@ -111,36 +148,21 @@ local function readColorSequence(
     pos: number,
     _refs: { Instance }?
 ): (ColorSequence, number)
-    local count, lenBytes = Varint.read(src, pos)
+    local count, dataStart, lenBytes = beginSeqRead(src, pos, "ColorSequence", COLSEQ_KP_BYTES)
     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)
-            )
+            readf32(src, off),
+            Color3.fromRGB(readu8(src, off + 4), readu8(src, off + 5), readu8(src, off + 6))
         )
         off += COLSEQ_KP_BYTES
     end
-    return ColorSequence.new(keypoints), lenBytes + bytes
+    return ColorSequence.new(keypoints), lenBytes + count * COLSEQ_KP_BYTES
 end
 
 -- Public -----------------------------------------------------------------

package/src/codec/datatype/String.luau

@@ -1,21 +1,23 @@
 --!strict
 --!native
--- Variable-length UTF-8 string codec with __call factory for bounded variant.
+-- UTF-8 string codec. __call yields a length-bounded variant.
 
 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 writeString(ch: Types.ChannelState, value: string): ()
     local 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
@@ -47,23 +49,28 @@ local function readString(src: buffer, pos: number, _refs: { Instance }?): (stri
 
     local dataStart = pos + lenBytes
     if dataStart + len > buffer.len(src) then
-        error("[Lync] String.read: length exceeds remaining buffer")
+        Log.error(`length {len}B exceeds remaining buffer`)
     end
     return buffer.readstring(src, dataStart, len), lenBytes + len
 end
 
+-- _maxStringLength lets Gate.validate reject oversized values send-side.
 local function boundedFactory(_self, maxLength: number): Types.InternalCodec<string>
-    if maxLength <= 0 then
-        error("[Lync] Lync.string: maxLength must be positive")
-    end
+    Log.assert(maxLength > 0, "maxLength must be positive")
 
     return table.freeze({
         _typeCheck = "string",
-        write = writeString,
+        _maxStringLength = maxLength,
+        write = function(ch: Types.ChannelState, value: string): ()
+            if #value > maxLength then
+                Log.error(`length {#value} exceeds max {maxLength}`)
+            end
+            writeString(ch, value)
+        end,
         read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
             local len, lenBytes = readLengthPrefix(src, pos)
             if len > maxLength then
-                error(`[Lync] String.read: length {len} exceeds max {maxLength}`)
+                Log.error(`length {len} exceeds max {maxLength}`)
             end
             if len == 0 then
                 return "", lenBytes
@@ -71,7 +78,7 @@ local function boundedFactory(_self, maxLength: number): Types.InternalCodec<str
 
             local dataStart = pos + lenBytes
             if dataStart + len > buffer.len(src) then
-                error("[Lync] String.read: length exceeds remaining buffer")
+                Log.error(`length {len}B exceeds remaining buffer`)
             end
             return buffer.readstring(src, dataStart, len), lenBytes + len
         end,

package/src/codec/datatype/UDim.luau

@@ -1,36 +1,38 @@
 --!strict
---!optimize 2
--- UDim (8 bytes) and UDim2 (16 bytes) codecs. Scale is f32, Offset is i32.
+--!native
+-- UDim (8B) and UDim2 (16B) codecs. Scale = f32, Offset = i32.
 
 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 writeI32 = Signed.writeI32
 local readi32 = buffer.readi32
 
 local function writeUDim(b: buffer, off: number, value: UDim): ()
-    buffer.writef32(b, off, value.Scale)
+    writef32(b, off, value.Scale)
     writeI32(b, off + 4, value.Offset)
 end
 
 local function readUDim(b: buffer, off: number): UDim
-    return UDim.new(buffer.readf32(b, off), readi32(b, off + 4))
+    return UDim.new(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)
+    writef32(b, off, x.Scale)
     writeI32(b, off + 4, x.Offset)
-    buffer.writef32(b, off + 8, y.Scale)
+    writef32(b, off + 8, y.Scale)
     writeI32(b, off + 12, y.Offset)
 end
 
 local function readUDim2(b: buffer, off: number): UDim2
     return UDim2.new(
-        UDim.new(buffer.readf32(b, off), readi32(b, off + 4)),
-        UDim.new(buffer.readf32(b, off + 8), readi32(b, off + 12))
+        UDim.new(readf32(b, off), readi32(b, off + 4)),
+        UDim.new(readf32(b, off + 8), readi32(b, off + 12))
     )
 end
 

package/src/codec/datatype/Vector.luau

@@ -1,75 +1,36 @@
 --!strict
---!optimize 2
--- Vector2 and Vector3 codecs with __call factory for quantized variants.
+--!native
+-- Vector2 / Vector3 codecs. __call yields a quantized variant.
 
 local Base = require(script.Parent.Parent.Base)
+local Quantize = require(script.Parent.Parent.Parent.util.Quantize)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
-local ceil = math.ceil
+local writef32 = buffer.writef32
+local readf32 = buffer.readf32
 local clamp = math.clamp
 local round = math.round
-local maxN = math.max
-local minN = math.min
-
---[[
-    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
-): (
-    number,
-    (buffer, number, number) -> (),
-    (buffer, number) -> number,
-    number,
-    number
-)
-    if rangeMin > rangeMax then
-        error(`[Lync] {apiName}: min must be <= max`)
-    end
-    if precision <= 0 then
-        error(`[Lync] {apiName}: precision must be positive`)
-    end
-
-    local delta = rangeMax - rangeMin
-    local maxInt = minN(0xFFFFFFFF, maxN(1, ceil(delta / precision)))
-
-    if maxInt <= 0xFF then
-        return 1, buffer.writeu8, buffer.readu8, maxInt / delta, delta / maxInt
-    end
-    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
 
 local function writeVec2(b: buffer, off: number, value: Vector2): ()
-    buffer.writef32(b, off, value.X)
-    buffer.writef32(b, off + 4, value.Y)
+    writef32(b, off, value.X)
+    writef32(b, off + 4, value.Y)
 end
 
 local function readVec2(b: buffer, off: number): Vector2
-    return Vector2.new(buffer.readf32(b, off), buffer.readf32(b, off + 4))
+    return Vector2.new(readf32(b, off), readf32(b, off + 4))
 end
 
 local function writeVec3(b: buffer, off: number, value: Vector3): ()
-    buffer.writef32(b, off, value.X)
-    buffer.writef32(b, off + 4, value.Y)
-    buffer.writef32(b, off + 8, value.Z)
+    writef32(b, off, value.X)
+    writef32(b, off + 4, value.Y)
+    writef32(b, off + 8, value.Z)
 end
 
 local function readVec3(b: buffer, off: number): Vector3
-    return Vector3.new(
-        buffer.readf32(b, off),
-        buffer.readf32(b, off + 4),
-        buffer.readf32(b, off + 8)
-    )
+    return Vector3.new(readf32(b, off), readf32(b, off + 4), readf32(b, off + 8))
 end
 
 local function quantizeVec2(
@@ -78,14 +39,14 @@ local function quantizeVec2(
     rangeMax: number,
     precision: number
 ): Types.InternalCodec<Vector2>
+    -- Degenerate range: emit nothing, decode to the constant.
     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 compBytes, wfn, rfn, scale, invScale, delta =
+        Quantize.setup("Lync.vec2", rangeMin, rangeMax, precision)
     local totalSize = compBytes * 2
-    local delta = rangeMax - rangeMin
 
     return Base.define(totalSize, function(b: buffer, off: number, value: Vector2): ()
         wfn(b, off, round(clamp(value.X - rangeMin, 0, delta) * scale))
@@ -108,20 +69,20 @@ local function quantizeVec3(
         return Base.constant(Vector3.new(rangeMin, rangeMin, rangeMin))
     end
 
-    local compBytes, wfn, rfn, scale, invScale =
-        quantizeSetup("Lync.vec3", rangeMin, rangeMax, precision)
+    local compBytes, wfn, rfn, scale, invScale, delta =
+        Quantize.setup("Lync.vec3", rangeMin, rangeMax, precision)
     local totalSize = compBytes * 3
-    local delta = rangeMax - rangeMin
+    local off2 = compBytes * 2
 
     return Base.define(totalSize, function(b: buffer, off: number, value: Vector3): ()
         wfn(b, off, round(clamp(value.X - rangeMin, 0, delta) * scale))
         wfn(b, off + compBytes, round(clamp(value.Y - rangeMin, 0, delta) * scale))
-        wfn(b, off + compBytes * 2, round(clamp(value.Z - rangeMin, 0, delta) * scale))
+        wfn(b, off + off2, round(clamp(value.Z - rangeMin, 0, delta) * scale))
     end, function(b: buffer, off: number): Vector3
         return Vector3.new(
             rfn(b, off) * invScale + rangeMin,
             rfn(b, off + compBytes) * invScale + rangeMin,
-            rfn(b, off + compBytes * 2) * invScale + rangeMin
+            rfn(b, off + off2) * invScale + rangeMin
         )
     end, { _typeCheck = "Vector3", _min = rangeMin, _max = rangeMax })
 end