@axpecter/lync 2.1.1 → 2.2.0

package/src/codec/meta/Auto.luau

@@ -3,11 +3,10 @@
 -- Self-describing codec. u8 type tag + value payload.
 
 local Base = require(script.Parent.Parent.Base)
-local BoolC = require(script.Parent.Parent.primitive.Bool)
 local BufferC = require(script.Parent.Parent.datatype.Buffer)
 local CFrameC = require(script.Parent.Parent.datatype.CFrame)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
 local ColorC = require(script.Parent.Parent.datatype.Color)
-local Float16C = require(script.Parent.Parent.primitive.Float16)
 local IVC = require(script.Parent.Parent.datatype.IntVector)
 local NRC = require(script.Parent.Parent.datatype.NumberRange)
 local NumberC = require(script.Parent.Parent.primitive.Number)
@@ -15,12 +14,13 @@ local RayC = require(script.Parent.Parent.datatype.Ray)
 local RectC = require(script.Parent.Parent.datatype.Rect)
 local RegionC = require(script.Parent.Parent.datatype.Region)
 local SeqC = require(script.Parent.Parent.datatype.Sequence)
+local Signed = require(script.Parent.Parent.primitive.Signed)
 local Types = require(script.Parent.Parent.Parent.Types)
 local UDimC = require(script.Parent.Parent.datatype.UDim)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 local VecC = require(script.Parent.Parent.datatype.Vector)
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local TAG_NIL = 0
 local TAG_BOOL = 1
@@ -51,68 +51,26 @@ local TAG_NUMSEQ = 25
 local TAG_COLSEQ = 26
 
 local INLINE_MAX = Varint.INLINE_MAX
+local F32_SCRATCH = NumberC._f32Scratch
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
+local writeByte = Channel.writeByte
 local writeu8 = buffer.writeu8
 local readu8 = buffer.readu8
 local floor = math.floor
-local abs = math.abs
-
-local F32_SCRATCH = NumberC._f32Scratch
+local isnan = math.isnan
 
---[[
-    Write dispatch tables: tag → { directWrite, payloadSize }.
-    Used for integer/float types where the codec has _directWrite + _size.
-]]
-local NUM_WRITE: { [number]: (buffer, number, number) -> () } = {
-    [TAG_U8] = buffer.writeu8,
-    [TAG_U16] = buffer.writeu16,
-    [TAG_U32] = buffer.writeu32,
-    [TAG_F32] = buffer.writef32,
-    [TAG_F64] = buffer.writef64,
-}
-
-local NUM_SIZE: { [number]: number } = {
-    [TAG_U8] = 1,
-    [TAG_U16] = 2,
-    [TAG_U32] = 4,
-    [TAG_F32] = 4,
-    [TAG_F64] = 8,
-}
-
--- writei8/i16/i32 are NOT FASTCALL, so we use writeu* with two's complement conversion
-local function writeI8(b: buffer, off: number, v: number): ()
-    writeu8(b, off, if v < 0 then v + 0x100 else v)
-end
-
-local function writeI16(b: buffer, off: number, v: number): ()
-    buffer.writeu16(b, off, if v < 0 then v + 0x10000 else v)
-end
+local writeI8 = Signed.writeI8
+local writeI16 = Signed.writeI16
+local writeI32 = Signed.writeI32
 
-local function writeI32(b: buffer, off: number, v: number): ()
-    buffer.writeu32(b, off, if v < 0 then v + 0x100000000 else v)
-end
-
-NUM_WRITE[TAG_I8] = writeI8
-NUM_WRITE[TAG_I16] = writeI16
-NUM_WRITE[TAG_I32] = writeI32
-NUM_SIZE[TAG_I8] = 1
-NUM_SIZE[TAG_I16] = 2
-NUM_SIZE[TAG_I32] = 4
-
-table.freeze(NUM_WRITE)
-table.freeze(NUM_SIZE)
-
--- Selects the smallest integer/float tag for a number value
 local function selectNumberTag(value: number): number
-    -- NaN always f64
-    if value ~= value then
+    if isnan(value) then
         return TAG_F64
     end
 
-    -- Integer path
     if floor(value) == value then
         if value >= 0 then
             if value <= 0xFF then
@@ -137,23 +95,85 @@ local function selectNumberTag(value: number): number
         end
     end
 
-    -- Float path: try f32 round-trip
+    -- Roblox is single-threaded so a module scratch cannot be aliased.
     buffer.writef32(F32_SCRATCH, 0, value)
     if buffer.readf32(F32_SCRATCH, 0) == value then
         return TAG_F32
     end
-
     return TAG_F64
 end
 
---[[
-    Roblox type dispatch: typeof string → { tag, codec }.
-    For types with _directWrite + _size, we use the fast path.
-]]
-type TypeEntry = {
-    tag: number,
-    codec: Types.InternalCodec<any>,
-}
+local function numberSize(tag: number): number
+    if tag == TAG_U8 or tag == TAG_I8 then
+        return 1
+    end
+    if tag == TAG_U16 or tag == TAG_I16 then
+        return 2
+    end
+    if tag == TAG_U32 or tag == TAG_I32 or tag == TAG_F32 then
+        return 4
+    end
+    return 8
+end
+
+local function writeNumber(b: buffer, off: number, tag: number, value: number): ()
+    if tag == TAG_U8 then
+        buffer.writeu8(b, off, value)
+        return
+    end
+    if tag == TAG_U16 then
+        buffer.writeu16(b, off, value)
+        return
+    end
+    if tag == TAG_U32 then
+        buffer.writeu32(b, off, value)
+        return
+    end
+    if tag == TAG_I8 then
+        writeI8(b, off, value)
+        return
+    end
+    if tag == TAG_I16 then
+        writeI16(b, off, value)
+        return
+    end
+    if tag == TAG_I32 then
+        writeI32(b, off, value)
+        return
+    end
+    if tag == TAG_F32 then
+        buffer.writef32(b, off, value)
+        return
+    end
+    buffer.writef64(b, off, value)
+end
+
+local function readNumber(b: buffer, off: number, tag: number): number
+    if tag == TAG_U8 then
+        return buffer.readu8(b, off)
+    end
+    if tag == TAG_U16 then
+        return buffer.readu16(b, off)
+    end
+    if tag == TAG_U32 then
+        return buffer.readu32(b, off)
+    end
+    if tag == TAG_I8 then
+        return buffer.readi8(b, off)
+    end
+    if tag == TAG_I16 then
+        return buffer.readi16(b, off)
+    end
+    if tag == TAG_I32 then
+        return buffer.readi32(b, off)
+    end
+    if tag == TAG_F32 then
+        return buffer.readf32(b, off)
+    end
+    return buffer.readf64(b, off)
+end
+
+type TypeEntry = { tag: number, codec: Types.InternalCodec<any> }
 
 local TYPE_DISPATCH: { [string]: TypeEntry } = table.freeze({
     Vector2 = { tag = TAG_VEC2, codec = VecC.vec2 },
@@ -171,9 +191,8 @@ local TYPE_DISPATCH: { [string]: TypeEntry } = table.freeze({
     Ray = { tag = TAG_RAY, codec = RayC.ray },
     NumberSequence = { tag = TAG_NUMSEQ, codec = SeqC.numberSequence },
     ColorSequence = { tag = TAG_COLSEQ, codec = SeqC.colorSequence },
-} :: any)
+})
 
--- Read dispatch: tag → codec
 local READ_DISPATCH: { [number]: Types.InternalCodec<any> } = table.freeze({
     [TAG_VEC2] = VecC.vec2,
     [TAG_VEC3] = VecC.vec3,
@@ -190,213 +209,142 @@ local READ_DISPATCH: { [number]: Types.InternalCodec<any> } = table.freeze({
     [TAG_RAY] = RayC.ray,
     [TAG_NUMSEQ] = SeqC.numberSequence,
     [TAG_COLSEQ] = SeqC.colorSequence,
-} :: any)
-
--- Numeric read helpers
-local function readI8(b: buffer, off: number): number
-    local raw = readu8(b, off)
-    return if raw >= 0x80 then raw - 0x100 else raw
-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
-
-local function readI32(b: buffer, off: number): number
-    local raw = buffer.readu32(b, off)
-    return if raw >= 0x80000000 then raw - 0x100000000 else raw
-end
-
-local NUM_READ: { [number]: (buffer, number) -> number } = table.freeze({
-    [TAG_U8] = buffer.readu8,
-    [TAG_U16] = buffer.readu16,
-    [TAG_U32] = buffer.readu32,
-    [TAG_I8] = readI8,
-    [TAG_I16] = readI16,
-    [TAG_I32] = readI32,
-    [TAG_F32] = buffer.readf32,
-    [TAG_F64] = buffer.readf64,
 })
 
--- Public --------------------------------------------------------------
+local function writeAuto(ch: Types.ChannelState, value: any): ()
+    if value == nil then
+        writeByte(ch, TAG_NIL)
+        return
+    end
 
-local AutoModule = {}
+    local t = typeof(value)
 
-AutoModule.auto = table.freeze({
-    write = function(ch: Types.ChannelState, value: any): ()
-        if value == nil then
-            local cursor = ch.cursor
-            if cursor + 1 > ch.size then
-                alloc(ch, 1)
-            end
-            writeu8(ch.buff, cursor, TAG_NIL)
-            ch.cursor = cursor + 1
-            return
+    if t == "boolean" then
+        local cursor = ch.cursor
+        if cursor + 2 > ch.size then
+            alloc(ch, 2)
         end
+        local b = ch.buff
+        writeu8(b, cursor, TAG_BOOL)
+        writeu8(b, cursor + 1, if value then 1 else 0)
+        ch.cursor = cursor + 2
+        return
+    end
 
-        local t = typeof(value)
-
-        if t == "boolean" then
-            local cursor = ch.cursor
-            if cursor + 2 > ch.size then
-                alloc(ch, 2)
-            end
-            local b = ch.buff
-            writeu8(b, cursor, TAG_BOOL)
-            writeu8(b, cursor + 1, if value then 1 else 0)
-            ch.cursor = cursor + 2
-            return
+    if t == "number" then
+        local tag = selectNumberTag(value)
+        local totalSize = 1 + numberSize(tag)
+        local cursor = ch.cursor
+        if cursor + totalSize > ch.size then
+            alloc(ch, totalSize)
         end
+        local b = ch.buff
+        writeu8(b, cursor, tag)
+        writeNumber(b, cursor + 1, tag, value)
+        ch.cursor = cursor + totalSize
+        return
+    end
 
-        if t == "number" then
-            local tag = selectNumberTag(value)
-            local payloadSize = NUM_SIZE[tag]
-            local totalSize = 1 + payloadSize
-            local cursor = ch.cursor
-            if cursor + totalSize > ch.size then
-                alloc(ch, totalSize)
-            end
-            local b = ch.buff
-            writeu8(b, cursor, tag)
-            NUM_WRITE[tag](b, cursor + 1, value)
-            ch.cursor = cursor + totalSize
-            return
-        end
+    if t == "string" then
+        writeByte(ch, TAG_STRING)
 
-        if t == "string" then
-            local cursor = ch.cursor
-            if cursor + 1 > ch.size then
-                alloc(ch, 1)
-            end
-            writeu8(ch.buff, cursor, TAG_STRING)
-            ch.cursor = cursor + 1
-            -- Inline string write (same as String codec)
-            local len = #value
-            cursor = ch.cursor
-            if len <= INLINE_MAX then
-                if cursor + 1 + len > ch.size then
-                    alloc(ch, 1 + len)
-                end
-                local b = ch.buff
-                writeu8(b, cursor, len)
-                if len > 0 then
-                    buffer.writestring(b, cursor + 1, value)
-                end
-                ch.cursor = cursor + 1 + len
-            else
-                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
+        local len = #value
+        local cursor = ch.cursor
+        if len <= INLINE_MAX then
+            if cursor + 1 + len > ch.size then
+                alloc(ch, 1 + len)
             end
-            return
-        end
-
-        if t == "buffer" then
-            local cursor = ch.cursor
-            if cursor + 1 > ch.size then
-                alloc(ch, 1)
+            local b = ch.buff
+            writeu8(b, cursor, len)
+            if len > 0 then
+                buffer.writestring(b, cursor + 1, value)
             end
-            writeu8(ch.buff, cursor, TAG_BUFFER)
-            ch.cursor = cursor + 1
-            BufferC.buff.write(ch, value)
+            ch.cursor = cursor + 1 + len
             return
         end
-
-        -- Roblox type dispatch
-        local entry = TYPE_DISPATCH[t]
-        if entry then
-            local codec = entry.codec
-            local size = codec._size
-            local dw = codec._directWrite
-
-            if size and dw then
-                -- Fast path: direct write
-                local totalSize = 1 + size
-                local cursor = ch.cursor
-                if cursor + totalSize > ch.size then
-                    alloc(ch, totalSize)
-                end
-                local b = ch.buff
-                writeu8(b, cursor, entry.tag)
-                dw(b, cursor + 1, value)
-                ch.cursor = cursor + totalSize
-            else
-                -- Generic path
-                local cursor = ch.cursor
-                if cursor + 1 > ch.size then
-                    alloc(ch, 1)
-                end
-                writeu8(ch.buff, cursor, entry.tag)
-                ch.cursor = cursor + 1
-                codec.write(ch, value)
-            end
-            return
+        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
 
-        error(`[Lync] Auto: unsupported type "{t}"`)
-    end,
+    if t == "buffer" then
+        writeByte(ch, TAG_BUFFER)
+        BufferC.buff.write(ch, value)
+        return
+    end
 
-    read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
-        local tag = readu8(src, pos)
+    local entry = TYPE_DISPATCH[t]
+    if not entry then
+        error(`[Lync] Auto.write: unsupported type "{t}"`)
+    end
 
-        -- Nil
-        if tag == TAG_NIL then
-            return nil, 1
+    local codec = entry.codec
+    local size = codec._size
+    local dw = codec._directWrite
+    if size and dw then
+        local totalSize = 1 + size
+        local cursor = ch.cursor
+        if cursor + totalSize > ch.size then
+            alloc(ch, totalSize)
         end
+        local b = ch.buff
+        writeu8(b, cursor, entry.tag)
+        dw(b, cursor + 1, value)
+        ch.cursor = cursor + totalSize
+        return
+    end
 
-        -- Bool
-        if tag == TAG_BOOL then
-            return readu8(src, pos + 1) ~= 0, 2
-        end
+    writeByte(ch, entry.tag)
+    codec.write(ch, value)
+end
 
-        -- Numeric types (tags 2-9)
-        local numRead = NUM_READ[tag]
-        if numRead then
-            local payloadSize = NUM_SIZE[tag]
-            return numRead(src, pos + 1), 1 + payloadSize
-        end
+local function readAuto(src: buffer, pos: number, refs: { Instance }?): (any, number)
+    local tag = readu8(src, pos)
 
-        -- String
-        if tag == TAG_STRING then
-            local b0 = readu8(src, pos + 1)
-            local len: number
-            local lenBytes: number
-
-            if b0 <= INLINE_MAX then
-                len = b0
-                lenBytes = 1
-            else
-                len, lenBytes = Varint.read(src, pos + 1)
-            end
+    if tag == TAG_NIL then
+        return nil, 1
+    end
+    if tag == TAG_BOOL then
+        return readu8(src, pos + 1) ~= 0, 2
+    end
 
-            if len == 0 then
-                return "", 1 + lenBytes
-            end
+    if tag >= TAG_U8 and tag <= TAG_F64 then
+        return readNumber(src, pos + 1, tag), 1 + numberSize(tag)
+    end
 
-            local dataStart = pos + 1 + lenBytes
-            return buffer.readstring(src, dataStart, len), 1 + lenBytes + len
+    if tag == TAG_STRING then
+        local len, lenBytes = Varint.readLengthPrefix(src, pos + 1)
+        if len == 0 then
+            return "", 1 + lenBytes
         end
+        return buffer.readstring(src, pos + 1 + lenBytes, len), 1 + lenBytes + len
+    end
 
-        -- Buffer
-        if tag == TAG_BUFFER then
-            local value, consumed = BufferC.buff.read(src, pos + 1, refs)
-            return value, 1 + consumed
-        end
+    if tag == TAG_BUFFER then
+        local value, consumed = BufferC.buff.read(src, pos + 1, refs)
+        return value, 1 + consumed
+    end
 
-        -- Roblox types
-        local codec = READ_DISPATCH[tag]
-        if codec then
-            local value, consumed = codec.read(src, pos + 1, refs)
-            return value, 1 + consumed
-        end
+    local codec = READ_DISPATCH[tag]
+    if not codec then
+        error(`[Lync] Auto.read: unknown tag {tag}`)
+    end
+    local value, consumed = codec.read(src, pos + 1, refs)
+    return value, 1 + consumed
+end
 
-        error(`[Lync] Auto: unknown tag {tag}`)
-    end,
-} :: any)
+-- Public -----------------------------------------------------------------
+
+local AutoModule = {}
+
+AutoModule.auto = table.freeze({
+    write = writeAuto,
+    read = readAuto,
+})
 
 return table.freeze(AutoModule)

package/src/codec/meta/Bitfield.luau

@@ -1,38 +1,54 @@
 --!strict
 --!native
--- Sub-byte packing. 1 to 32 bits across bool/uint/int fields.
+-- Sub-byte packing. 1 to 32 bits across bool / uint / int fields.
 
 local Base = require(script.Parent.Parent.Base)
+local Types = require(script.Parent.Parent.Parent.Types)
 
--- Private -------------------------------------------------------------
+-- Constants --------------------------------------------------------------
+
+local TYPE_BOOL = 0
+local TYPE_UINT = 1
+local TYPE_INT = 2
+
+-- Private ----------------------------------------------------------------
 
 local band = bit32.band
 local bor = bit32.bor
 local lshift = bit32.lshift
 local rshift = bit32.rshift
 
--- Field type constants
-local TYPE_BOOL = 0
-local TYPE_UINT = 1
-local TYPE_INT = 2
+--[[
+    Width-aware mask: bit32.lshift(1, 32) returns 0, so 32-bit fields
+    need the all-ones mask explicitly. Sign-extension constants for int
+    fields use 2^(width-1) and 2^width via numeric exponentiation so
+    width=32 still produces 0x80000000 / 0x100000000 correctly.
+]]
+local function widthMask(width: number): number
+    if width >= 32 then
+        return 0xFFFFFFFF
+    end
+    return lshift(1, width) - 1
+end
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Bitfield = {}
 
-function Bitfield.define(schema: { [string]: { type: string, width: number? } }): any
-    -- Collect and sort keys alphabetically
-    local keys = {}
+export type FieldSpec = { type: "bool" | "uint" | "int", width: number? }
+
+function Bitfield.define(schema: { [string]: FieldSpec }): Types.InternalCodec<any>
+    local keys: { string } = {}
     for key in schema do
         table.insert(keys, key)
     end
     table.sort(keys)
 
-    if #keys == 0 then
+    local fieldCount = #keys
+    if fieldCount == 0 then
         error("[Lync] Lync.bitfield: requires at least one field")
     end
 
-    local fieldCount = #keys
     local fieldKeys = table.create(fieldCount)
     local fieldTypes = table.create(fieldCount)
     local fieldOffsets = table.create(fieldCount)
@@ -59,7 +75,7 @@ function Bitfield.define(schema: { [string]: { type: string, width: number? } })
                 error(`[Lync] Lync.bitfield: field "{key}" uint width must be 1-32`)
             end
             fieldTypes[i] = TYPE_UINT
-            fieldMasks[i] = lshift(1, width) - 1
+            fieldMasks[i] = widthMask(width)
             fieldSignBit[i] = 0
             fieldSignExt[i] = 0
             totalBits += width
@@ -69,12 +85,12 @@ function Bitfield.define(schema: { [string]: { type: string, width: number? } })
                 error(`[Lync] Lync.bitfield: field "{key}" int width must be 2-32`)
             end
             fieldTypes[i] = TYPE_INT
-            fieldMasks[i] = lshift(1, width) - 1
-            fieldSignBit[i] = lshift(1, width - 1)
-            fieldSignExt[i] = lshift(1, width)
+            fieldMasks[i] = widthMask(width)
+            fieldSignBit[i] = 2 ^ (width - 1)
+            fieldSignExt[i] = 2 ^ width
             totalBits += width
         else
-            error(`[Lync] Lync.bitfield: unknown field type "{spec.type}"`)
+            error(`[Lync] Lync.bitfield: field "{key}" has unknown type "{spec.type}"`)
         end
     end
 
@@ -82,26 +98,17 @@ function Bitfield.define(schema: { [string]: { type: string, width: number? } })
         error(`[Lync] Lync.bitfield: total exceeds 32 bits ({totalBits})`)
     end
 
-    -- Determine wire size
     local wireBytes: number
     local wfn: (buffer, number, number) -> ()
     local rfn: (buffer, number) -> number
-
     if totalBits <= 8 then
-        wireBytes = 1
-        wfn = buffer.writeu8
-        rfn = buffer.readu8
+        wireBytes, wfn, rfn = 1, buffer.writeu8, buffer.readu8
     elseif totalBits <= 16 then
-        wireBytes = 2
-        wfn = buffer.writeu16
-        rfn = buffer.readu16
+        wireBytes, wfn, rfn = 2, buffer.writeu16, buffer.readu16
     else
-        wireBytes = 4
-        wfn = buffer.writeu32
-        rfn = buffer.readu32
+        wireBytes, wfn, rfn = 4, buffer.writeu32, buffer.readu32
     end
 
-    -- Freeze all descriptor arrays
     table.freeze(fieldKeys)
     table.freeze(fieldTypes)
     table.freeze(fieldOffsets)
@@ -125,22 +132,16 @@ function Bitfield.define(schema: { [string]: { type: string, width: number? } })
     end, function(b: buffer, off: number): any
         local packed = rfn(b, off)
         local result: { [string]: any } = {}
-
         for i = 1, fieldCount do
             local raw = band(rshift(packed, fieldOffsets[i]), fieldMasks[i])
             if fieldTypes[i] == TYPE_BOOL then
                 result[fieldKeys[i]] = raw ~= 0
             elseif fieldTypes[i] == TYPE_INT then
-                if raw >= fieldSignBit[i] then
-                    result[fieldKeys[i]] = raw - fieldSignExt[i]
-                else
-                    result[fieldKeys[i]] = raw
-                end
+                result[fieldKeys[i]] = if raw >= fieldSignBit[i] then raw - fieldSignExt[i] else raw
             else
                 result[fieldKeys[i]] = raw
             end
         end
-
         return result
     end)
 end