@axpecter/lync 2.0.0 → 2.1.1

package/src/codec/primitive/Float16.luau

@@ -2,23 +2,9 @@
 --!native
 -- Half-precision float codec. 2 bytes, ±65504, ~3 decimal digits.
 
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
-local Types = require(script.Parent.Parent.Parent.Types)
+local Base = require(script.Parent.Parent.Base)
 
-local alloc = Channel.alloc
-
-type ChannelState = Types.ChannelState
-
--- Constants -----------------------------------------------------------
-
-local MAX_HALF = 65504
-local BIAS = 15
-local EXP_MAX = 31
-local MANT_BITS = 10
-local MANT_SCALE = 1024
-local SIGN_BIT = 0x8000
-local INF_BITS = 0x7C00
-local NAN_BITS = 0x7E00
+-- Private -------------------------------------------------------------
 
 local band = bit32.band
 local bor = bit32.bor
@@ -29,84 +15,92 @@ local ldexp = math.ldexp
 local round = math.round
 local huge = math.huge
 
--- Private -------------------------------------------------------------
-
 local function encode(value: number): number
+    -- NaN
     if value ~= value then
-        return NAN_BITS
+        return 0x7E00
     end
+
+    -- Zero (both +0 and -0 map to positive zero)
     if value == 0 then
         return 0
     end
 
+    -- Sign extraction
     local sign = 0
     if value < 0 then
-        sign = SIGN_BIT
+        sign = 0x8000
         value = -value
     end
 
-    if value > MAX_HALF then
-        return bor(sign, INF_BITS)
+    -- Overflow to infinity
+    if value > 65504 then
+        return bor(sign, 0x7C00)
     end
 
+    -- Decompose via frexp: value = mantissa * 2^exponent, mantissa in [0.5, 1)
     local mantissa, exponent = frexp(value)
-    exponent += 14
-
-    local bits: number
-    if exponent <= 0 then
-        local shift = exponent + MANT_BITS - 1
-        if shift < 0 then
+    local biasedExp = exponent + 14
+
+    if biasedExp <= 0 then
+        -- Subnormal: frac = round(mantissa * 2^(biasedExp + 10))
+        local frac = round(ldexp(mantissa, biasedExp + 10))
+        if frac >= 1024 then
+            -- Rounds to minimum normal
+            return bor(sign, 0x0400)
+        end
+        if frac <= 0 then
             return sign
         end
-        bits = round(mantissa * lshift(1, shift))
-    elseif exponent >= EXP_MAX then
-        bits = INF_BITS
-    else
-        bits = bor(lshift(exponent, MANT_BITS), round((mantissa * 2 - 1) * MANT_SCALE))
+        return bor(sign, frac)
+    end
+
+    -- Normal: frac = round((mantissa * 2 - 1) * 1024)
+    local frac = round((mantissa * 2 - 1) * 1024)
+
+    -- Carry: mantissa rounding overflows into exponent
+    if frac >= 1024 then
+        frac = 0
+        biasedExp += 1
     end
 
-    return bor(sign, bits)
+    -- Overflow after carry
+    if biasedExp >= 31 then
+        return bor(sign, 0x7C00)
+    end
+
+    return bor(sign, lshift(biasedExp, 10), frac)
 end
 
-local function decode(packed: number): number
-    local exponent = band(rshift(packed, MANT_BITS), 0x1F)
-    local mantissa = band(packed, 0x03FF)
+local function decode(raw: number): number
+    local sign = band(raw, 0x8000)
+    local exp = band(rshift(raw, 10), 0x1F)
+    local frac = band(raw, 0x03FF)
 
-    local result: number
-    if exponent == 0 then
-        result = if mantissa == 0 then 0 else ldexp(mantissa / MANT_SCALE, 1 - BIAS)
-    elseif exponent == EXP_MAX then
-        result = if mantissa == 0 then huge else 0 / 0
+    local value: number
+
+    if exp == 0 then
+        -- Zero or subnormal
+        value = if frac == 0 then 0 else ldexp(frac, -24)
+    elseif exp == 31 then
+        -- Infinity or NaN
+        value = if frac == 0 then huge else 0 / 0
     else
-        result = ldexp(mantissa / MANT_SCALE + 1, exponent - BIAS)
+        -- Normal: (frac + 1024) * 2^(exp - 25)
+        value = ldexp(frac + 1024, exp - 25)
     end
 
-    return if band(packed, SIGN_BIT) ~= 0 then -result else result
+    return if sign ~= 0 then -value else value
 end
 
 -- Public --------------------------------------------------------------
 
 local Float16 = {}
 
-Float16.f16 = table.freeze({
-    _size = 2,
-    _directWrite = function(b: buffer, offset: number, value: number): ()
-        buffer.writeu16(b, offset, encode(value))
-    end,
-    _directRead = function(b: buffer, offset: number): number
-        return decode(buffer.readu16(b, offset))
-    end,
-    write = function(ch: ChannelState, value: number): ()
-        local c = ch.cursor
-        if c + 2 > ch.size then
-            alloc(ch, 2)
-        end
-        buffer.writeu16(ch.buff, c, encode(value))
-        ch.cursor = c + 2
-    end,
-    read = function(src: buffer, pos: number, _refs: { Instance }?): (number, number)
-        return decode(buffer.readu16(src, pos)), 2
-    end,
-})
+Float16.f16 = Base.define(2, function(b: buffer, off: number, value: number): ()
+    buffer.writeu16(b, off, encode(value))
+end, function(b: buffer, off: number): number
+    return decode(buffer.readu16(b, off))
+end, { _typeCheck = "number" })
 
 return table.freeze(Float16)

package/src/codec/primitive/Int.luau

@@ -0,0 +1,68 @@
+--!strict
+--!optimize 2
+-- Smart integer codec. Auto-selects u8/u16/u32/i8/i16/i32 from range.
+
+local Base = require(script.Parent.Parent.Base)
+
+-- Private -------------------------------------------------------------
+
+local floor = math.floor
+
+-- Public --------------------------------------------------------------
+
+local Int = {}
+
+function Int.int(min: number, max: number): any
+    if min > max then
+        error(`[Lync] Lync.int: min ({min}) must be <= max ({max})`)
+    end
+    if floor(min) ~= min or floor(max) ~= max then
+        error("[Lync] Lync.int: bounds must be integers")
+    end
+
+    local meta = {
+        _min = min,
+        _max = max,
+        _isInteger = true,
+        _typeCheck = "number",
+    }
+
+    if min >= 0 then
+        -- Unsigned path
+        if max <= 0xFF then
+            return Base.define(1, buffer.writeu8, buffer.readu8, meta)
+        elseif max <= 0xFFFF then
+            return Base.define(2, buffer.writeu16, buffer.readu16, meta)
+        elseif max <= 0xFFFFFFFF then
+            return Base.define(4, buffer.writeu32, buffer.readu32, meta)
+        end
+    else
+        -- Signed path: use unsigned write/read, interpret as signed
+        if min >= -0x80 and max <= 0x7F then
+            return Base.define(1, function(b: buffer, off: number, v: number): ()
+                buffer.writeu8(b, off, if v < 0 then v + 0x100 else v)
+            end, function(b: buffer, off: number): number
+                local raw = buffer.readu8(b, off)
+                return if raw >= 0x80 then raw - 0x100 else raw
+            end, meta)
+        elseif min >= -0x8000 and max <= 0x7FFF then
+            return Base.define(2, function(b: buffer, off: number, v: number): ()
+                buffer.writeu16(b, off, if v < 0 then v + 0x10000 else v)
+            end, function(b: buffer, off: number): number
+                local raw = buffer.readu16(b, off)
+                return if raw >= 0x8000 then raw - 0x10000 else raw
+            end, meta)
+        elseif min >= -0x80000000 and max <= 0x7FFFFFFF then
+            return Base.define(4, function(b: buffer, off: number, v: number): ()
+                buffer.writeu32(b, off, if v < 0 then v + 0x100000000 else v)
+            end, function(b: buffer, off: number): number
+                local raw = buffer.readu32(b, off)
+                return if raw >= 0x80000000 then raw - 0x100000000 else raw
+            end, meta)
+        end
+    end
+
+    error(`[Lync] Lync.int: range [{min}, {max}] exceeds i32 bounds`)
+end
+
+return table.freeze(Int)

package/src/codec/primitive/Number.luau

@@ -1,48 +1,26 @@
 --!strict
---!native
--- u8, u16, u32, i8, i16, i32, f32, f64 codecs.
+--!optimize 2
+-- Explicit-precision float codecs: f32 and f64.
 
 local Base = require(script.Parent.Parent.Base)
 
-return table.freeze({
-    u8 = Base.define(1, function(b: buffer, o: number, v: number): ()
-        buffer.writeu8(b, o, v)
-    end, function(b: buffer, o: number): number
-        return buffer.readu8(b, o)
-    end),
-    u16 = Base.define(2, function(b: buffer, o: number, v: number): ()
-        buffer.writeu16(b, o, v)
-    end, function(b: buffer, o: number): number
-        return buffer.readu16(b, o)
-    end),
-    u32 = Base.define(4, function(b: buffer, o: number, v: number): ()
-        buffer.writeu32(b, o, v)
-    end, function(b: buffer, o: number): number
-        return buffer.readu32(b, o)
-    end),
-    i8 = Base.define(1, function(b: buffer, o: number, v: number): ()
-        buffer.writei8(b, o, v)
-    end, function(b: buffer, o: number): number
-        return buffer.readi8(b, o)
-    end),
-    i16 = Base.define(2, function(b: buffer, o: number, v: number): ()
-        buffer.writei16(b, o, v)
-    end, function(b: buffer, o: number): number
-        return buffer.readi16(b, o)
-    end),
-    i32 = Base.define(4, function(b: buffer, o: number, v: number): ()
-        buffer.writei32(b, o, v)
-    end, function(b: buffer, o: number): number
-        return buffer.readi32(b, o)
-    end),
-    f32 = Base.define(4, function(b: buffer, o: number, v: number): ()
-        buffer.writef32(b, o, v)
-    end, function(b: buffer, o: number): number
-        return buffer.readf32(b, o)
-    end),
-    f64 = Base.define(8, function(b: buffer, o: number, v: number): ()
-        buffer.writef64(b, o, v)
-    end, function(b: buffer, o: number): number
-        return buffer.readf64(b, o)
-    end),
+-- Constants -----------------------------------------------------------
+
+local F32_SCRATCH = buffer.create(4)
+
+-- Public --------------------------------------------------------------
+
+local Number = {}
+
+Number.f32 = Base.define(4, buffer.writef32, buffer.readf32, {
+    _typeCheck = "number",
 })
+
+Number.f64 = Base.define(8, buffer.writef64, buffer.readf64, {
+    _typeCheck = "number",
+})
+
+-- Shared scratch buffer for Auto codec f32 round-trip test
+Number._f32Scratch = F32_SCRATCH
+
+return table.freeze(Number)

package/src/codec/primitive/Varint.luau

@@ -1,76 +1,97 @@
 --!strict
 --!native
--- LEB128 variable-length integer encoding and decoding.
+-- Dense prefix-varint encoding with single-branch decode.
 
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Base = require(script.Parent.Parent.Base)
 local Types = require(script.Parent.Parent.Parent.Types)
 
-type ChannelState = Types.ChannelState
-
-local alloc = Channel.alloc
-
 -- Constants -----------------------------------------------------------
 
-local CONT = 0x80
-local MASK = 0x7F
-local MAX_BYTES = 5
-local MAX_VALUE = 4294967295
+local INLINE_MAX = 0xBF
+
+-- Private -------------------------------------------------------------
 
+local alloc = Base.alloc
 local band = bit32.band
 local bor = bit32.bor
 local rshift = bit32.rshift
-local lshift = bit32.lshift
+local writeu8 = buffer.writeu8
+local writeu16 = buffer.writeu16
+local writeu32 = buffer.writeu32
+local readu8 = buffer.readu8
+local readu16 = buffer.readu16
+local readu32 = buffer.readu32
 
 -- Public --------------------------------------------------------------
 
 local Varint = {}
 
-function Varint.write(ch: ChannelState, value: number): ()
-    if value < 0 or value > MAX_VALUE then
-        error(`[Lync] Varint value out of range: {value}`)
-    end
+Varint.INLINE_MAX = INLINE_MAX
 
-    -- Fast path: ~80%+ of real-world varints are single-byte(lengths, counts)
-    if value < CONT then
-        local c = ch.cursor
-        if c + 1 > ch.size then
-            alloc(ch, 1)
-        end
-        buffer.writeu8(ch.buff, c, value)
-        ch.cursor = c + 1
-        return
+function Varint.write(ch: Types.ChannelState, value: number): ()
+    if value < 0 or value > 0xFFFFFFFF or value % 1 ~= 0 then
+        error(`[Lync] Varint: value must be an integer in [0, 4294967295], got {value}`)
     end
 
-    local c = ch.cursor
-    if c + MAX_BYTES > ch.size then
-        alloc(ch, MAX_BYTES)
-    end
+    local cursor = ch.cursor
     local b = ch.buff
 
-    while value >= CONT do
-        buffer.writeu8(b, c, bor(band(value, MASK), CONT))
-        value = rshift(value, 7)
-        c += 1
+    if value <= INLINE_MAX then
+        if cursor + 1 > ch.size then
+            alloc(ch, 1)
+        end
+        writeu8(b, cursor, value)
+        ch.cursor = cursor + 1
+    elseif value <= 8383 then
+        if cursor + 2 > ch.size then
+            alloc(ch, 2)
+        end
+        local adjusted = value - 192
+        b = ch.buff -- alloc may have replaced the buffer
+        writeu8(b, cursor, bor(0xC0, rshift(adjusted, 8)))
+        writeu8(b, cursor + 1, band(adjusted, 0xFF))
+        ch.cursor = cursor + 2
+    elseif value <= 1056959 then
+        if cursor + 3 > ch.size then
+            alloc(ch, 3)
+        end
+        local adjusted = value - 8384
+        b = ch.buff
+        writeu8(b, cursor, bor(0xE0, rshift(adjusted, 16)))
+        writeu16(b, cursor + 1, band(adjusted, 0xFFFF))
+        ch.cursor = cursor + 3
+    else
+        if cursor + 5 > ch.size then
+            alloc(ch, 5)
+        end
+        b = ch.buff
+        writeu8(b, cursor, 0xF0)
+        writeu32(b, cursor + 1, value)
+        ch.cursor = cursor + 5
     end
-
-    buffer.writeu8(b, c, value)
-    ch.cursor = c + 1
 end
 
--- Reads rely on buffer.readu8 throwing on OOB. MAX_BYTES rejects malformed loops.
 function Varint.read(src: buffer, pos: number): (number, number)
-    local result = 0
-
-    for offset = 0, MAX_BYTES - 1 do
-        local byte = buffer.readu8(src, pos + offset)
-        result = bor(result, lshift(band(byte, MASK), offset * 7))
-
-        if band(byte, CONT) == 0 then
-            return result, offset + 1
-        end
+    local b0 = readu8(src, pos)
+
+    if b0 <= INLINE_MAX then
+        return b0, 1
+    elseif b0 <= 0xDF then
+        return band(b0, 0x1F) * 256 + readu8(src, pos + 1) + 192, 2
+    elseif b0 <= 0xEF then
+        return band(b0, 0x0F) * 65536 + readu16(src, pos + 1) + 8384, 3
+    else
+        return readu32(src, pos + 1), 5
     end
+end
 
-    error(`[Lync] Varint exceeds {MAX_BYTES} bytes at position {pos}`)
+function Varint.writeInline(ch: Types.ChannelState, value: number): ()
+    local cursor = ch.cursor
+    if cursor + 1 > ch.size then
+        alloc(ch, 1)
+    end
+    writeu8(ch.buff, cursor, value)
+    ch.cursor = cursor + 1
 end
 
 return table.freeze(Varint)