@axpecter/lync 2.0.0 → 2.1.1

package/src/codec/datatype/Region.luau

@@ -1,54 +1,60 @@
 --!strict
---!native
--- Region3(24B) and Region3int16(12B) codecs.
+--!optimize 2
+-- Region3 (24 bytes) and Region3int16 (12 bytes) codecs.
 
 local Base = require(script.Parent.Parent.Base)
 
-local function writeRegion3(b: buffer, o: number, v: Region3): ()
-    local cf = v.CFrame
-    local size = v.Size
-    local halfSize = size * 0.5
-    local pos = cf.Position
-    local minV = pos - halfSize
-    local maxV = pos + halfSize
-    buffer.writef32(b, o, minV.X)
-    buffer.writef32(b, o + 4, minV.Y)
-    buffer.writef32(b, o + 8, minV.Z)
-    buffer.writef32(b, o + 12, maxV.X)
-    buffer.writef32(b, o + 16, maxV.Y)
-    buffer.writef32(b, o + 20, maxV.Z)
+-- 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 readRegion3(b: buffer, o: number): Region3
-    return Region3.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))
-    )
+local function readI16(b: buffer, off: number): number
+    local raw = buffer.readu16(b, off)
+    return if raw >= 0x8000 then raw - 0x10000 else raw
 end
 
-return table.freeze({
-    region3 = Base.define(24, writeRegion3, readRegion3),
-    region3int16 = Base.define(12, function(b: buffer, o: number, v: Region3int16): ()
-        local minV = v.Min
-        local maxV = v.Max
-        buffer.writei16(b, o, minV.X)
-        buffer.writei16(b, o + 2, minV.Y)
-        buffer.writei16(b, o + 4, minV.Z)
-        buffer.writei16(b, o + 6, maxV.X)
-        buffer.writei16(b, o + 8, maxV.Y)
-        buffer.writei16(b, o + 10, maxV.Z)
-    end, function(b: buffer, o: number): Region3int16
-        return Region3int16.new(
-            Vector3int16.new(
-                buffer.readi16(b, o),
-                buffer.readi16(b, o + 2),
-                buffer.readi16(b, o + 4)
-            ),
-            Vector3int16.new(
-                buffer.readi16(b, o + 6),
-                buffer.readi16(b, o + 8),
-                buffer.readi16(b, o + 10)
-            )
+-- Public --------------------------------------------------------------
+
+local RegionCodec = {}
+
+RegionCodec.region3 = Base.define(24, function(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)
+end, function(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)
         )
-    end),
-})
+    )
+end, { _typeCheck = "Region3" })
+
+RegionCodec.region3int16 = Base.define(12, function(b: buffer, off: number, value: Region3int16): ()
+    local minV = value.Min
+    local maxV = value.Max
+    writeI16(b, off, minV.X)
+    writeI16(b, off + 2, minV.Y)
+    writeI16(b, off + 4, minV.Z)
+    writeI16(b, off + 6, maxV.X)
+    writeI16(b, off + 8, maxV.Y)
+    writeI16(b, off + 10, maxV.Z)
+end, function(b: buffer, off: number): Region3int16
+    return Region3int16.new(
+        Vector3int16.new(readI16(b, off), readI16(b, off + 2), readI16(b, off + 4)),
+        Vector3int16.new(readI16(b, off + 6), readI16(b, off + 8), readI16(b, off + 10))
+    )
+end, { _typeCheck = "Region3int16" })
+
+return table.freeze(RegionCodec)

package/src/codec/datatype/Sequence.luau

@@ -1,29 +1,25 @@
 --!strict
---!native
--- NumberSequence and ColorSequence codecs with varint length prefix.
+--!optimize 2
+-- NumberSequence and ColorSequence codecs with varint count.
 
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Base = require(script.Parent.Parent.Base)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
-type ChannelState = Types.ChannelState
-
-local alloc = Channel.alloc
-
--- Constants -----------------------------------------------------------
-
-local NS_STRIDE = 12
-local CS_STRIDE = 7
+-- Private -------------------------------------------------------------
 
+local alloc = Base.alloc
 local round = math.round
 local clamp = math.clamp
 
 -- Public --------------------------------------------------------------
 
-local Sequence = {}
+local SequenceCodec = {}
 
-Sequence.numberSequence = table.freeze({
-    write = function(ch: ChannelState, value: NumberSequence): ()
+SequenceCodec.numberSequence = table.freeze({
+    _typeCheck = "NumberSequence",
+
+    write = function(ch: Types.ChannelState, value: NumberSequence): ()
         local keypoints = value.Keypoints
         local count = #keypoints
         Varint.write(ch, count)
@@ -32,47 +28,54 @@ Sequence.numberSequence = table.freeze({
             return
         end
 
-        local totalBytes = count * NS_STRIDE
-        local c = ch.cursor
-        if c + totalBytes > ch.size then
-            alloc(ch, totalBytes)
+        local bytes = count * 12
+        local cursor = ch.cursor
+        if cursor + bytes > ch.size then
+            alloc(ch, bytes)
         end
-
         local b = ch.buff
+
         for i = 1, count do
             local kp = keypoints[i]
-            buffer.writef32(b, c, kp.Time)
-            buffer.writef32(b, c + 4, kp.Value)
-            buffer.writef32(b, c + 8, kp.Envelope)
-            c += NS_STRIDE
+            local off = cursor + (i - 1) * 12
+            buffer.writef32(b, off, kp.Time)
+            buffer.writef32(b, off + 4, kp.Value)
+            buffer.writef32(b, off + 8, kp.Envelope)
         end
 
-        ch.cursor = c
+        ch.cursor = cursor + bytes
     end,
+
     read = function(src: buffer, pos: number, _refs: { Instance }?): (NumberSequence, number)
         local count, lenBytes = Varint.read(src, pos)
-        local absPos = pos + lenBytes
-
         if count == 0 then
             return NumberSequence.new(0), lenBytes
         end
 
+        local bytes = count * 12
+        local dataStart = pos + lenBytes
+        if dataStart + bytes > buffer.len(src) then
+            error("[Lync] NumberSequence: data exceeds buffer")
+        end
+
         local keypoints = table.create(count)
         for i = 1, count do
+            local off = dataStart + (i - 1) * 12
             keypoints[i] = NumberSequenceKeypoint.new(
-                buffer.readf32(src, absPos),
-                buffer.readf32(src, absPos + 4),
-                buffer.readf32(src, absPos + 8)
+                buffer.readf32(src, off),
+                buffer.readf32(src, off + 4),
+                buffer.readf32(src, off + 8)
             )
-            absPos += NS_STRIDE
         end
 
-        return NumberSequence.new(keypoints), absPos - pos
+        return NumberSequence.new(keypoints), lenBytes + bytes
     end,
-})
+} :: any)
+
+SequenceCodec.colorSequence = table.freeze({
+    _typeCheck = "ColorSequence",
 
-Sequence.colorSequence = table.freeze({
-    write = function(ch: ChannelState, value: ColorSequence): ()
+    write = function(ch: Types.ChannelState, value: ColorSequence): ()
         local keypoints = value.Keypoints
         local count = #keypoints
         Varint.write(ch, count)
@@ -81,48 +84,53 @@ Sequence.colorSequence = table.freeze({
             return
         end
 
-        local totalBytes = count * CS_STRIDE
-        local c = ch.cursor
-        if c + totalBytes > ch.size then
-            alloc(ch, totalBytes)
+        local bytes = count * 7
+        local cursor = ch.cursor
+        if cursor + bytes > ch.size then
+            alloc(ch, bytes)
         end
-
         local b = ch.buff
+
         for i = 1, count do
             local kp = keypoints[i]
-            local color = kp.Value
-            buffer.writef32(b, c, kp.Time)
-            buffer.writeu8(b, c + 4, round(clamp(color.R, 0, 1) * 255))
-            buffer.writeu8(b, c + 5, round(clamp(color.G, 0, 1) * 255))
-            buffer.writeu8(b, c + 6, round(clamp(color.B, 0, 1) * 255))
-            c += CS_STRIDE
+            local off = cursor + (i - 1) * 7
+            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))
         end
 
-        ch.cursor = c
+        ch.cursor = cursor + bytes
     end,
+
     read = function(src: buffer, pos: number, _refs: { Instance }?): (ColorSequence, number)
         local count, lenBytes = Varint.read(src, pos)
-        local absPos = pos + lenBytes
-
         if count == 0 then
             return ColorSequence.new(Color3.new()), lenBytes
         end
 
+        local bytes = count * 7
+        local dataStart = pos + lenBytes
+        if dataStart + bytes > buffer.len(src) then
+            error("[Lync] ColorSequence: data exceeds buffer")
+        end
+
         local keypoints = table.create(count)
         for i = 1, count do
+            local off = dataStart + (i - 1) * 7
             keypoints[i] = ColorSequenceKeypoint.new(
-                buffer.readf32(src, absPos),
+                buffer.readf32(src, off),
                 Color3.fromRGB(
-                    buffer.readu8(src, absPos + 4),
-                    buffer.readu8(src, absPos + 5),
-                    buffer.readu8(src, absPos + 6)
+                    buffer.readu8(src, off + 4),
+                    buffer.readu8(src, off + 5),
+                    buffer.readu8(src, off + 6)
                 )
             )
-            absPos += CS_STRIDE
         end
 
-        return ColorSequence.new(keypoints), absPos - pos
+        return ColorSequence.new(keypoints), lenBytes + bytes
     end,
-})
+} :: any)
 
-return table.freeze(Sequence)
+return table.freeze(SequenceCodec)

package/src/codec/datatype/String.luau

@@ -1,84 +1,117 @@
 --!strict
 --!native
--- Variable-length string codec with varint length prefix.
+-- Variable-length string codec with __call for bounded variant.
 
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Base = require(script.Parent.Parent.Base)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
-type ChannelState = Types.ChannelState
+-- Private -------------------------------------------------------------
 
-local alloc = Channel.alloc
+local alloc = Base.alloc
+local writeu8 = buffer.writeu8
+local readu8 = buffer.readu8
+local INLINE = Varint.INLINE_MAX
 
--- Public --------------------------------------------------------------
-
-local String = {}
+local function writeString(ch: Types.ChannelState, value: string): ()
+    local len = #value
+    local cursor = ch.cursor
 
-String.string = table.freeze({
-    write = function(ch: ChannelState, value: string): ()
-        local len = #value
-
-        if len < 128 then
-            local total = 1 + len
-            local c = ch.cursor
-            if c + total > ch.size then
-                alloc(ch, total)
-            end
-            local b = ch.buff
-            buffer.writeu8(b, c, len)
-            if len > 0 then
-                buffer.writestring(b, c + 1, value)
-            end
-            ch.cursor = c + total
-        else
-            Varint.write(ch, len)
-            local c = ch.cursor
-            if c + len > ch.size then
-                alloc(ch, len)
-            end
-            buffer.writestring(ch.buff, c, value)
-            ch.cursor = c + len
+    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
-    end,
-    read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
-        local len, lenBytes = Varint.read(src, pos)
-        if len == 0 then
-            return "", lenBytes
+        local b = ch.buff
+        writeu8(b, cursor, len)
+        if len > 0 then
+            buffer.writestring(b, cursor + 1, value)
         end
-
-        local remaining = buffer.len(src) - pos - lenBytes
-        if len > remaining then
-            error(`[Lync] String length exceeds buffer: {len} > {remaining}`)
+        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
+    end
+end
+
+local function readString(src: buffer, pos: number, _refs: { Instance }?): (string, number)
+    local b0 = readu8(src, pos)
+    local len: number
+    local lenBytes: number
 
-        return buffer.readstring(src, pos + lenBytes, len), lenBytes + len
-    end,
-})
+    if b0 <= INLINE then
+        len = b0
+        lenBytes = 1
+    else
+        len, lenBytes = Varint.read(src, pos)
+    end
+
+    if len == 0 then
+        return "", lenBytes
+    end
 
-function String.bounded(maxLength: number): any
-    if maxLength <= 0 or maxLength ~= math.floor(maxLength) then
-        error(`[Lync] boundedString maxLength must be a positive integer, got {maxLength}`)
+    local dataStart = pos + lenBytes
+    if dataStart + len > buffer.len(src) then
+        error("[Lync] String: 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>
+    if maxLength <= 0 then
+        error("[Lync] Lync.string: maxLength must be positive")
     end
 
     return table.freeze({
-        write = String.string.write,
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
-            local len, lenBytes = Varint.read(src, pos)
+        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
+
             if len > maxLength then
-                error(`[Lync] String length {len} exceeds max {maxLength}`)
+                error(`[Lync] String: length {len} exceeds max {maxLength}`)
             end
+
             if len == 0 then
                 return "", lenBytes
             end
 
-            local remaining = buffer.len(src) - pos - lenBytes
-            if len > remaining then
-                error(`[Lync] String length exceeds buffer: {len} > {remaining}`)
+            local dataStart = pos + lenBytes
+            if dataStart + len > buffer.len(src) then
+                error("[Lync] String: length exceeds remaining buffer")
             end
 
-            return buffer.readstring(src, pos + lenBytes, len), lenBytes + len
+            return buffer.readstring(src, dataStart, len), lenBytes + len
         end,
-    })
+    } :: any)
 end
 
-return table.freeze(String)
+-- Public --------------------------------------------------------------
+
+local StringCodec = setmetatable(
+    {
+        write = writeString,
+        read = readString,
+        _typeCheck = "string",
+    } :: any,
+    { __call = boundedFactory }
+)
+
+return StringCodec

package/src/codec/datatype/UDim.luau

@@ -1,27 +1,45 @@
 --!strict
---!native
--- UDim(8B) and UDim2(16B) codecs.
+--!optimize 2
+-- UDim (8 bytes) and UDim2 (16 bytes) codecs.
 
 local Base = require(script.Parent.Parent.Base)
 
-return table.freeze({
-    udim = Base.define(8, function(b: buffer, o: number, v: UDim): ()
-        buffer.writef32(b, o, v.Scale)
-        buffer.writei32(b, o + 4, v.Offset)
-    end, function(b: buffer, o: number): UDim
-        return UDim.new(buffer.readf32(b, o), buffer.readi32(b, o + 4))
-    end),
-    udim2 = Base.define(16, function(b: buffer, o: number, v: UDim2): ()
-        local x = v.X
-        local y = v.Y
-        buffer.writef32(b, o, x.Scale)
-        buffer.writei32(b, o + 4, x.Offset)
-        buffer.writef32(b, o + 8, y.Scale)
-        buffer.writei32(b, o + 12, y.Offset)
-    end, function(b: buffer, o: number): UDim2
-        return UDim2.new(
-            UDim.new(buffer.readf32(b, o), buffer.readi32(b, o + 4)),
-            UDim.new(buffer.readf32(b, o + 8), buffer.readi32(b, o + 12))
+-- Public --------------------------------------------------------------
+
+local UDimCodec = {}
+
+UDimCodec.udim = Base.define(8, function(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" })
+
+UDimCodec.udim2 = Base.define(16, function(b: buffer, off: number, value: UDim2): ()
+    local x = value.X
+    local y = value.Y
+    buffer.writef32(b, off, x.Scale)
+    buffer.writeu32(b, off + 4, if x.Offset < 0 then x.Offset + 0x100000000 else 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)
+    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
         )
-    end),
-})
+    )
+end, { _typeCheck = "UDim2" })
+
+return table.freeze(UDimCodec)