@axpecter/lync 2.2.1 → 2.3.1

package/src/codec/composite/Map.luau

@@ -1,26 +1,48 @@
 --!strict
 --!native
--- Map and deltaMap codecs.
+-- map() and deltaMap(). Keys sorted at encode for stable wire bytes.
 
 local Base = require(script.Parent.Parent.Base)
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
-local Shared = require(script.Parent.Shared)
+local Baseline = require(script.Parent.Parent.Parent.internal.Baseline)
+local Log = require(script.Parent.Parent.Parent.util.Log)
+local Shared = require(script.Parent.Parent.composite.Shared)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
+-- State ------------------------------------------------------------------
+
+--[[
+    Depth-stacked key scratch. A nested Map.write (Map<K, Map<K2, V>>) would
+    clobber a single shared array mid-iteration; the stack gives each frame
+    its own slot. Mirrors Shared.acquireScratch / releaseScratch.
+]]
+local _keyStacks: { { any } } = {}
+local _keyDepth = 0
+
 -- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
-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
+
+local function acquireKeys(): { any }
+    _keyDepth += 1
+    local keys = _keyStacks[_keyDepth]
+    if keys then
+        return keys
+    end
+    keys = {}
+    _keyStacks[_keyDepth] = keys
+    return keys
+end
+
+local function releaseKeys(): ()
+    _keyDepth -= 1
+end
+
+-- Module-level so the mixed-type sort path doesn't allocate a closure per write.
+local function tostringLess(a: any, b: any): boolean
+    return tostring(a) < tostring(b)
+end
 
 -- Public -----------------------------------------------------------------
 
@@ -33,24 +55,59 @@ function Map.map(
 ): Types.InternalCodec<any>
     local fixedKey = keyCodec._size
     local fixedValue = valueCodec._size
+    local hasUnknown = keyCodec._hasUnknown or valueCodec._hasUnknown
 
-    return table.freeze({
+    --[[
+        Numbers and strings sort by `<` directly; everything else (Instance,
+        vector, mixed-type via Auto) routes through tostring. Pinned at codec
+        creation so writes don't re-sniff the key type.
+    ]]
+    local typeCheck = keyCodec._typeCheck
+    local canSortDirect = typeCheck == "number" or typeCheck == "string"
+
+    local codec: Types.InternalCodec<any> = {
         _isMap = true,
         _keyCodec = keyCodec,
         _valueCodec = valueCodec,
         _maxCount = maxCount,
 
+        --[[
+            Sort keys for deterministic wire layout. Without this, two
+            structurally-equal maps yield different byte sequences across
+            frames, which breaks every downstream byte-equality cache (the
+            XOR baseline and deltaMap).
+        ]]
         write = function(ch: Types.ChannelState, value: { [any]: any }): ()
+            if typeof(value) ~= "table" then
+                Log.error(`expected table, got {typeof(value)}`)
+            end
+
+            local keys = acquireKeys()
             local count = 0
-            for _ in value do
+            for k in value do
                 count += 1
+                keys[count] = k
+            end
+
+            -- Drop tail entries from the prior reuse so table.sort sees only `count` items.
+            local prevTail = #keys
+            for i = count + 1, prevTail do
+                keys[i] = nil
             end
 
             Varint.write(ch, count)
             if count == 0 then
+                releaseKeys()
                 return
             end
 
+            if canSortDirect then
+                table.sort(keys :: { any })
+            else
+                table.sort(keys, tostringLess)
+            end
+
+            -- Single alloc when both halves are fixed-size.
             if fixedKey and fixedValue then
                 local entrySize = fixedKey + fixedValue
                 local cursor = ch.cursor
@@ -59,33 +116,53 @@ function Map.map(
                 end
             end
 
-            for k, v in value do
+            for i = 1, count do
+                local k = keys[i]
                 keyCodec.write(ch, k)
-                valueCodec.write(ch, v)
+                valueCodec.write(ch, value[k])
+                keys[i] = nil
             end
+            releaseKeys()
         end,
 
         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.read: count {count} exceeds max {maxCount}`)
+                Log.error(`count {count} exceeds max {maxCount}`)
+            end
+
+            -- Fixed-size: reject corrupt counts before per-entry decode.
+            if fixedKey and fixedValue and count > 0 then
+                local entrySize = fixedKey + fixedValue
+                local dataStart = pos + lenBytes
+                local payloadBytes = count * entrySize
+                if payloadBytes > buffer.len(src) - dataStart then
+                    Log.error(`payload {payloadBytes}B exceeds remaining buffer`)
+                end
             end
 
             local result: { [any]: any } = {}
             local total = lenBytes
             for i = 1, count do
                 local k, kc = keyCodec.read(src, pos + total, refs)
+                if kc == 0 then
+                    Log.error(`truncated key at index {i}`)
+                end
                 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}`)
+                if vc == 0 then
+                    Log.error(`truncated value at index {i}`)
                 end
+                total += vc
                 result[k] = v
             end
             return result, total
         end,
-    })
+    }
+    if hasUnknown then
+        codec._hasUnknown = true
+    end
+    return table.freeze(codec)
 end
 
 function Map.deltaMap(
@@ -93,57 +170,11 @@ function Map.deltaMap(
     valueCodec: Types.InternalCodec<any>,
     maxCount: number?
 ): Types.InternalCodec<any>
-    local deltaId = allocDeltaId()
-    local innerMap = Map.map(keyCodec, valueCodec, maxCount)
-
-    return table.freeze({
-        _isDelta = true,
-
-        write = function(ch: Types.ChannelState, value: { [any]: any }): ()
-            local cache = ch.deltas[deltaId]
-
-            if not cache then
-                writeByte(ch, DELTA_FULL)
-
-                local scratch = acquireScratch()
-                innerMap.write(scratch, value)
-                local snapLen = scratch.cursor
-
-                ch.deltas[deltaId] = { raw = snapshot(scratch.buff, snapLen), len = snapLen }
-                innerMap.write(ch, value)
-                releaseScratch()
-                return
-            end
-
-            local scratch = acquireScratch()
-            innerMap.write(scratch, value)
-            local scratchLen = scratch.cursor
-
-            if
-                scratchLen == cache.len
-                and rangeEqual(scratch.buff, 0, cache.raw, 0, scratchLen)
-            then
-                writeByte(ch, DELTA_UNCHANGED)
-                releaseScratch()
-                return
-            end
-
-            writeByte(ch, DELTA_FULL)
-            innerMap.write(ch, value)
-
-            cache.raw = snapshot(scratch.buff, scratchLen)
-            cache.len = scratchLen
-            releaseScratch()
-        end,
-
-        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,
-    })
+    return Shared.makeUnchangedOrFullDelta(
+        Map.map(keyCodec, valueCodec, maxCount),
+        allocDeltaId(),
+        Baseline
+    )
 end
 
 return table.freeze(Map)

package/src/codec/composite/Optional.luau

@@ -1,14 +1,16 @@
 --!strict
---!optimize 2
--- Optional codec. 1-byte present/absent flag, value only if present.
+--!native
+-- Optional codec. 1-byte present/absent flag, value only when present.
 
 local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Private ----------------------------------------------------------------
 
 local writeByte = Channel.writeByte
 local readu8 = buffer.readu8
+local bufferLen = buffer.len
 
 -- Public -----------------------------------------------------------------
 
@@ -29,6 +31,7 @@ function Optional.optional(inner: Types.InternalCodec<any>): Types.InternalCodec
         end,
 
         read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
+            Log.assert(pos < bufferLen(src), "presence byte missing at end of buffer")
             if readu8(src, pos) == 0 then
                 return nil, 1
             end
@@ -37,6 +40,7 @@ function Optional.optional(inner: Types.InternalCodec<any>): Types.InternalCodec
         end,
     }
 
+    -- Propagate _hasUnknown so Gate skips schema validation upstream.
     if inner._hasUnknown then
         codec._hasUnknown = true
     end

package/src/codec/composite/Shared.luau

@@ -1,29 +1,27 @@
 --!strict
 --!native
--- Shared helpers for composite codecs: delta flags, scratch pool, bool packing.
+-- Shared composite-codec helpers: delta flags, scratch pool, bool packing.
 
 local Base = require(script.Parent.Parent.Base)
+local Buf = require(script.Parent.Parent.Parent.util.Buffer)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- 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.
+    Delta flag space, shared across deltaStruct/deltaArray/deltaMap:
+      0    UNCHANGED  (decoder reuses cache)
+      1    FULL       (full payload follows)
+    Struct's per-segment scheme uses [1..segCount] as a single-dirty-segment
+    index, then segCount + DELTA_FULL_OFFSET / + DELTA_MULTI_OFFSET.
 ]]
 local DELTA_UNCHANGED = 0
 local DELTA_FULL = 1
 local DELTA_FULL_OFFSET = 1
 local DELTA_MULTI_OFFSET = 2
 
-local INITIAL_SCRATCH = 1024
-
 -- State ------------------------------------------------------------------
 
 local _nextDeltaId = 0
@@ -35,49 +33,37 @@ local _scratchStack: { Types.ChannelState } = {}
 local alloc = Base.alloc
 local band = bit32.band
 local bor = bit32.bor
-local bxor = bit32.bxor
 local lshift = bit32.lshift
 local readu8 = buffer.readu8
-local readu32 = buffer.readu32
 local writeu8 = buffer.writeu8
-
-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
+local bufCopy = buffer.copy
+local rangeEqual = Buf.rangeEqual
+local snapshot = Buf.snapshot
 
 -- 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
+Shared.rangeEqual = rangeEqual
+Shared.snapshot = snapshot
 
 function Shared.allocDeltaId(): number
     _nextDeltaId += 1
     return _nextDeltaId
 end
 
+-- 8 bools per byte.
+function Shared.boolBytes(n: number): number
+    return (n + 7) // 8
+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.
+    Stack-based scratch ChannelState pool. 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
@@ -87,7 +73,7 @@ function Shared.acquireScratch(): Types.ChannelState
         ch.refCount = 0
         return ch
     end
-    ch = newScratch()
+    ch = Channel.create()
     _scratchStack[_scratchDepth] = ch
     return ch
 end
@@ -96,35 +82,9 @@ function Shared.releaseScratch(): ()
     _scratchDepth -= 1
 end
 
-function Shared.rangeEqual(a: buffer, offA: number, b: buffer, offB: number, len: number): boolean
-    local aligned = band(len, -4)
-    local i = 0
-    while i < aligned do
-        if bxor(readu32(a, offA + i), readu32(b, offB + i)) ~= 0 then
-            return false
-        end
-        i += 4
-    end
-    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.
+    Split a struct schema into (dataKeys, dataCodecs, boolKeys), each sorted
+    alphabetically for deterministic wire layout.
 ]]
 function Shared.extractFields(
     schema: { [string]: Types.InternalCodec<any> }
@@ -140,9 +100,7 @@ function Shared.extractFields(
         end
     end
 
-    if #dataKeys == 0 and #boolKeys == 0 then
-        error("[Lync] Lync.struct: requires at least one field")
-    end
+    Log.assert(#dataKeys > 0 or #boolKeys > 0, "requires at least one field")
 
     table.sort(dataKeys)
     table.sort(boolKeys)
@@ -174,9 +132,9 @@ function Shared.packBools(
     if cursor + byteCount > ch.size then
         alloc(ch, byteCount)
     end
-    local b = ch.buff
 
     local idx = 1
+    local b = ch.buff
     for byteIdx = 0, byteCount - 1 do
         local packed = 0
         local remaining = boolCount - idx + 1
@@ -193,6 +151,39 @@ function Shared.packBools(
     ch.cursor = cursor + byteCount
 end
 
+--[[
+    Integer-indexed bool-array pack. Split from packBools to skip the
+    per-bit string-key getter on the bool-array hot path.
+]]
+function Shared.packBoolArray(ch: Types.ChannelState, value: { boolean }, count: number): ()
+    if count == 0 then
+        return
+    end
+
+    local byteCount = (count + 7) // 8
+    local cursor = ch.cursor
+    if cursor + byteCount > ch.size then
+        alloc(ch, byteCount)
+    end
+
+    local idx = 1
+    local b = ch.buff
+    for byteIdx = 0, byteCount - 1 do
+        local packed = 0
+        local remaining = count - 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
+
 function Shared.unpackBools(
     src: buffer,
     pos: number,
@@ -218,4 +209,104 @@ function Shared.unpackBools(
     return byteCount
 end
 
+-- Fills `result[1..count]` in place.
+function Shared.unpackBoolArray(
+    src: buffer,
+    pos: number,
+    count: number,
+    result: { boolean }
+): number
+    if count == 0 then
+        return 0
+    end
+
+    local byteCount = (count + 7) // 8
+    local idx = 1
+    for byteIdx = 0, byteCount - 1 do
+        local byte = readu8(src, pos + byteIdx)
+        local remaining = count - 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 byteCount
+end
+
+--[[
+    Build a byte-equality delta codec around any inner codec. Wire:
+      [DELTA_UNCHANGED]                       1 byte
+      [DELTA_FULL]  <inner-encoded payload>   1 + N bytes
+    Used by deltaArray and deltaMap. The FULL path encodes once into scratch
+    then bufCopies into the channel — avoids a double encode.
+]]
+function Shared.makeUnchangedOrFullDelta(
+    inner: Types.InternalCodec<any>,
+    deltaId: number,
+    Baseline: {
+        getCache: (number) -> any,
+        setCache: (number, any) -> (),
+    }
+): Types.InternalCodec<any>
+    return table.freeze({
+        _isDelta = true,
+
+        write = function(ch: Types.ChannelState, value: any): ()
+            local scratch = Shared.acquireScratch()
+            inner.write(scratch, value)
+            local scratchLen = scratch.cursor
+
+            local cache = ch.deltas[deltaId]
+            if
+                cache
+                and 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
+                Shared.releaseScratch()
+                return
+            end
+
+            local cursor = ch.cursor
+            if cursor + 1 + scratchLen > ch.size then
+                alloc(ch, 1 + scratchLen)
+            end
+            local b = ch.buff
+            writeu8(b, cursor, DELTA_FULL)
+            if scratchLen > 0 then
+                bufCopy(b, cursor + 1, scratch.buff, 0, scratchLen)
+            end
+            ch.cursor = cursor + 1 + scratchLen
+
+            local snap = snapshot(scratch.buff, scratchLen)
+            if cache then
+                cache.raw = snap
+                cache.len = scratchLen
+            else
+                ch.deltas[deltaId] = { raw = snap, len = scratchLen }
+            end
+            Shared.releaseScratch()
+        end,
+
+        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
+            if readu8(src, pos) == DELTA_UNCHANGED then
+                local cached = Baseline.getCache(deltaId)
+                if not cached then
+                    Log.error("UNCHANGED flag before any FULL frame; baseline missing")
+                end
+                return cached, 1
+            end
+            local value, consumed = inner.read(src, pos + 1, refs)
+            Baseline.setCache(deltaId, value)
+            return value, 1 + consumed
+        end,
+    })
+end
+
 return table.freeze(Shared)