@axpecter/lync 1.5.2 → 2.1.0

package/src/codec/meta/Bitfield.luau

@@ -1,192 +1,148 @@
 --!strict
 --!native
--- Pack booleans, unsigned and signed integers at the bit level.
+-- Sub-byte packing. 1 to 32 bits across bool/uint/int fields.
 
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
-local Types = require(script.Parent.Parent.Parent.Types)
+local Base = require(script.Parent.Parent.Base)
 
-type ChannelState = Types.ChannelState
-type Codec<T> = Types.Codec<T>
-
-local alloc = Channel.alloc
-
--- Constants -----------------------------------------------------------
+-- Private -------------------------------------------------------------
 
 local band = bit32.band
 local bor = bit32.bor
 local lshift = bit32.lshift
 local rshift = bit32.rshift
 
--- Private -------------------------------------------------------------
-
-type FieldSpec = {
-    type: "bool" | "uint" | "int",
-    width: number?,
-}
-
-local function selectIO(bytes: number): ((b: buffer, offset: number, v: number) -> (), (
-    b: buffer,
-    offset: number
-) -> number)
-    if bytes == 1 then
-        return buffer.writeu8, buffer.readu8
-    end
-    if bytes == 2 then
-        return buffer.writeu16, buffer.readu16
-    end
-    return buffer.writeu32, buffer.readu32
-end
+-- Field type constants
+local TYPE_BOOL = 0
+local TYPE_UINT = 1
+local TYPE_INT = 2
 
 -- Public --------------------------------------------------------------
 
 local Bitfield = {}
 
-function Bitfield.define(schema: { [string]: FieldSpec }): Codec<any>
-    local sortedKeys = {} :: { string }
-
+function Bitfield.define(schema: { [string]: { type: string, width: number? } }): any
+    -- Collect and sort keys alphabetically
+    local keys = {}
     for key in schema do
-        table.insert(sortedKeys, key)
+        table.insert(keys, key)
     end
+    table.sort(keys)
 
-    table.sort(sortedKeys)
-
-    local count = #sortedKeys
-    if count == 0 then
-        error("[Lync] Bitfield requires at least one field")
+    if #keys == 0 then
+        error("[Lync] Lync.bitfield: requires at least one field")
     end
 
-    local keys = table.create(count) :: { string }
-    local isBool = table.create(count) :: { boolean }
-    local offsets = table.create(count) :: { number }
-    local masks = table.create(count) :: { number }
-
-    local hasSigned = false
-    local signBits = nil :: { number }?
-    local signExtends = nil :: { number }?
-
+    local fieldCount = #keys
+    local fieldKeys = table.create(fieldCount)
+    local fieldTypes = table.create(fieldCount)
+    local fieldOffsets = table.create(fieldCount)
+    local fieldMasks = table.create(fieldCount)
+    local fieldSignBit = table.create(fieldCount)
+    local fieldSignExt = table.create(fieldCount)
     local totalBits = 0
-    for i = 1, count do
-        local key = sortedKeys[i]
-        local spec = schema[key]
-        local specIsBool = spec.type == "bool"
-        local specIsSigned = spec.type == "int"
-        local width: number
 
-        if specIsBool then
-            width = 1
-        else
-            if not spec.width then
-                error(`[Lync] Bitfield field requires a width: "{key}"`)
+    for i = 1, fieldCount do
+        local key = keys[i]
+        local spec = schema[key]
+        fieldKeys[i] = key
+        fieldOffsets[i] = totalBits
+
+        if spec.type == "bool" then
+            fieldTypes[i] = TYPE_BOOL
+            fieldMasks[i] = 1
+            fieldSignBit[i] = 0
+            fieldSignExt[i] = 0
+            totalBits += 1
+        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`)
             end
-            width = spec.width
-            if width < 1 or width > 32 then
-                error(`[Lync] Bitfield width must be 1-32: "{key}" got {width}`)
+            fieldTypes[i] = TYPE_UINT
+            fieldMasks[i] = lshift(1, width) - 1
+            fieldSignBit[i] = 0
+            fieldSignExt[i] = 0
+            totalBits += width
+        elseif spec.type == "int" then
+            local width = spec.width
+            if not width or width < 2 or width > 32 then
+                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)
+            totalBits += width
+        else
+            error(`[Lync] Lync.bitfield: unknown field type "{spec.type}"`)
         end
-
-        if specIsSigned then
-            hasSigned = true
-        end
-
-        keys[i] = key
-        isBool[i] = specIsBool
-        offsets[i] = totalBits
-        masks[i] = lshift(1, width) - 1
-        totalBits += width
     end
 
     if totalBits > 32 then
-        error(`[Lync] Bitfield exceeds 32 bits: {totalBits}`)
+        error(`[Lync] Lync.bitfield: total exceeds 32 bits ({totalBits})`)
     end
 
-    -- Only build sign tables when at least one field is signed
-    if hasSigned then
-        signBits = table.create(count) :: { number }
-        signExtends = table.create(count) :: { number }
-
-        for i = 1, count do
-            local spec = schema[sortedKeys[i]]
-            if spec.type == "int" then
-                (signBits :: { number })[i] = lshift(1, (spec.width :: number) - 1);
-                (signExtends :: { number })[i] = lshift(1, spec.width :: number)
-            else
-                (signBits :: { number })[i] = 0
-                (signExtends :: { number })[i] = 0
-            end
-        end
-
-        table.freeze(signBits :: { number })
-        table.freeze(signExtends :: { number })
+    -- 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
+    elseif totalBits <= 16 then
+        wireBytes = 2
+        wfn = buffer.writeu16
+        rfn = buffer.readu16
+    else
+        wireBytes = 4
+        wfn = buffer.writeu32
+        rfn = buffer.readu32
     end
 
-    table.freeze(keys)
-    table.freeze(isBool)
-    table.freeze(offsets)
-    table.freeze(masks)
+    -- Freeze all descriptor arrays
+    table.freeze(fieldKeys)
+    table.freeze(fieldTypes)
+    table.freeze(fieldOffsets)
+    table.freeze(fieldMasks)
+    table.freeze(fieldSignBit)
+    table.freeze(fieldSignExt)
 
-    local bytes = if totalBits <= 8 then 1 elseif totalBits <= 16 then 2 else 4
-    local wfn, rfn = selectIO(bytes)
-
-    -- Shared pack logic
-    local function packValue(value: any): number
+    return Base.define(wireBytes, function(b: buffer, off: number, value: any): ()
         local packed = 0
-        for i = 1, count do
-            local bits = if isBool[i]
-                then (if value[keys[i]] then 1 else 0)
-                else band(value[keys[i]], masks[i])
-            packed = bor(packed, lshift(bits, offsets[i]))
+        for i = 1, fieldCount do
+            local v = value[fieldKeys[i]]
+            if fieldTypes[i] == TYPE_BOOL then
+                if v then
+                    packed = bor(packed, lshift(1, fieldOffsets[i]))
+                end
+            else
+                packed = bor(packed, lshift(band(v, fieldMasks[i]), fieldOffsets[i]))
+            end
         end
-        return packed
-    end
-
-    -- Shared unpack logic
-    local function unpackValue(packed: number): any
-        local result = {}
-
-        if hasSigned then
-            local sb = signBits :: { number }
-            local se = signExtends :: { number }
-
-            for i = 1, count do
-                local raw = band(rshift(packed, offsets[i]), masks[i])
-                if isBool[i] then
-                    result[keys[i]] = raw ~= 0
-                elseif sb[i] > 0 and raw >= sb[i] then
-                    result[keys[i]] = raw - se[i]
+        wfn(b, off, packed)
+    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[keys[i]] = raw
+                    result[fieldKeys[i]] = raw
                 end
-            end
-        else
-            for i = 1, count do
-                local raw = band(rshift(packed, offsets[i]), masks[i])
-                result[keys[i]] = if isBool[i] then raw ~= 0 else raw
+            else
+                result[fieldKeys[i]] = raw
             end
         end
 
         return result
-    end
-
-    return table.freeze({
-        _size = bytes,
-        _directWrite = function(b: buffer, offset: number, value: any): ()
-            wfn(b, offset, packValue(value))
-        end,
-        _directRead = function(b: buffer, offset: number): any
-            return unpackValue(rfn(b, offset))
-        end,
-        write = function(ch: ChannelState, value: any): ()
-            local c = ch.cursor
-            if c + bytes > ch.size then
-                alloc(ch, bytes)
-            end
-            wfn(ch.buff, c, packValue(value))
-            ch.cursor = c + bytes
-        end,
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (any, number)
-            return unpackValue(rfn(src, pos)), bytes
-        end,
-    })
+    end)
 end
 
 return table.freeze(Bitfield)

package/src/codec/meta/Custom.luau

@@ -1,11 +1,15 @@
 --!strict
---!native
--- User-defined fixed-size codec factory. Public API wrapper over Base.define.
+--!optimize 2
+-- User-defined fixed-size codec.
 
 local Base = require(script.Parent.Parent.Base)
 
+-- Private -------------------------------------------------------------
+
 local floor = math.floor
 
+-- Public --------------------------------------------------------------
+
 local Custom = {}
 
 function Custom.define(
@@ -13,8 +17,8 @@ function Custom.define(
     writeFn: (b: buffer, offset: number, value: any) -> (),
     readFn: (b: buffer, offset: number) -> any
 ): any
-    if size < 0 or size ~= floor(size) then
-        error(`[Lync] Custom codec size must be a non-negative integer, got {size}`)
+    if type(size) ~= "number" or size < 0 or floor(size) ~= size then
+        error("[Lync] Lync.custom: size must be a non-negative integer")
     end
 
     if size == 0 then

package/src/codec/meta/Enum.luau

@@ -1,81 +1,53 @@
 --!strict
---!native
--- String enum codec. Maps values to u8 indices at definition time.
+--!optimize 2
+-- String enum codec. Maps values to u8 indices at define time.
 
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
-local Types = require(script.Parent.Parent.Parent.Types)
-
-type ChannelState = Types.ChannelState
-type Codec<T> = Types.Codec<T>
-
-local alloc = Channel.alloc
+local Base = require(script.Parent.Parent.Base)
 
 -- Public --------------------------------------------------------------
 
 local EnumCodec = {}
 
-function EnumCodec.define(...: string): Codec<string>
+function EnumCodec.define(...: string): any
     local values = { ... }
     local count = #values
     if count == 0 then
-        error("[Lync] Enum requires at least one value")
+        error("[Lync] Lync.enum: requires at least one value")
     end
     if count > 256 then
-        error(`[Lync] Enum exceeds 256 values: {count}`)
+        error("[Lync] Lync.enum: exceeds 256 variants")
     end
 
-    local toIndex = {} :: { [string]: number }
-    local toValue = table.create(count) :: { string }
+    -- Build lookup tables
+    local toIndex: { [string]: number } = {}
+    local toValue = table.create(count)
 
-    for i, value in values do
-        if toIndex[value] ~= nil then
-            error(`[Lync] Duplicate enum value: "{value}"`)
+    for i = 1, count do
+        local val = values[i]
+        if toIndex[val] then
+            error(`[Lync] Lync.enum: duplicate value "{val}"`)
         end
-        toIndex[value] = i - 1
-        toValue[i] = value
+        toIndex[val] = i - 1
+        toValue[i] = val
     end
 
     table.freeze(toIndex)
     table.freeze(toValue)
 
-    return table.freeze({
-        _size = 1,
-        _directWrite = function(b: buffer, offset: number, value: string): ()
-            local idx = toIndex[value]
-            if idx == nil then
-                error(`[Lync] Invalid enum value: "{value}"`)
-            end
-            buffer.writeu8(b, offset, idx)
-        end,
-        _directRead = function(b: buffer, offset: number): string
-            local idx = buffer.readu8(b, offset)
-            local value = toValue[idx + 1]
-            if value == nil then
-                error(`[Lync] Invalid enum index: {idx}`)
-            end
-            return value
-        end,
-        write = function(ch: ChannelState, value: string): ()
-            local idx = toIndex[value]
-            if idx == nil then
-                error(`[Lync] Invalid enum value: "{value}"`)
-            end
-            local c = ch.cursor
-            if c + 1 > ch.size then
-                alloc(ch, 1)
-            end
-            buffer.writeu8(ch.buff, c, idx)
-            ch.cursor = c + 1
-        end,
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
-            local idx = buffer.readu8(src, pos)
-            local value = toValue[idx + 1]
-            if value == nil then
-                error(`[Lync] Invalid enum index: {idx}`)
-            end
-            return value, 1
-        end,
-    })
+    return Base.define(1, function(b: buffer, off: number, value: string): ()
+        local idx = toIndex[value]
+        if idx == nil then
+            error(`[Lync] Enum: invalid value "{value}"`)
+        end
+        buffer.writeu8(b, off, idx)
+    end, function(b: buffer, off: number): string
+        local idx = buffer.readu8(b, off)
+        local val = toValue[idx + 1]
+        if val == nil then
+            error(`[Lync] Enum: invalid index {idx}`)
+        end
+        return val
+    end, { _typeCheck = "string" })
 end
 
 return table.freeze(EnumCodec)

package/src/codec/meta/Float.luau

@@ -0,0 +1,64 @@
+--!strict
+--!native
+-- Fixed-point quantization codec. Maps float ranges to integer ranges.
+
+local Base = require(script.Parent.Parent.Base)
+
+-- Private -------------------------------------------------------------
+
+local ceil = math.ceil
+local clamp = math.clamp
+local round = math.round
+local max = math.max
+local min = math.min
+
+-- Public --------------------------------------------------------------
+
+local Float = {}
+
+function Float.float(rangeMin: number, rangeMax: number, precision: number): any
+    if rangeMin > rangeMax then
+        error(`[Lync] Lync.float: min ({rangeMin}) must be <= max ({rangeMax})`)
+    end
+    if precision <= 0 then
+        error("[Lync] Lync.float: precision must be positive")
+    end
+
+    local delta = rangeMax - rangeMin
+
+    -- Constant value: zero bytes
+    if delta == 0 then
+        return Base.zero()
+    end
+
+    local maxInt = min(0xFFFFFFFF, max(1, ceil(delta / precision)))
+
+    local compBytes: number
+    local wfn: (buffer, number, number) -> ()
+    local rfn: (buffer, number) -> number
+
+    if maxInt <= 0xFF then
+        compBytes = 1
+        wfn = buffer.writeu8
+        rfn = buffer.readu8
+    elseif maxInt <= 0xFFFF then
+        compBytes = 2
+        wfn = buffer.writeu16
+        rfn = buffer.readu16
+    else
+        compBytes = 4
+        wfn = buffer.writeu32
+        rfn = buffer.readu32
+    end
+
+    local scale = maxInt / delta
+    local invScale = delta / maxInt
+
+    return Base.define(compBytes, function(b: buffer, off: number, value: number): ()
+        wfn(b, off, round(clamp(value - rangeMin, 0, delta) * scale))
+    end, function(b: buffer, off: number): number
+        return rfn(b, off) * invScale + rangeMin
+    end, { _min = rangeMin, _max = rangeMax, _typeCheck = "number" })
+end
+
+return table.freeze(Float)

package/src/codec/meta/Nothing.luau

@@ -1,9 +1,13 @@
 --!strict
---!native
--- Zero-byte codec. Reads nil. Good for fire-and-forget signals.
+--!optimize 2
+-- Zero-byte codec. Reads nil. For fire-and-forget signals.
 
 local Base = require(script.Parent.Parent.Base)
 
-return table.freeze({
-    nothing = Base.zero(),
-})
+-- Public --------------------------------------------------------------
+
+local Nothing = {}
+
+Nothing.nothing = Base.zero()
+
+return table.freeze(Nothing)

package/src/codec/meta/Unknown.luau

@@ -1,39 +1,48 @@
 --!strict
---!native
--- Sidecar codec. Bypasses buffer serialization, uses Roblox remote refs.
+--!optimize 2
+-- Bypasses buffer serialization. Uses Roblox remote sidecar refs.
 
-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
-
-return table.freeze({
-    unknown = table.freeze({
-        write = function(ch: ChannelState, value: any): ()
-            local refs = ch.refs
-            local idx = #refs + 1
-            if idx > 65535 then
-                error(`[Lync] Unknown ref overflow: {idx} exceeds u16 max`)
-            end
-
-            refs[idx] = value
-
-            local c = ch.cursor
-            if c + 2 > ch.size then
-                alloc(ch, 2)
-            end
-            buffer.writeu16(ch.buff, c, idx)
-            ch.cursor = c + 2
-        end,
-        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
-            if not refs then
-                error("[Lync] Unknown read requires refs array")
-            end
-
-            local idx = buffer.readu16(src, pos)
-            return refs[idx], 2
-        end,
-    }),
-})
+-- Private -------------------------------------------------------------
+
+local alloc = Base.alloc
+local writeu16 = buffer.writeu16
+local readu16 = buffer.readu16
+
+-- Public --------------------------------------------------------------
+
+local Unknown = {}
+
+Unknown.unknown = table.freeze({
+    _hasUnknown = true,
+
+    write = function(ch: Types.ChannelState, value: any): ()
+        local idx = ch.refCount + 1
+        if idx > 0xFFFF then
+            error("[Lync] Unknown: ref overflow (>65535)")
+        end
+
+        ch.refs[idx] = value :: any
+        ch.refCount = idx
+
+        local cursor = ch.cursor
+        if cursor + 2 > ch.size then
+            alloc(ch, 2)
+        end
+        writeu16(ch.buff, cursor, idx)
+        ch.cursor = cursor + 2
+    end,
+
+    read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
+        if not refs then
+            error("[Lync] Unknown: read requires refs array")
+        end
+
+        local idx = readu16(src, pos)
+        return (refs :: any)[idx], 2
+    end,
+} :: any)
+
+return table.freeze(Unknown)

package/src/codec/primitive/Bool.luau

@@ -1,30 +1,20 @@
 --!strict
---!native
--- Boolean codec. _isBool tells struct to pack into bitfields.
+--!optimize 2
+-- Boolean codec with bitpacking flag for struct and array codecs.
 
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze({
-    bool = table.freeze({
-        _size = 1,
-        _isBool = true,
-        _directWrite = function(b: buffer, offset: number, value: boolean): ()
-            buffer.writeu8(b, offset, if value then 1 else 0)
-        end,
-        _directRead = function(b: buffer, offset: number): boolean
-            return buffer.readu8(b, offset) ~= 0
-        end,
-        write = function(ch: any, value: boolean): ()
-            local c = ch.cursor
-            if c + 1 > ch.size then
-                alloc(ch, 1)
-            end
-            buffer.writeu8(ch.buff, c, if value then 1 else 0)
-            ch.cursor = c + 1
-        end,
-        read = function(src: buffer, pos: number, _refs: { Instance }?): (boolean, number)
-            return buffer.readu8(src, pos) ~= 0, 1
-        end,
-    }),
+-- Public --------------------------------------------------------------
+
+local Bool = {}
+
+Bool.bool = Base.define(1, function(b: buffer, off: number, value: boolean): ()
+    buffer.writeu8(b, off, if value then 1 else 0)
+end, function(b: buffer, off: number): boolean
+    return buffer.readu8(b, off) ~= 0
+end, {
+    _isBool = true,
+    _typeCheck = "boolean",
 })
+
+return table.freeze(Bool)