@axpecter/lync 2.1.1 → 2.2.0

package/src/codec/composite/Shared.luau

@@ -5,36 +5,67 @@
 local Base = require(script.Parent.Parent.Base)
 local Types = require(script.Parent.Parent.Parent.Types)
 
--- Constants -----------------------------------------------------------
-
+-- Constants --------------------------------------------------------------
+
+--[[
+    Delta encoding flag space, shared across deltaStruct/deltaArray/deltaMap:
+      0    UNCHANGED  : sender skipped this entry, decoder reuses cache
+      1    FULL       : full payload follows
+      2..  reserved   : per-segment / per-key delta encodings (future)
+
+    Struct's per-segment scheme uses [1..segCount] as "single dirty
+    segment index" then segCount + DELTA_FULL_OFFSET for full and
+    segCount + DELTA_MULTI_OFFSET for multi-dirty bitmap.
+]]
 local DELTA_UNCHANGED = 0
+local DELTA_FULL = 1
 local DELTA_FULL_OFFSET = 1
 local DELTA_MULTI_OFFSET = 2
 
--- State ---------------------------------------------------------------
+local INITIAL_SCRATCH = 1024
+
+-- State ------------------------------------------------------------------
 
 local _nextDeltaId = 0
 local _scratchDepth = 0
 local _scratchStack: { Types.ChannelState } = {}
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
 local band = bit32.band
 local bor = bit32.bor
 local bxor = bit32.bxor
 local lshift = bit32.lshift
-local rshift = bit32.rshift
-
 local readu8 = buffer.readu8
 local readu32 = buffer.readu32
 local writeu8 = buffer.writeu8
 
--- Public --------------------------------------------------------------
+local function newScratch(): Types.ChannelState
+    return {
+        buff = buffer.create(INITIAL_SCRATCH),
+        cursor = 0,
+        size = INITIAL_SCRATCH,
+        refs = {},
+        refCount = 0,
+        lastId = -1,
+        countPos = -1,
+        itemCount = 0,
+        singleMode = false,
+        singlePos = 0,
+        deltas = {},
+        prevDump = nil,
+        prevDumpLen = 0,
+        currentPacket = nil,
+    }
+end
+
+-- Public -----------------------------------------------------------------
 
 local Shared = {}
 
 Shared.DELTA_UNCHANGED = DELTA_UNCHANGED
+Shared.DELTA_FULL = DELTA_FULL
 Shared.DELTA_FULL_OFFSET = DELTA_FULL_OFFSET
 Shared.DELTA_MULTI_OFFSET = DELTA_MULTI_OFFSET
 
@@ -43,31 +74,21 @@ function Shared.allocDeltaId(): number
     return _nextDeltaId
 end
 
+--[[
+    Acquire a scratch ChannelState. Stack-based so re-entrant codec
+    serialization (a codec writing into scratch that triggers another
+    codec's scratch acquire) works without aliasing.
+]]
 function Shared.acquireScratch(): Types.ChannelState
     _scratchDepth += 1
     local ch = _scratchStack[_scratchDepth]
-    if not ch then
-        ch = {
-            buff = buffer.create(1024),
-            cursor = 0,
-            size = 1024,
-            refs = {},
-            refCount = 0,
-            lastId = -1,
-            countPos = 0,
-            itemCount = 0,
-            singleMode = false,
-            singlePos = 0,
-            deltas = {},
-            prevDump = nil,
-            prevDumpLen = 0,
-            currentPacket = nil,
-        }
-        _scratchStack[_scratchDepth] = ch
-    else
+    if ch then
         ch.cursor = 0
         ch.refCount = 0
+        return ch
     end
+    ch = newScratch()
+    _scratchStack[_scratchDepth] = ch
     return ch
 end
 
@@ -76,8 +97,7 @@ function Shared.releaseScratch(): ()
 end
 
 function Shared.rangeEqual(a: buffer, offA: number, b: buffer, offB: number, len: number): boolean
-    -- u32 chunks
-    local aligned = len - (len % 4)
+    local aligned = band(len, -4)
     local i = 0
     while i < aligned do
         if bxor(readu32(a, offA + i), readu32(b, offB + i)) ~= 0 then
@@ -85,27 +105,35 @@ function Shared.rangeEqual(a: buffer, offA: number, b: buffer, offB: number, len
         end
         i += 4
     end
-
-    -- u8 remainder
     while i < len do
         if readu8(a, offA + i) ~= readu8(b, offB + i) then
             return false
         end
         i += 1
     end
-
     return true
 end
 
+function Shared.snapshot(src: buffer, len: number): buffer
+    local out = buffer.create(len)
+    if len > 0 then
+        buffer.copy(out, 0, src, 0, len)
+    end
+    return out
+end
+
+--[[
+    Split a struct schema into (dataKeys, dataCodecs, boolKeys), all
+    sorted alphabetically for deterministic wire layout.
+]]
 function Shared.extractFields(
     schema: { [string]: Types.InternalCodec<any> }
 ): ({ string }, { Types.InternalCodec<any> }, { string })
     local dataKeys: { string } = {}
-    local dataCodecs: { Types.InternalCodec<any> } = {}
     local boolKeys: { string } = {}
 
     for key, codec in schema do
-        if (codec :: any)._isBool then
+        if codec._isBool then
             table.insert(boolKeys, key)
         else
             table.insert(dataKeys, key)
@@ -119,23 +147,28 @@ function Shared.extractFields(
     table.sort(dataKeys)
     table.sort(boolKeys)
 
-    for i = 1, #dataKeys do
+    local dataCount = #dataKeys
+    local dataCodecs = table.create(dataCount)
+    for i = 1, dataCount do
         dataCodecs[i] = schema[dataKeys[i]]
     end
 
     table.freeze(dataKeys)
     table.freeze(dataCodecs)
     table.freeze(boolKeys)
-
     return dataKeys, dataCodecs, boolKeys
 end
 
 function Shared.packBools(
     ch: Types.ChannelState,
-    value: any,
+    value: { [string]: any },
     boolKeys: { string },
     boolCount: number
 ): ()
+    if boolCount == 0 then
+        return
+    end
+
     local byteCount = (boolCount + 7) // 8
     local cursor = ch.cursor
     if cursor + byteCount > ch.size then
@@ -146,7 +179,8 @@ function Shared.packBools(
     local idx = 1
     for byteIdx = 0, byteCount - 1 do
         local packed = 0
-        local limit = if idx + 8 <= boolCount + 1 then 8 else boolCount - idx + 1
+        local remaining = boolCount - idx + 1
+        local limit = if remaining >= 8 then 8 else remaining
         for bit = 0, limit - 1 do
             if value[boolKeys[idx]] then
                 packed = bor(packed, lshift(1, bit))
@@ -164,20 +198,23 @@ function Shared.unpackBools(
     pos: number,
     boolKeys: { string },
     boolCount: number,
-    result: any
+    result: { [string]: any }
 ): number
+    if boolCount == 0 then
+        return 0
+    end
+
     local byteCount = (boolCount + 7) // 8
     local idx = 1
-
     for byteIdx = 0, byteCount - 1 do
         local byte = readu8(src, pos + byteIdx)
-        local limit = if idx + 8 <= boolCount + 1 then 8 else boolCount - idx + 1
+        local remaining = boolCount - idx + 1
+        local limit = if remaining >= 8 then 8 else remaining
         for bit = 0, limit - 1 do
             result[boolKeys[idx]] = band(byte, lshift(1, bit)) ~= 0
             idx += 1
         end
     end
-
     return byteCount
 end
 

package/src/codec/composite/Struct.luau

@@ -1,33 +1,51 @@
 --!strict
 --!native
--- struct and deltaStruct codecs with single-field delta shortcut.
+-- Struct and deltaStruct 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)
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
+local writeByte = Channel.writeByte
 local writeu8 = buffer.writeu8
 local readu8 = buffer.readu8
+local band = bit32.band
+local bor = bit32.bor
+local lshift = bit32.lshift
+
 local extractFields = Shared.extractFields
 local packBools = Shared.packBools
 local unpackBools = Shared.unpackBools
 local rangeEqual = Shared.rangeEqual
+local snapshot = Shared.snapshot
 local acquireScratch = Shared.acquireScratch
 local releaseScratch = Shared.releaseScratch
 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
 
-local band = bit32.band
-local bor = bit32.bor
-local lshift = bit32.lshift
+local function buildFrozenSchema(
+    dataKeys: { string },
+    boolKeys: { string },
+    schema: { [string]: Types.InternalCodec<any> }
+): { [string]: Types.InternalCodec<any> }
+    local frozen: { [string]: Types.InternalCodec<any> } = {}
+    for i = 1, #dataKeys do
+        local k = dataKeys[i]
+        frozen[k] = schema[k]
+    end
+    for i = 1, #boolKeys do
+        local k = boolKeys[i]
+        frozen[k] = schema[k]
+    end
+    return table.freeze(frozen)
+end
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Struct = {}
 
@@ -37,12 +55,9 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
     local boolCount = #boolKeys
     local boolBytes = (boolCount + 7) // 8
 
-    -- Check all-direct path
-    local allDirect = true
-    local fixedSize = 0
-
+    local allDirect, fixedSize = true, 0
     for i = 1, dataCount do
-        local c = dataCodecs[i] :: any
+        local c = dataCodecs[i]
         if not c._size or not c._directWrite or not c._directRead then
             allDirect = false
             break
@@ -51,29 +66,20 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
     end
 
     local totalFixed = fixedSize + boolBytes
-
-    -- Freeze schema for Gate
-    local frozenSchema: { [string]: Types.InternalCodec<any> } = {}
-    for key, codec in schema do
-        frozenSchema[key] = codec
-    end
-    table.freeze(frozenSchema)
+    local frozenSchema = buildFrozenSchema(dataKeys, boolKeys, schema)
 
     if allDirect and dataCount > 0 then
-        -- Precompute offsets
         local offsets = table.create(dataCount)
         local directWrites = table.create(dataCount)
         local directReads = table.create(dataCount)
         local cursor = 0
-
         for i = 1, dataCount do
-            local c = dataCodecs[i] :: any
+            local c = dataCodecs[i]
             offsets[i] = cursor
             directWrites[i] = c._directWrite
             directReads[i] = c._directRead
-            cursor += c._size
+            cursor += c._size :: number
         end
-
         table.freeze(offsets)
         table.freeze(directWrites)
         table.freeze(directReads)
@@ -86,22 +92,23 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                 for i = 1, dataCount do
                     directWrites[i](b, off + offsets[i], value[dataKeys[i]])
                 end
-                -- Bool packing inline for direct path
-                if boolCount > 0 then
-                    local boolOff = off + fixedSize
-                    local idx = 1
-                    local byteCount = boolBytes
-                    for byteIdx = 0, byteCount - 1 do
-                        local packed = 0
-                        local limit = if idx + 8 <= boolCount + 1 then 8 else boolCount - idx + 1
-                        for bit = 0, limit - 1 do
-                            if value[boolKeys[idx]] then
-                                packed = bor(packed, lshift(1, bit))
-                            end
-                            idx += 1
+                if boolCount == 0 then
+                    return
+                end
+
+                local boolOff = off + fixedSize
+                local idx = 1
+                for byteIdx = 0, boolBytes - 1 do
+                    local packed = 0
+                    local remaining = boolCount - idx + 1
+                    local limit = if remaining >= 8 then 8 else remaining
+                    for bit = 0, limit - 1 do
+                        if value[boolKeys[idx]] then
+                            packed = bor(packed, lshift(1, bit))
                         end
-                        buffer.writeu8(b, boolOff + byteIdx, packed)
+                        idx += 1
                     end
+                    writeu8(b, boolOff + byteIdx, packed)
                 end
             end,
 
@@ -141,10 +148,9 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                 end
                 return result, totalFixed
             end,
-        } :: any)
+        }) :: Types.InternalCodec<any>
     end
 
-    -- Generic path
     return table.freeze({
         _schema = frozenSchema,
 
@@ -170,38 +176,17 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
             end
             return result, total
         end,
-    } :: any)
+    }) :: Types.InternalCodec<any>
 end
 
 function Struct.deltaStruct(
     schema: { [string]: Types.InternalCodec<any> }
 ): Types.InternalCodec<any>
-    local dataKeys, dataCodecs, boolKeys = extractFields(schema)
-    local dataCount = #dataKeys
-    local boolCount = #boolKeys
-    local boolBytes = (boolCount + 7) // 8
-    local segCount = dataCount + (if boolCount > 0 then 1 else 0)
-    local maskBytes = (segCount + 7) // 8
-    local deltaId = allocDeltaId()
-
-    -- Freeze schema for Gate
-    local frozenSchema: { [string]: Types.InternalCodec<any> } = {}
-    for key, codec in schema do
-        frozenSchema[key] = codec
-    end
-    table.freeze(frozenSchema)
-
-    --[[
-        Flag encoding with single-field shortcut:
-          0            = UNCHANGED
-          1..segCount  = single dirty segment index
-          segCount + 1 = FULL
-          segCount + 2 = MULTI dirty
-    ]]
+    local dataKeys, _dataCodecs, boolKeys = extractFields(schema)
+    local segCount = #dataKeys + (if #boolKeys > 0 then 1 else 0)
     local FLAG_FULL = segCount + DELTA_FULL_OFFSET
-    local FLAG_MULTI = segCount + DELTA_MULTI_OFFSET
-
-    -- Inner struct codec for full serialization
+    local deltaId = allocDeltaId()
+    local frozenSchema = buildFrozenSchema(dataKeys, boolKeys, schema)
     local innerStruct = Struct.struct(schema)
 
     return table.freeze({
@@ -212,93 +197,47 @@ function Struct.deltaStruct(
             local cache = ch.deltas[deltaId]
 
             if not cache then
-                -- First frame: FLAG_FULL + full payload
-                local cursor = ch.cursor
-                if cursor + 1 > ch.size then
-                    alloc(ch, 1)
-                end
-                writeu8(ch.buff, cursor, FLAG_FULL)
-                ch.cursor = cursor + 1
+                writeByte(ch, FLAG_FULL)
 
-                -- Serialize to scratch for caching
                 local scratch = acquireScratch()
                 innerStruct.write(scratch, value)
-
-                -- Snapshot scratch bytes as the baseline for future comparison
                 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 }
                 innerStruct.write(ch, value)
                 releaseScratch()
                 return
             end
 
-            -- Compare current serialization against cached baseline
             local scratch = acquireScratch()
             innerStruct.write(scratch, value)
-
-            local scratchBuf = scratch.buff
             local scratchLen = scratch.cursor
-            local cachedBuf = cache.raw
-            local cachedLen = cache.len
-
-            -- Byte-for-byte match means no fields changed
-            if scratchLen == cachedLen and rangeEqual(scratchBuf, 0, cachedBuf, 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
+
+            if
+                scratchLen == cache.len
+                and rangeEqual(scratch.buff, 0, cache.raw, 0, scratchLen)
+            then
+                writeByte(ch, DELTA_UNCHANGED)
                 releaseScratch()
                 return
             end
 
-            --[[
-                Changed but not unchanged: full re-send. Per-segment delta
-                tracking is deferred to a future version.
-            ]]
-            local cursor = ch.cursor
-            if cursor + 1 > ch.size then
-                alloc(ch, 1)
-            end
-            writeu8(ch.buff, cursor, FLAG_FULL)
-            ch.cursor = cursor + 1
+            writeByte(ch, FLAG_FULL)
             innerStruct.write(ch, value)
 
-            -- Update cache
-            local newBuf = buffer.create(scratchLen)
-            buffer.copy(newBuf, 0, scratchBuf, 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 cached value (caller must have baseline)
+            if readu8(src, pos) == DELTA_UNCHANGED then
                 return nil, 1
             end
-
-            if flag == FLAG_FULL then
-                local value, consumed = innerStruct.read(src, pos + 1, refs)
-                return value, 1 + consumed
-            end
-
-            -- For now, treat any other flag as full (future: per-segment delta)
             local value, consumed = innerStruct.read(src, pos + 1, refs)
             return value, 1 + consumed
         end,
-    } :: any)
+    }) :: Types.InternalCodec<any>
 end
 
 return table.freeze(Struct)

package/src/codec/composite/Tagged.luau

@@ -2,16 +2,15 @@
 --!optimize 2
 -- Discriminated union codec. u8 variant tag + variant payload.
 
-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 Tagged = {}
 
@@ -37,7 +36,6 @@ function Tagged.define(
         error("[Lync] Lync.tagged: exceeds 256 variants")
     end
 
-    -- Build lookup tables
     local nameToTag: { [string]: number } = {}
     local tagToCodec = table.create(variantCount)
     local tagToName = table.create(variantCount)
@@ -49,7 +47,7 @@ function Tagged.define(
         nameToTag[name] = i - 1
         tagToCodec[i] = codec
         tagToName[i] = name
-        if (codec :: any)._hasUnknown then
+        if codec._hasUnknown then
             hasUnknown = true
         end
     end
@@ -58,25 +56,22 @@ function Tagged.define(
     table.freeze(tagToCodec)
     table.freeze(tagToName)
 
-    local codec: any = {
+    local codec: Types.InternalCodec<any> = {
+        _isTagged = true,
+        _tagField = tagField,
+        _variants = variants,
+
         write = function(ch: Types.ChannelState, value: any): ()
             local name = value[tagField]
             if name == nil then
-                error(`[Lync] Tagged: missing tagField "{tagField}" in value`)
+                error(`[Lync] Tagged.write: missing tagField "{tagField}"`)
             end
-
             local tag = nameToTag[name]
             if tag == nil then
-                error(`[Lync] Tagged: unknown variant "{name}"`)
-            end
-
-            local cursor = ch.cursor
-            if cursor + 1 > ch.size then
-                alloc(ch, 1)
+                error(`[Lync] Tagged.write: unknown variant "{name}"`)
             end
-            writeu8(ch.buff, cursor, tag)
-            ch.cursor = cursor + 1
 
+            writeByte(ch, tag)
             tagToCodec[tag + 1].write(ch, value)
         end,
 
@@ -84,21 +79,16 @@ function Tagged.define(
             local tag = readu8(src, pos)
             local varCodec = tagToCodec[tag + 1]
             if not varCodec then
-                error(`[Lync] Tagged: unknown tag {tag}`)
+                error(`[Lync] Tagged.read: unknown tag {tag}`)
             end
 
-            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
+                data[tagField] = tagToName[tag + 1]
             end
-
             return data, 1 + consumed
         end,
     }
-
     if hasUnknown then
         codec._hasUnknown = true
     end