@axpecter/lync 1.5.2 → 2.1.0

package/src/codec/composite/Tagged.luau

@@ -1,222 +1,108 @@
 --!strict
---!native
+--!optimize 2
 -- Discriminated union codec. u8 variant tag + variant payload.
 
-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
-type Codec<T> = Types.Codec<T>
-type InternalCodec<T> = Types.InternalCodec<T>
+-- Private -------------------------------------------------------------
 
-local alloc = Channel.alloc
+local alloc = Base.alloc
+local writeu8 = buffer.writeu8
+local readu8 = buffer.readu8
 
 -- Public --------------------------------------------------------------
 
 local Tagged = {}
 
--- Read injects tagField into the decoded table. Variant codecs must return mutable tables.
-function Tagged.define(tagField: string, variants: { [string]: Codec<any> }): Codec<any>
-    if #tagField == 0 then
-        error("[Lync] Tagged union tagField must not be empty")
+function Tagged.define(
+    tagField: string,
+    variants: { [string]: Types.InternalCodec<any> }
+): Types.InternalCodec<any>
+    if tagField == "" then
+        error("[Lync] Lync.tagged: tagField cannot be empty")
     end
 
-    local names = {} :: { string }
+    local names: { string } = {}
     for name in variants do
-        if #name == 0 then
-            error("[Lync] Tagged union variant name must not be empty")
-        end
         table.insert(names, name)
     end
     table.sort(names)
 
-    local count = #names
-    if count == 0 then
-        error("[Lync] Tagged union requires at least one variant")
+    local variantCount = #names
+    if variantCount == 0 then
+        error("[Lync] Lync.tagged: requires at least one variant")
     end
-    if count > 256 then
-        error(`[Lync] Tagged union exceeds 256 variants: {count}`)
+    if variantCount > 256 then
+        error("[Lync] Lync.tagged: exceeds 256 variants")
     end
 
-    local nameToTag = {} :: { [string]: number }
-    local tagCodecs = table.create(count) :: { Codec<any> }
-    local tagNames = table.create(count) :: { string }
-    local tagSizes = table.create(count) :: { number? }
-
-    local allDirect = true
-    local uniformSize: number? = (variants[names[1]] :: InternalCodec<any>)._size
-    local directWrites = table.create(count) :: { any }
-    local directReads = table.create(count) :: { any }
-
-    for i, name in names do
-        local codec = variants[name] :: InternalCodec<any>
-        nameToTag[name] = i
-        tagCodecs[i] = codec
-        tagNames[i] = name
-
-        local size = codec._size
-        tagSizes[i] = size
-
-        if size ~= uniformSize then
-            uniformSize = nil
-        end
-
-        local dw = codec._directWrite
-        local dr = codec._directRead
-        if dw and dr and size then
-            directWrites[i] = dw
-            directReads[i] = dr
-        else
-            allDirect = false
+    -- Build lookup tables
+    local nameToTag: { [string]: number } = {}
+    local tagToCodec = table.create(variantCount)
+    local tagToName = table.create(variantCount)
+    local hasUnknown = false
+
+    for i = 1, variantCount do
+        local name = names[i]
+        local codec = variants[name]
+        nameToTag[name] = i - 1
+        tagToCodec[i] = codec
+        tagToName[i] = name
+        if (codec :: any)._hasUnknown then
+            hasUnknown = true
         end
     end
 
     table.freeze(nameToTag)
-    table.freeze(tagCodecs)
-    table.freeze(tagNames)
-    table.freeze(tagSizes)
-
-    local fixedSize: number? = if uniformSize then 1 + uniformSize else nil
-
-    if allDirect then
-        table.freeze(directWrites)
-        table.freeze(directReads)
-
-        -- If uniform size, expose _directWrite/_directRead for parent struct/array
-        if fixedSize then
-            return table.freeze({
-                _size = fixedSize,
-                _directWrite = function(b: buffer, offset: number, value: any): ()
-                    local tag = nameToTag[value[tagField]]
-                    if not tag then
-                        error(`[Lync] Unknown variant: {value[tagField]}`)
-                    end
-                    buffer.writeu8(b, offset, tag - 1)
-                    directWrites[tag](b, offset + 1, value)
-                end,
-                _directRead = function(b: buffer, offset: number): any
-                    local tag = buffer.readu8(b, offset) + 1
-                    local name = tagNames[tag]
-                    if not name then
-                        error(`[Lync] Unknown variant index: {tag - 1}`)
-                    end
-                    local data = directReads[tag](b, offset + 1)
-                    if type(data) == "table" then
-                        data[tagField] = name
-                    end
-                    return data
-                end,
-                write = function(ch: ChannelState, value: any): ()
-                    local tag = nameToTag[value[tagField]]
-                    if not tag then
-                        error(`[Lync] Unknown variant: {value[tagField]}`)
-                    end
-                    local c = ch.cursor
-                    if c + (fixedSize :: number) > ch.size then
-                        alloc(ch, fixedSize :: number)
-                    end
-                    local b = ch.buff
-                    buffer.writeu8(b, c, tag - 1)
-                    directWrites[tag](b, c + 1, value)
-                    ch.cursor = c + (fixedSize :: number)
-                end,
-                read = function(src: buffer, pos: number, _refs: { Instance }?): (any, number)
-                    local tag = buffer.readu8(src, pos) + 1
-                    local name = tagNames[tag]
-                    if not name then
-                        error(`[Lync] Unknown variant index: {tag - 1}`)
-                    end
-                    local data = directReads[tag](src, pos + 1)
-                    if type(data) == "table" then
-                        data[tagField] = name
-                    end
-                    return data, fixedSize :: number
-                end,
-            })
-        end
-
-        -- Non-uniform sizes but all have direct: use direct dispatch internally
-        local fieldSizes = table.clone(tagSizes) :: { number }
-        table.freeze(fieldSizes)
-
-        return table.freeze({
-            _size = nil,
-            write = function(ch: ChannelState, value: any): ()
-                local tag = nameToTag[value[tagField]]
-                if not tag then
-                    error(`[Lync] Unknown variant: {value[tagField]}`)
-                end
-                local varSize = fieldSizes[tag]
-                local totalNeeded = 1 + varSize
-                local c = ch.cursor
-                if c + totalNeeded > ch.size then
-                    alloc(ch, totalNeeded)
-                end
-                local b = ch.buff
-                buffer.writeu8(b, c, tag - 1)
-                directWrites[tag](b, c + 1, value)
-                ch.cursor = c + totalNeeded
-            end,
-            read = function(src: buffer, pos: number, _refs: { Instance }?): (any, number)
-                local tag = buffer.readu8(src, pos) + 1
-                local name = tagNames[tag]
-                if not name then
-                    error(`[Lync] Unknown variant index: {tag - 1}`)
-                end
-                local data = directReads[tag](src, pos + 1)
-                if type(data) == "table" then
-                    data[tagField] = name
-                end
-                return data, 1 + fieldSizes[tag]
-            end,
-        })
-    end
+    table.freeze(tagToCodec)
+    table.freeze(tagToName)
+
+    local codec: any = {
+        write = function(ch: Types.ChannelState, value: any): ()
+            local name = value[tagField]
+            if name == nil then
+                error(`[Lync] Tagged: missing tagField "{tagField}" in value`)
+            end
 
-    local writeFns = table.create(count) :: { any }
-    local readFns = table.create(count) :: { any }
-    for i = 1, count do
-        writeFns[i] = tagCodecs[i].write
-        readFns[i] = tagCodecs[i].read
-    end
-    table.freeze(writeFns)
-    table.freeze(readFns)
-
-    return table.freeze({
-        _size = fixedSize,
-        write = function(ch: ChannelState, value: any): ()
-            local tag = nameToTag[value[tagField]]
-            if not tag then
-                error(`[Lync] Unknown variant: {value[tagField]}`)
+            local tag = nameToTag[name]
+            if tag == nil then
+                error(`[Lync] Tagged: unknown variant "{name}"`)
             end
 
-            local variantSize = tagSizes[tag]
-            if variantSize then
-                alloc(ch, 1 + variantSize)
-            else
+            local cursor = ch.cursor
+            if cursor + 1 > ch.size then
                 alloc(ch, 1)
             end
+            writeu8(ch.buff, cursor, tag)
+            ch.cursor = cursor + 1
 
-            local c = ch.cursor
-            buffer.writeu8(ch.buff, c, tag - 1)
-            ch.cursor = c + 1
-            writeFns[tag](ch, value)
+            tagToCodec[tag + 1].write(ch, value)
         end,
+
         read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
-            local tag = buffer.readu8(src, pos) + 1
-            local name = tagNames[tag]
-            if not name then
-                error(`[Lync] Unknown variant index: {tag - 1}`)
+            local tag = readu8(src, pos)
+            local varCodec = tagToCodec[tag + 1]
+            if not varCodec then
+                error(`[Lync] Tagged: unknown tag {tag}`)
             end
 
-            local data, bytes = readFns[tag](src, pos + 1, refs)
+            local name = tagToName[tag + 1]
+            local data, consumed = varCodec.read(src, pos + 1, refs)
 
+            -- Caller needs the tag field to discriminate the union
             if type(data) == "table" then
                 data[tagField] = name
             end
 
-            return data, 1 + bytes
+            return data, 1 + consumed
         end,
-    })
+    }
+
+    if hasUnknown then
+        codec._hasUnknown = true
+    end
+    return table.freeze(codec)
 end
 
 return table.freeze(Tagged)

package/src/codec/composite/Tuple.luau

@@ -1,145 +1,131 @@
 --!strict
---!native
+--!optimize 2
 -- Positional ordered codec. Like struct but indexed, not keyed.
 
-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
-type Codec<T> = Types.Codec<T>
-type InternalCodec<T> = Types.InternalCodec<T>
+-- Private -------------------------------------------------------------
 
-local alloc = Channel.alloc
+local alloc = Base.alloc
 
 -- Public --------------------------------------------------------------
 
 local Tuple = {}
 
-function Tuple.define(...: Codec<any>): Codec<{ any }>
+function Tuple.define(...: Types.InternalCodec<any>): Types.InternalCodec<any>
     local codecs = { ... }
     local count = #codecs
     if count == 0 then
-        error("[Lync] Tuple requires at least one codec")
+        error("[Lync] Lync.tuple: requires at least one codec")
     end
 
-    table.freeze(codecs)
-
-    local canDirect = true
-    local totalSize: number = 0
-    local directWrites = table.create(count) :: { any }
-    local directReads = table.create(count) :: { any }
-    local fieldSizes = table.create(count) :: { number }
+    -- Check if all codecs are direct
+    local allDirect = true
+    local totalSize = 0
+    local hasUnknown = false
 
     for i = 1, count do
-        local internal = codecs[i] :: InternalCodec<any>
-        local size = internal._size
-        local dw = internal._directWrite
-        local dr = internal._directRead
-
-        if size and dw and dr then
-            fieldSizes[i] = size
-            directWrites[i] = dw
-            directReads[i] = dr
-            totalSize += size
+        local c = codecs[i] :: any
+        if c._hasUnknown then
+            hasUnknown = true
+        end
+        if not c._size or not c._directWrite or not c._directRead then
+            allDirect = false
         else
-            canDirect = false
-            if size then
-                totalSize += size
-            else
-                totalSize = nil :: any
-            end
-            break
+            totalSize += c._size
         end
     end
 
-    -- Recompute totalSize for generic path if direct failed partway
-    if not canDirect then
-        totalSize = 0 :: any
+    table.freeze(codecs)
+
+    if allDirect then
+        -- Build precomputed offsets
+        local offsets = table.create(count)
+        local directWrites = table.create(count)
+        local directReads = table.create(count)
+        local cursor = 0
+
         for i = 1, count do
-            local size = (codecs[i] :: InternalCodec<any>)._size
-            if size then
-                totalSize = (totalSize :: number) + size
-            else
-                totalSize = nil :: any
-                break
-            end
+            local c = codecs[i] :: any
+            offsets[i] = cursor
+            directWrites[i] = c._directWrite
+            directReads[i] = c._directRead
+            cursor += c._size
         end
-    end
 
-    if canDirect then
+        table.freeze(offsets)
         table.freeze(directWrites)
         table.freeze(directReads)
-        table.freeze(fieldSizes)
 
-        local function directWriteBody(b: buffer, c: number, value: { any }): ()
-            for i = 1, count do
-                directWrites[i](b, c, value[i])
-                c += fieldSizes[i]
-            end
-        end
+        local codec: any = {
+            _size = totalSize,
 
-        local function directReadBody(b: buffer, pos: number): { any }
-            local result = table.create(count)
-            local c = pos
-            for i = 1, count do
-                result[i] = directReads[i](b, c)
-                c += fieldSizes[i]
-            end
-            return result
-        end
+            _directWrite = function(b: buffer, off: number, value: any): ()
+                for i = 1, count do
+                    directWrites[i](b, off + offsets[i], value[i])
+                end
+            end,
 
-        return table.freeze({
-            _size = totalSize,
-            _directWrite = directWriteBody,
-            _directRead = directReadBody,
-            write = function(ch: ChannelState, value: { any }): ()
+            _directRead = function(b: buffer, off: number): any
+                local result = table.create(count)
+                for i = 1, count do
+                    result[i] = directReads[i](b, off + offsets[i])
+                end
+                return result
+            end,
+
+            write = function(ch: Types.ChannelState, value: any): ()
                 local c = ch.cursor
                 if c + totalSize > ch.size then
                     alloc(ch, totalSize)
                 end
-                directWriteBody(ch.buff, c, value)
+                local b = ch.buff
+                for i = 1, count do
+                    directWrites[i](b, c + offsets[i], value[i])
+                end
                 ch.cursor = c + totalSize
             end,
-            read = function(src: buffer, pos: number, _refs: { Instance }?): ({ any }, number)
-                return directReadBody(src, pos), totalSize
+
+            read = function(src: buffer, pos: number, _refs: { Instance }?): (any, number)
+                local result = table.create(count)
+                for i = 1, count do
+                    result[i] = directReads[i](src, pos + offsets[i])
+                end
+                return result, totalSize
             end,
-        })
-    end
+        }
 
-    local writeFns = table.create(count) :: { any }
-    local readFns = table.create(count) :: { any }
-    for i = 1, count do
-        writeFns[i] = codecs[i].write
-        readFns[i] = codecs[i].read
+        if hasUnknown then
+            codec._hasUnknown = true
+        end
+        return table.freeze(codec)
     end
-    table.freeze(writeFns)
-    table.freeze(readFns)
-
-    local hasFixedTotal = totalSize ~= nil
 
-    return table.freeze({
-        _size = totalSize,
-        write = function(ch: ChannelState, value: { any }): ()
-            if hasFixedTotal then
-                alloc(ch, totalSize :: number)
-            end
+    -- Generic path
+    local codec: any = {
+        write = function(ch: Types.ChannelState, value: any): ()
             for i = 1, count do
-                writeFns[i](ch, value[i])
+                codecs[i].write(ch, value[i])
             end
         end,
-        read = function(src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
-            local result = table.create(count)
-            local absPos = pos
 
+        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
+            local result = table.create(count)
+            local total = 0
             for i = 1, count do
-                local value, n = readFns[i](src, absPos, refs)
-                result[i] = value
-                absPos += n
+                local v, consumed = codecs[i].read(src, pos + total, refs)
+                result[i] = v
+                total += consumed
             end
-
-            return result, absPos - pos
+            return result, total
         end,
-    })
+    }
+
+    if hasUnknown then
+        codec._hasUnknown = true
+    end
+    return table.freeze(codec)
 end
 
 return table.freeze(Tuple)

package/src/codec/datatype/Buffer.luau

@@ -1,45 +1,73 @@
 --!strict
---!native
--- Raw buffer codec with varint length prefix.
+--!optimize 2
+-- Raw buffer codec with dense-prefix-varint length prefix.
 
-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 INLINE = Varint.INLINE_MAX
 
 -- Public --------------------------------------------------------------
 
-local Buffer = {}
+local BufferCodec = {}
 
-Buffer.buff = table.freeze({
-    write = function(ch: ChannelState, value: buffer): ()
+BufferCodec.buff = table.freeze({
+    _typeCheck = "buffer",
+
+    write = function(ch: Types.ChannelState, value: buffer): ()
         local len = buffer.len(value)
-        Varint.write(ch, len)
-        local c = ch.cursor
-        if c + len > ch.size then
-            alloc(ch, len)
+        local cursor = ch.cursor
+
+        if len <= INLINE then
+            if cursor + 1 + len > ch.size then
+                alloc(ch, 1 + len)
+            end
+            local b = ch.buff
+            buffer.writeu8(b, cursor, len)
+            if len > 0 then
+                buffer.copy(b, cursor + 1, value, 0, len)
+            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.copy(ch.buff, cursor, value, 0, len)
+            ch.cursor = cursor + len
         end
-        buffer.copy(ch.buff, c, value, 0, len)
-        ch.cursor = c + len
     end,
+
     read = function(src: buffer, pos: number, _refs: { Instance }?): (buffer, number)
-        local len, lenBytes = Varint.read(src, pos)
+        local b0 = buffer.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 == 0 then
             return buffer.create(0), lenBytes
         end
 
-        local remaining = buffer.len(src) - pos - lenBytes
-        if len > remaining then
-            error(`[Lync] Buffer length exceeds remaining: {len} > {remaining}`)
+        local dataStart = pos + lenBytes
+        if dataStart + len > buffer.len(src) then
+            error("[Lync] Buffer: length exceeds remaining buffer")
         end
 
         local out = buffer.create(len)
-        buffer.copy(out, 0, src, pos + lenBytes, len)
+        buffer.copy(out, 0, src, dataStart, len)
         return out, lenBytes + len
     end,
-})
+} :: any)
 
-return table.freeze(Buffer)
+return table.freeze(BufferCodec)