@axpecter/lync 2.1.1 → 2.2.0

package/src/codec/composite/Array.luau

@@ -1,15 +1,17 @@
 --!strict
 --!native
--- array and deltaArray codecs.
+-- Array and deltaArray codecs. Bool elements are bit-packed.
 
 local Base = require(script.Parent.Parent.Base)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
 local Shared = require(script.Parent.Shared)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
+local writeByte = Channel.writeByte
 local writeu8 = buffer.writeu8
 local readu8 = buffer.readu8
 local band = bit32.band
@@ -19,137 +21,149 @@ local lshift = bit32.lshift
 local acquireScratch = Shared.acquireScratch
 local releaseScratch = Shared.releaseScratch
 local rangeEqual = Shared.rangeEqual
+local snapshot = Shared.snapshot
 local allocDeltaId = Shared.allocDeltaId
-
 local DELTA_UNCHANGED = Shared.DELTA_UNCHANGED
-local DELTA_FULL_OFFSET = Shared.DELTA_FULL_OFFSET
-local DELTA_MULTI_OFFSET = Shared.DELTA_MULTI_OFFSET
-
--- Public --------------------------------------------------------------
-
-local Array = {}
-
-function Array.array(element: Types.InternalCodec<any>, maxCount: number?): Types.InternalCodec<any>
-    local elemAny = element :: any
-
-    -- Bool array: bitpacked
-    if elemAny._isBool then
-        return table.freeze({
-            write = function(ch: Types.ChannelState, value: { any }): ()
-                local len = #value
-                Varint.write(ch, len)
-                if len == 0 then
-                    return
-                end
+local DELTA_FULL = Shared.DELTA_FULL
 
-                local byteCount = (len + 7) // 8
-                local cursor = ch.cursor
-                if cursor + byteCount > ch.size then
-                    alloc(ch, byteCount)
-                end
-                local b = ch.buff
-
-                local idx = 1
-                for byteIdx = 0, byteCount - 1 do
-                    local packed = 0
-                    local limit = if idx + 8 <= len + 1 then 8 else len - idx + 1
-                    for bit = 0, limit - 1 do
-                        if value[idx] then
-                            packed = bor(packed, lshift(1, bit))
-                        end
-                        idx += 1
-                    end
-                    writeu8(b, cursor + byteIdx, packed)
-                end
-                ch.cursor = cursor + byteCount
-            end,
+local function makeBoolArray(
+    element: Types.InternalCodec<any>,
+    maxCount: number?
+): Types.InternalCodec<any>
+    return table.freeze({
+        _isArray = true,
+        _element = element,
+        _maxCount = maxCount,
 
-            read = function(src: buffer, pos: number, _refs: { Instance }?): ({ boolean }, number)
-                local len, lenBytes = Varint.read(src, pos)
-                if maxCount and len > maxCount then
-                    error(`[Lync] Array: count {len} exceeds max {maxCount}`)
-                end
-                if len == 0 then
-                    return {}, lenBytes
-                end
+        write = function(ch: Types.ChannelState, value: { boolean }): ()
+            local len = #value
+            Varint.write(ch, len)
+            if len == 0 then
+                return
+            end
 
-                local byteCount = (len + 7) // 8
-                local dataStart = pos + lenBytes
-                local result = table.create(len)
-                local idx = 1
-
-                for byteIdx = 0, byteCount - 1 do
-                    local byte = readu8(src, dataStart + byteIdx)
-                    local limit = if idx + 8 <= len + 1 then 8 else len - idx + 1
-                    for bit = 0, limit - 1 do
-                        result[idx] = band(byte, lshift(1, bit)) ~= 0
-                        idx += 1
+            local byteCount = (len + 7) // 8
+            local cursor = ch.cursor
+            if cursor + byteCount > ch.size then
+                alloc(ch, byteCount)
+            end
+            local b = ch.buff
+
+            local idx = 1
+            for byteIdx = 0, byteCount - 1 do
+                local packed = 0
+                local remaining = len - idx + 1
+                local limit = if remaining >= 8 then 8 else remaining
+                for bit = 0, limit - 1 do
+                    if value[idx] then
+                        packed = bor(packed, lshift(1, bit))
                     end
+                    idx += 1
                 end
+                writeu8(b, cursor + byteIdx, packed)
+            end
+            ch.cursor = cursor + byteCount
+        end,
 
-                return result, lenBytes + byteCount
-            end,
-        } :: any)
-    end
+        read = function(src: buffer, pos: number, _refs: { Instance }?): ({ boolean }, number)
+            local len, lenBytes = Varint.read(src, pos)
+            if maxCount and len > maxCount then
+                error(`[Lync] Array.read: count {len} exceeds max {maxCount}`)
+            end
+            if len == 0 then
+                return {}, lenBytes
+            end
 
-    -- Direct array: element has _size + _directWrite + _directRead
-    local elemSize = elemAny._size
-    local elemDW = elemAny._directWrite
-    local elemDR = elemAny._directRead
+            local byteCount = (len + 7) // 8
+            local dataStart = pos + lenBytes
+            local result = table.create(len)
 
-    if elemSize and elemDW and elemDR then
-        return table.freeze({
-            write = function(ch: Types.ChannelState, value: { any }): ()
-                local len = #value
-                Varint.write(ch, len)
-                if len == 0 then
-                    return
+            local idx = 1
+            for byteIdx = 0, byteCount - 1 do
+                local byte = readu8(src, dataStart + byteIdx)
+                local remaining = len - idx + 1
+                local limit = if remaining >= 8 then 8 else remaining
+                for bit = 0, limit - 1 do
+                    result[idx] = band(byte, lshift(1, bit)) ~= 0
+                    idx += 1
                 end
+            end
+            return result, lenBytes + byteCount
+        end,
+    })
+end
 
-                local payloadBytes = len * elemSize
-                local cursor = ch.cursor
-                if cursor + payloadBytes > ch.size then
-                    alloc(ch, payloadBytes)
-                end
-                local b = ch.buff
+local function makeDirectArray(
+    element: Types.InternalCodec<any>,
+    elemSize: number,
+    elemDW: (b: buffer, off: number, value: any) -> (),
+    elemDR: (b: buffer, off: number) -> any,
+    maxCount: number?
+): Types.InternalCodec<any>
+    return table.freeze({
+        _isArray = true,
+        _element = element,
+        _maxCount = maxCount,
 
-                for i = 1, len do
-                    elemDW(b, cursor + (i - 1) * elemSize, value[i])
-                end
-                ch.cursor = cursor + payloadBytes
-            end,
+        write = function(ch: Types.ChannelState, value: { any }): ()
+            local len = #value
+            Varint.write(ch, len)
+            if len == 0 then
+                return
+            end
 
-            read = function(src: buffer, pos: number, _refs: { Instance }?): ({ any }, number)
-                local len, lenBytes = Varint.read(src, pos)
-                if maxCount and len > maxCount then
-                    error(`[Lync] Array: count {len} exceeds max {maxCount}`)
-                end
-                if len == 0 then
-                    return {}, lenBytes
-                end
+            local payloadBytes = len * elemSize
+            local cursor = ch.cursor
+            if cursor + payloadBytes > ch.size then
+                alloc(ch, payloadBytes)
+            end
+            local b = ch.buff
 
-                local payloadBytes = len * elemSize
-                local dataStart = pos + lenBytes
+            local off = cursor
+            for i = 1, len do
+                elemDW(b, off, value[i])
+                off += elemSize
+            end
+            ch.cursor = cursor + payloadBytes
+        end,
 
-                -- Safety cap
-                local remaining = buffer.len(src) - dataStart
-                if payloadBytes > remaining then
-                    len = remaining // elemSize
-                    payloadBytes = len * elemSize
-                end
+        read = function(src: buffer, pos: number, _refs: { Instance }?): ({ any }, number)
+            local len, lenBytes = Varint.read(src, pos)
+            if maxCount and len > maxCount then
+                error(`[Lync] Array.read: count {len} exceeds max {maxCount}`)
+            end
+            if len == 0 then
+                return {}, lenBytes
+            end
 
-                local result = table.create(len)
-                for i = 1, len do
-                    result[i] = elemDR(src, dataStart + (i - 1) * elemSize)
-                end
+            local payloadBytes = len * elemSize
+            local dataStart = pos + lenBytes
+            local remaining = buffer.len(src) - dataStart
+            if payloadBytes > remaining then
+                len = remaining // elemSize
+                payloadBytes = len * elemSize
+            end
 
-                return result, lenBytes + payloadBytes
-            end,
-        } :: any)
-    end
+            local result = table.create(len)
+            local off = dataStart
+            for i = 1, len do
+                result[i] = elemDR(src, off)
+                off += elemSize
+            end
+            return result, lenBytes + payloadBytes
+        end,
+    })
+end
 
-    -- Generic array
+local function makeGenericArray(
+    element: Types.InternalCodec<any>,
+    maxCount: number?
+): Types.InternalCodec<any>
     return table.freeze({
+        _isArray = true,
+        _element = element,
+        _maxCount = maxCount,
+
         write = function(ch: Types.ChannelState, value: { any }): ()
             local len = #value
             Varint.write(ch, len)
@@ -161,7 +175,7 @@ function Array.array(element: Types.InternalCodec<any>, maxCount: number?): Type
         read = function(src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
             local len, lenBytes = Varint.read(src, pos)
             if maxCount and len > maxCount then
-                error(`[Lync] Array: count {len} exceeds max {maxCount}`)
+                error(`[Lync] Array.read: count {len} exceeds max {maxCount}`)
             end
             if len == 0 then
                 return {}, lenBytes
@@ -171,13 +185,34 @@ function Array.array(element: Types.InternalCodec<any>, maxCount: number?): Type
             local total = lenBytes
             for i = 1, len do
                 local v, consumed = element.read(src, pos + total, refs)
+                if consumed == 0 then
+                    error(`[Lync] Array.read: element codec consumed 0 bytes at index {i}`)
+                end
                 result[i] = v
                 total += consumed
             end
-
             return result, total
         end,
-    } :: any)
+    })
+end
+
+-- Public -----------------------------------------------------------------
+
+local Array = {}
+
+function Array.array(element: Types.InternalCodec<any>, maxCount: number?): Types.InternalCodec<any>
+    if element._isBool then
+        return makeBoolArray(element, maxCount)
+    end
+
+    local elemSize = element._size
+    local elemDW = element._directWrite
+    local elemDR = element._directRead
+    if elemSize and elemDW and elemDR then
+        return makeDirectArray(element, elemSize, elemDW, elemDR, maxCount)
+    end
+
+    return makeGenericArray(element, maxCount)
 end
 
 function Array.deltaArray(
@@ -194,73 +229,47 @@ function Array.deltaArray(
             local cache = ch.deltas[deltaId]
 
             if not cache then
-                -- First frame: full
-                local cursor = ch.cursor
-                if cursor + 1 > ch.size then
-                    alloc(ch, 1)
-                end
-                writeu8(ch.buff, cursor, 1) -- FLAG_FULL (len+1 where len=0 for first)
-                ch.cursor = cursor + 1
+                writeByte(ch, DELTA_FULL)
 
                 local scratch = acquireScratch()
                 innerArray.write(scratch, value)
                 local snapLen = scratch.cursor
-                local snapBuf = buffer.create(snapLen)
-                buffer.copy(snapBuf, 0, scratch.buff, 0, snapLen)
 
-                ch.deltas[deltaId] = { raw = snapBuf, len = snapLen }
+                ch.deltas[deltaId] = { raw = snapshot(scratch.buff, snapLen), len = snapLen }
                 innerArray.write(ch, value)
                 releaseScratch()
                 return
             end
 
-            -- Compare against cache
             local scratch = acquireScratch()
             innerArray.write(scratch, value)
             local scratchLen = scratch.cursor
-            local cachedLen = cache.len
 
             if
-                scratchLen == cachedLen and rangeEqual(scratch.buff, 0, cache.raw, 0, scratchLen)
+                scratchLen == cache.len
+                and rangeEqual(scratch.buff, 0, cache.raw, 0, scratchLen)
             then
-                local cursor = ch.cursor
-                if cursor + 1 > ch.size then
-                    alloc(ch, 1)
-                end
-                writeu8(ch.buff, cursor, DELTA_UNCHANGED)
-                ch.cursor = cursor + 1
+                writeByte(ch, DELTA_UNCHANGED)
                 releaseScratch()
                 return
             end
 
-            -- Changed: full re-send
-            local cursor = ch.cursor
-            if cursor + 1 > ch.size then
-                alloc(ch, 1)
-            end
-            writeu8(ch.buff, cursor, 1)
-            ch.cursor = cursor + 1
+            writeByte(ch, DELTA_FULL)
             innerArray.write(ch, value)
 
-            local newBuf = buffer.create(scratchLen)
-            buffer.copy(newBuf, 0, scratch.buff, 0, scratchLen)
-            cache.raw = newBuf
+            cache.raw = snapshot(scratch.buff, scratchLen)
             cache.len = scratchLen
-
             releaseScratch()
         end,
 
         read = function(src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
-            local flag = readu8(src, pos)
-
-            if flag == DELTA_UNCHANGED then
-                return {} :: any, 1
+            if readu8(src, pos) == DELTA_UNCHANGED then
+                return {}, 1
             end
-
             local value, consumed = innerArray.read(src, pos + 1, refs)
             return value, 1 + consumed
         end,
-    } :: any)
+    })
 end
 
 return table.freeze(Array)

package/src/codec/composite/Map.luau

@@ -1,25 +1,28 @@
 --!strict
 --!native
--- map and deltaMap codecs.
+-- Map and deltaMap codecs.
 
 local Base = require(script.Parent.Parent.Base)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
 local Shared = require(script.Parent.Shared)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
-local writeu8 = buffer.writeu8
+local writeByte = Channel.writeByte
 local readu8 = buffer.readu8
 
 local acquireScratch = Shared.acquireScratch
 local releaseScratch = Shared.releaseScratch
 local rangeEqual = Shared.rangeEqual
+local snapshot = Shared.snapshot
 local allocDeltaId = Shared.allocDeltaId
 local DELTA_UNCHANGED = Shared.DELTA_UNCHANGED
+local DELTA_FULL = Shared.DELTA_FULL
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Map = {}
 
@@ -28,9 +31,16 @@ function Map.map(
     valueCodec: Types.InternalCodec<any>,
     maxCount: number?
 ): Types.InternalCodec<any>
+    local fixedKey = keyCodec._size
+    local fixedValue = valueCodec._size
+
     return table.freeze({
-        write = function(ch: Types.ChannelState, value: any): ()
-            -- Count entries
+        _isMap = true,
+        _keyCodec = keyCodec,
+        _valueCodec = valueCodec,
+        _maxCount = maxCount,
+
+        write = function(ch: Types.ChannelState, value: { [any]: any }): ()
             local count = 0
             for _ in value do
                 count += 1
@@ -41,11 +51,8 @@ function Map.map(
                 return
             end
 
-            -- Pre-alloc if both fixed size
-            local kAny = keyCodec :: any
-            local vAny = valueCodec :: any
-            if kAny._size and vAny._size then
-                local entrySize = kAny._size + vAny._size
+            if fixedKey and fixedValue then
+                local entrySize = fixedKey + fixedValue
                 local cursor = ch.cursor
                 if cursor + count * entrySize > ch.size then
                     alloc(ch, count * entrySize)
@@ -58,26 +65,27 @@ function Map.map(
             end
         end,
 
-        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
+        read = function(src: buffer, pos: number, refs: { Instance }?): ({ [any]: any }, number)
             local count, lenBytes = Varint.read(src, pos)
             if maxCount and count > maxCount then
-                error(`[Lync] Map: count {count} exceeds max {maxCount}`)
+                error(`[Lync] Map.read: count {count} exceeds max {maxCount}`)
             end
 
             local result: { [any]: any } = {}
             local total = lenBytes
-
-            for _ = 1, count do
+            for i = 1, count do
                 local k, kc = keyCodec.read(src, pos + total, refs)
                 total += kc
                 local v, vc = valueCodec.read(src, pos + total, refs)
                 total += vc
+                if kc == 0 and vc == 0 then
+                    error(`[Lync] Map.read: zero-byte entry at index {i}`)
+                end
                 result[k] = v
             end
-
             return result, total
         end,
-    } :: any)
+    })
 end
 
 function Map.deltaMap(
@@ -91,24 +99,17 @@ function Map.deltaMap(
     return table.freeze({
         _isDelta = true,
 
-        write = function(ch: Types.ChannelState, value: any): ()
+        write = function(ch: Types.ChannelState, value: { [any]: any }): ()
             local cache = ch.deltas[deltaId]
 
             if not cache then
-                local cursor = ch.cursor
-                if cursor + 1 > ch.size then
-                    alloc(ch, 1)
-                end
-                writeu8(ch.buff, cursor, 3) -- FLAG_FULL
-                ch.cursor = cursor + 1
+                writeByte(ch, DELTA_FULL)
 
                 local scratch = acquireScratch()
                 innerMap.write(scratch, value)
                 local snapLen = scratch.cursor
-                local snapBuf = buffer.create(snapLen)
-                buffer.copy(snapBuf, 0, scratch.buff, 0, snapLen)
 
-                ch.deltas[deltaId] = { raw = snapBuf, len = snapLen }
+                ch.deltas[deltaId] = { raw = snapshot(scratch.buff, snapLen), len = snapLen }
                 innerMap.write(ch, value)
                 releaseScratch()
                 return
@@ -117,49 +118,32 @@ function Map.deltaMap(
             local scratch = acquireScratch()
             innerMap.write(scratch, value)
             local scratchLen = scratch.cursor
-            local cachedLen = cache.len
 
             if
-                scratchLen == cachedLen and rangeEqual(scratch.buff, 0, cache.raw, 0, scratchLen)
+                scratchLen == cache.len
+                and rangeEqual(scratch.buff, 0, cache.raw, 0, scratchLen)
             then
-                local cursor = ch.cursor
-                if cursor + 1 > ch.size then
-                    alloc(ch, 1)
-                end
-                writeu8(ch.buff, cursor, DELTA_UNCHANGED)
-                ch.cursor = cursor + 1
+                writeByte(ch, DELTA_UNCHANGED)
                 releaseScratch()
                 return
             end
 
-            -- Changed: full re-send
-            local cursor = ch.cursor
-            if cursor + 1 > ch.size then
-                alloc(ch, 1)
-            end
-            writeu8(ch.buff, cursor, 3) -- FLAG_FULL
-            ch.cursor = cursor + 1
+            writeByte(ch, DELTA_FULL)
             innerMap.write(ch, value)
 
-            local newBuf = buffer.create(scratchLen)
-            buffer.copy(newBuf, 0, scratch.buff, 0, scratchLen)
-            cache.raw = newBuf
+            cache.raw = snapshot(scratch.buff, scratchLen)
             cache.len = scratchLen
-
             releaseScratch()
         end,
 
-        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
-            local flag = readu8(src, pos)
-
-            if flag == DELTA_UNCHANGED then
-                return {} :: any, 1
+        read = function(src: buffer, pos: number, refs: { Instance }?): ({ [any]: any }, number)
+            if readu8(src, pos) == DELTA_UNCHANGED then
+                return {}, 1
             end
-
             local value, consumed = innerMap.read(src, pos + 1, refs)
             return value, 1 + consumed
         end,
-    } :: any)
+    })
 end
 
 return table.freeze(Map)

package/src/codec/composite/Optional.luau

@@ -1,40 +1,35 @@
 --!strict
 --!optimize 2
--- Optional codec. 1 byte flag, value only if present.
+-- Optional codec. 1-byte present/absent flag, value only if present.
 
-local Base = require(script.Parent.Parent.Base)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
 local Types = require(script.Parent.Parent.Parent.Types)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
-local alloc = Base.alloc
-local writeu8 = buffer.writeu8
+local writeByte = Channel.writeByte
 local readu8 = buffer.readu8
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Optional = {}
 
 function Optional.optional(inner: Types.InternalCodec<any>): Types.InternalCodec<any>
-    local codec: any = {
+    local codec: Types.InternalCodec<any> = {
+        _isOptional = true,
+        _inner = inner,
+
         write = function(ch: Types.ChannelState, value: any): ()
-            local cursor = ch.cursor
-            if cursor + 1 > ch.size then
-                alloc(ch, 1)
-            end
             if value == nil then
-                writeu8(ch.buff, cursor, 0)
-                ch.cursor = cursor + 1
-            else
-                writeu8(ch.buff, cursor, 1)
-                ch.cursor = cursor + 1
-                inner.write(ch, value)
+                writeByte(ch, 0)
+                return
             end
+            writeByte(ch, 1)
+            inner.write(ch, value)
         end,
 
         read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
-            local flag = readu8(src, pos)
-            if flag == 0 then
+            if readu8(src, pos) == 0 then
                 return nil, 1
             end
             local value, consumed = inner.read(src, pos + 1, refs)
@@ -42,10 +37,9 @@ function Optional.optional(inner: Types.InternalCodec<any>): Types.InternalCodec
         end,
     }
 
-    if (inner :: any)._hasUnknown then
+    if inner._hasUnknown then
         codec._hasUnknown = true
     end
-
     return table.freeze(codec)
 end