@axpecter/lync 2.2.1 → 2.3.2

package/src/codec/meta/Auto.luau

@@ -8,6 +8,7 @@ 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 IVC = require(script.Parent.Parent.datatype.IntVector)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 local NRC = require(script.Parent.Parent.datatype.NumberRange)
 local NumberC = require(script.Parent.Parent.primitive.Number)
 local RayC = require(script.Parent.Parent.datatype.Ray)
@@ -53,6 +54,78 @@ local TAG_COLSEQ = 26
 local INLINE_MAX = Varint.INLINE_MAX
 local F32_SCRATCH = NumberC._f32Scratch
 
+-- Tag -> numeric primitive dispatch tables.
+local NUM_SIZE: { [number]: number } = table.freeze({
+    [TAG_U8] = 1,
+    [TAG_I8] = 1,
+    [TAG_U16] = 2,
+    [TAG_I16] = 2,
+    [TAG_U32] = 4,
+    [TAG_I32] = 4,
+    [TAG_F32] = 4,
+    [TAG_F64] = 8,
+})
+
+local NUM_WRITE: { [number]: (buffer, number, number) -> () } = table.freeze({
+    [TAG_U8] = buffer.writeu8,
+    [TAG_U16] = buffer.writeu16,
+    [TAG_U32] = buffer.writeu32,
+    [TAG_I8] = Signed.writeI8,
+    [TAG_I16] = Signed.writeI16,
+    [TAG_I32] = Signed.writeI32,
+    [TAG_F32] = buffer.writef32,
+    [TAG_F64] = buffer.writef64,
+})
+
+local NUM_READ: { [number]: (buffer, number) -> number } = table.freeze({
+    [TAG_U8] = buffer.readu8,
+    [TAG_U16] = buffer.readu16,
+    [TAG_U32] = buffer.readu32,
+    [TAG_I8] = buffer.readi8,
+    [TAG_I16] = buffer.readi16,
+    [TAG_I32] = buffer.readi32,
+    [TAG_F32] = buffer.readf32,
+    [TAG_F64] = buffer.readf64,
+})
+
+type TypeEntry = { tag: number, codec: Types.InternalCodec<any> }
+
+local TYPE_DISPATCH: { [string]: TypeEntry } = table.freeze({
+    Vector2 = { tag = TAG_VEC2, codec = VecC.vec2 },
+    Vector3 = { tag = TAG_VEC3, codec = VecC.vec3 },
+    Color3 = { tag = TAG_COLOR3, codec = ColorC.color3 },
+    CFrame = { tag = TAG_CFRAME, codec = CFrameC.cframe },
+    UDim = { tag = TAG_UDIM, codec = UDimC.udim },
+    UDim2 = { tag = TAG_UDIM2, codec = UDimC.udim2 },
+    NumberRange = { tag = TAG_NUMRANGE, codec = NRC.numberRange },
+    Rect = { tag = TAG_RECT, codec = RectC.rect },
+    Vector2int16 = { tag = TAG_V2I16, codec = IVC.vec2int16 },
+    Vector3int16 = { tag = TAG_V3I16, codec = IVC.vec3int16 },
+    Region3 = { tag = TAG_REGION3, codec = RegionC.region3 },
+    Region3int16 = { tag = TAG_R3I16, codec = RegionC.region3int16 },
+    Ray = { tag = TAG_RAY, codec = RayC.ray },
+    NumberSequence = { tag = TAG_NUMSEQ, codec = SeqC.numberSequence },
+    ColorSequence = { tag = TAG_COLSEQ, codec = SeqC.colorSequence },
+})
+
+local READ_DISPATCH: { [number]: Types.InternalCodec<any> } = table.freeze({
+    [TAG_VEC2] = VecC.vec2,
+    [TAG_VEC3] = VecC.vec3,
+    [TAG_COLOR3] = ColorC.color3,
+    [TAG_CFRAME] = CFrameC.cframe,
+    [TAG_UDIM] = UDimC.udim,
+    [TAG_UDIM2] = UDimC.udim2,
+    [TAG_NUMRANGE] = NRC.numberRange,
+    [TAG_RECT] = RectC.rect,
+    [TAG_V2I16] = IVC.vec2int16,
+    [TAG_V3I16] = IVC.vec3int16,
+    [TAG_REGION3] = RegionC.region3,
+    [TAG_R3I16] = RegionC.region3int16,
+    [TAG_RAY] = RayC.ray,
+    [TAG_NUMSEQ] = SeqC.numberSequence,
+    [TAG_COLSEQ] = SeqC.colorSequence,
+})
+
 -- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
@@ -62,10 +135,12 @@ local readu8 = buffer.readu8
 local floor = math.floor
 local isnan = math.isnan
 
-local writeI8 = Signed.writeI8
-local writeI16 = Signed.writeI16
-local writeI32 = Signed.writeI32
-
+--[[
+    Pick the narrowest tag for a number. NaN forces F64 (no integer or F32
+    can represent it). Integers walk u8 -> u16 -> u32 / i8 -> i16 -> i32; non-
+    integers try f32 by round-tripping through scratch (see Number.luau) and
+    fall through to f64 if precision is lost.
+]]
 local function selectNumberTag(value: number): number
     if isnan(value) then
         return TAG_F64
@@ -95,7 +170,6 @@ local function selectNumberTag(value: number): number
         end
     end
 
-    -- 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
@@ -103,114 +177,6 @@ local function selectNumberTag(value: number): number
     return TAG_F64
 end
 
-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 },
-    Vector3 = { tag = TAG_VEC3, codec = VecC.vec3 },
-    Color3 = { tag = TAG_COLOR3, codec = ColorC.color3 },
-    CFrame = { tag = TAG_CFRAME, codec = CFrameC.cframe },
-    UDim = { tag = TAG_UDIM, codec = UDimC.udim },
-    UDim2 = { tag = TAG_UDIM2, codec = UDimC.udim2 },
-    NumberRange = { tag = TAG_NUMRANGE, codec = NRC.numberRange },
-    Rect = { tag = TAG_RECT, codec = RectC.rect },
-    Vector2int16 = { tag = TAG_V2I16, codec = IVC.vec2int16 },
-    Vector3int16 = { tag = TAG_V3I16, codec = IVC.vec3int16 },
-    Region3 = { tag = TAG_REGION3, codec = RegionC.region3 },
-    Region3int16 = { tag = TAG_R3I16, codec = RegionC.region3int16 },
-    Ray = { tag = TAG_RAY, codec = RayC.ray },
-    NumberSequence = { tag = TAG_NUMSEQ, codec = SeqC.numberSequence },
-    ColorSequence = { tag = TAG_COLSEQ, codec = SeqC.colorSequence },
-})
-
-local READ_DISPATCH: { [number]: Types.InternalCodec<any> } = table.freeze({
-    [TAG_VEC2] = VecC.vec2,
-    [TAG_VEC3] = VecC.vec3,
-    [TAG_COLOR3] = ColorC.color3,
-    [TAG_CFRAME] = CFrameC.cframe,
-    [TAG_UDIM] = UDimC.udim,
-    [TAG_UDIM2] = UDimC.udim2,
-    [TAG_NUMRANGE] = NRC.numberRange,
-    [TAG_RECT] = RectC.rect,
-    [TAG_V2I16] = IVC.vec2int16,
-    [TAG_V3I16] = IVC.vec3int16,
-    [TAG_REGION3] = RegionC.region3,
-    [TAG_R3I16] = RegionC.region3int16,
-    [TAG_RAY] = RayC.ray,
-    [TAG_NUMSEQ] = SeqC.numberSequence,
-    [TAG_COLSEQ] = SeqC.colorSequence,
-})
-
 local function writeAuto(ch: Types.ChannelState, value: any): ()
     if value == nil then
         writeByte(ch, TAG_NIL)
@@ -233,15 +199,16 @@ local function writeAuto(ch: Types.ChannelState, value: any): ()
 
     if t == "number" then
         local tag = selectNumberTag(value)
-        local totalSize = 1 + numberSize(tag)
+        local size = NUM_SIZE[tag]
+        local total = 1 + size
         local cursor = ch.cursor
-        if cursor + totalSize > ch.size then
-            alloc(ch, totalSize)
+        if cursor + total > ch.size then
+            alloc(ch, total)
         end
         local b = ch.buff
         writeu8(b, cursor, tag)
-        writeNumber(b, cursor + 1, tag, value)
-        ch.cursor = cursor + totalSize
+        NUM_WRITE[tag](b, cursor + 1, value)
+        ch.cursor = cursor + total
         return
     end
 
@@ -250,6 +217,7 @@ local function writeAuto(ch: Types.ChannelState, value: any): ()
 
         local len = #value
         local cursor = ch.cursor
+        -- Inline single-byte length fast path; matches String.luau.
         if len <= INLINE_MAX then
             if cursor + 1 + len > ch.size then
                 alloc(ch, 1 + len)
@@ -280,22 +248,22 @@ local function writeAuto(ch: Types.ChannelState, value: any): ()
 
     local entry = TYPE_DISPATCH[t]
     if not entry then
-        error(`[Lync] Auto.write: unsupported type "{t}"`)
+        Log.error(`unsupported type "{t}"`)
     end
-
     local codec = entry.codec
     local size = codec._size
     local dw = codec._directWrite
+    -- Fixed-size + direct writer: single alloc + tag + payload.
     if size and dw then
-        local totalSize = 1 + size
+        local total = 1 + size
         local cursor = ch.cursor
-        if cursor + totalSize > ch.size then
-            alloc(ch, totalSize)
+        if cursor + total > ch.size then
+            alloc(ch, total)
         end
         local b = ch.buff
         writeu8(b, cursor, entry.tag)
         dw(b, cursor + 1, value)
-        ch.cursor = cursor + totalSize
+        ch.cursor = cursor + total
         return
     end
 
@@ -314,7 +282,7 @@ local function readAuto(src: buffer, pos: number, refs: { Instance }?): (any, nu
     end
 
     if tag >= TAG_U8 and tag <= TAG_F64 then
-        return readNumber(src, pos + 1, tag), 1 + numberSize(tag)
+        return NUM_READ[tag](src, pos + 1), 1 + NUM_SIZE[tag]
     end
 
     if tag == TAG_STRING then
@@ -332,7 +300,7 @@ local function readAuto(src: buffer, pos: number, refs: { Instance }?): (any, nu
 
     local codec = READ_DISPATCH[tag]
     if not codec then
-        error(`[Lync] Auto.read: unknown tag {tag}`)
+        Log.error(`unknown tag {tag}`)
     end
     local value, consumed = codec.read(src, pos + 1, refs)
     return value, 1 + consumed

package/src/codec/meta/Bitfield.luau

@@ -1,8 +1,9 @@
 --!strict
 --!native
--- Sub-byte packing. 1 to 32 bits across bool / uint / int fields.
+-- Sub-byte packed bool/uint/int fields. Up to 32 bits total per record.
 
 local Base = require(script.Parent.Parent.Base)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Constants --------------------------------------------------------------
@@ -18,12 +19,7 @@ local bor = bit32.bor
 local lshift = bit32.lshift
 local rshift = bit32.rshift
 
---[[
-    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.
-]]
+-- bit32.lshift(1, 32) wraps to 0; force all-ones in the 32-bit case.
 local function widthMask(width: number): number
     if width >= 32 then
         return 0xFFFFFFFF
@@ -38,6 +34,7 @@ local Bitfield = {}
 export type FieldSpec = { type: "bool" | "uint" | "int", width: number? }
 
 function Bitfield.define(schema: { [string]: FieldSpec }): Types.InternalCodec<any>
+    -- Sort field names so bit positions are stable across runs.
     local keys: { string } = {}
     for key in schema do
         table.insert(keys, key)
@@ -45,9 +42,7 @@ function Bitfield.define(schema: { [string]: FieldSpec }): Types.InternalCodec<a
     table.sort(keys)
 
     local fieldCount = #keys
-    if fieldCount == 0 then
-        error("[Lync] Lync.bitfield: requires at least one field")
-    end
+    Log.assert(fieldCount > 0, "requires at least one field")
 
     local fieldKeys = table.create(fieldCount)
     local fieldTypes = table.create(fieldCount)
@@ -72,7 +67,7 @@ function Bitfield.define(schema: { [string]: FieldSpec }): Types.InternalCodec<a
         elseif spec.type == "uint" then
             local width = spec.width
             if not width or width < 1 or width > 32 then
-                error(`[Lync] Lync.bitfield: field "{key}" uint width must be 1-32`)
+                Log.error(`field "{key}" uint width must be 1-32`)
             end
             fieldTypes[i] = TYPE_UINT
             fieldMasks[i] = widthMask(width)
@@ -81,8 +76,9 @@ function Bitfield.define(schema: { [string]: FieldSpec }): Types.InternalCodec<a
             totalBits += width
         elseif spec.type == "int" then
             local width = spec.width
+            -- Min int width is 2: 1 bit can't represent both a sign and a value.
             if not width or width < 2 or width > 32 then
-                error(`[Lync] Lync.bitfield: field "{key}" int width must be 2-32`)
+                Log.error(`field "{key}" int width must be 2-32`)
             end
             fieldTypes[i] = TYPE_INT
             fieldMasks[i] = widthMask(width)
@@ -90,14 +86,15 @@ function Bitfield.define(schema: { [string]: FieldSpec }): Types.InternalCodec<a
             fieldSignExt[i] = 2 ^ width
             totalBits += width
         else
-            error(`[Lync] Lync.bitfield: field "{key}" has unknown type "{spec.type}"`)
+            Log.error(`field "{key}" has unknown type "{spec.type}"`)
         end
     end
 
     if totalBits > 32 then
-        error(`[Lync] Lync.bitfield: total exceeds 32 bits ({totalBits})`)
+        Log.error(`total exceeds 32 bits ({totalBits})`)
     end
 
+    -- Pick the narrowest u8/u16/u32 wire form.
     local wireBytes: number
     local wfn: (buffer, number, number) -> ()
     local rfn: (buffer, number) -> number
@@ -137,6 +134,7 @@ function Bitfield.define(schema: { [string]: FieldSpec }): Types.InternalCodec<a
             if fieldTypes[i] == TYPE_BOOL then
                 result[fieldKeys[i]] = raw ~= 0
             elseif fieldTypes[i] == TYPE_INT then
+                -- Sign-extend: subtract 2^width when the sign bit is set.
                 result[fieldKeys[i]] = if raw >= fieldSignBit[i] then raw - fieldSignExt[i] else raw
             else
                 result[fieldKeys[i]] = raw

package/src/codec/meta/Custom.luau

@@ -3,6 +3,7 @@
 -- User-defined fixed-size codec.
 
 local Base = require(script.Parent.Parent.Base)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Private ----------------------------------------------------------------
@@ -20,8 +21,9 @@ function Custom.define<T>(
     typeCheck: string?
 ): Types.InternalCodec<T>
     if type(size) ~= "number" or size < 0 or floor(size) ~= size then
-        error("[Lync] Lync.custom: size must be a non-negative integer")
+        Log.error(`size must be a non-negative integer, got {size}`)
     end
+    -- size == 0 collapses to constant(nil): user has no payload to encode.
     if size == 0 then
         return Base.constant(nil :: any) :: Types.InternalCodec<T>
     end