@axpecter/lync 1.3.1 → 1.4.1

package/src/codec/composite/Array.luau

@@ -4,14 +4,15 @@
 
 local Baseline = require (script.Parent.Parent.Parent.internal.Baseline)
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Shared = require (script.Parent.Shared)
 local Types = require (script.Parent.Parent.Parent.Types)
+local Varint = require (script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
-local Varint = require (script.Parent.Parent.primitive.Varint)
+type InternalCodec<T> = Types.InternalCodec<T>
 
+local alloc = Channel.alloc
 local rangeEqual = Shared.rangeEqual
 local acquireScratch = Shared.acquireScratch
 local releaseScratch = Shared.releaseScratch
@@ -20,7 +21,7 @@ local FLAG_DELTA = Shared.FLAG_DELTA
 local FLAG_FULL = Shared.FLAG_FULL
 local FLAG_UNCHANGED = Shared.FLAG_UNCHANGED
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Array = {}
 
@@ -30,9 +31,10 @@ function Array.deltaArray (element: Codec<any>, maxCount: number?): Codec<{ any
     local writeElement = element.write
     local readElement = element.read
 
-    local elemSize = (element :: any)._size :: number?
-    local elemDirect = (element :: any)._directWrite
-    local elemDRead = (element :: any)._directRead
+    local internal = element :: InternalCodec<any>
+    local elemSize = internal._size
+    local elemWrite = internal._directWrite
+    local elemRead = internal._directRead
 
     return table.freeze ({
         _isDelta = true,
@@ -45,13 +47,13 @@ function Array.deltaArray (element: Codec<any>, maxCount: number?): Codec<{ any
             local bounds = table.create (len + 1)
             bounds[1] = 0
 
-            if elemDirect and elemSize then
+            if elemWrite and elemSize then
                 local totalBytes = len * elemSize
                 alloc (scratch, totalBytes)
                 local b = scratch.buff
                 local c = 0
                 for i = 1, len do
-                    elemDirect (b, c, value[i])
+                    elemWrite (b, c, value[i])
                     c += elemSize
                     bounds[i + 1] = c
                 end
@@ -147,9 +149,9 @@ function Array.deltaArray (element: Codec<any>, maxCount: number?): Codec<{ any
 
                 local result = table.create (len)
 
-                if elemDRead and elemSize then
+                if elemRead and elemSize then
                     for i = 1, len do
-                        result[i] = elemDRead (src, absPos)
+                        result[i] = elemRead (src, absPos)
                         absPos += elemSize
                     end
                 else
@@ -174,8 +176,8 @@ function Array.deltaArray (element: Codec<any>, maxCount: number?): Codec<{ any
                 local idx, idxBytes = Varint.read (src, absPos)
                 absPos += idxBytes
 
-                if elemDRead and elemSize then
-                    result[idx + 1] = elemDRead (src, absPos)
+                if elemRead and elemSize then
+                    result[idx + 1] = elemRead (src, absPos)
                     absPos += elemSize
                 else
                     local val, n = readElement (src, absPos, refs)
@@ -191,9 +193,10 @@ function Array.deltaArray (element: Codec<any>, maxCount: number?): Codec<{ any
 end
 
 function Array.array (element: Codec<any>, maxCount: number?): Codec<{ any }>
-    local elementSize = (element :: any)._size :: number?
-    local directWrite = (element :: any)._directWrite
-    local directRead = (element :: any)._directRead
+    local internal = element :: InternalCodec<any>
+    local elementSize = internal._size
+    local directWrite = internal._directWrite
+    local directRead = internal._directRead
 
     if elementSize and directWrite and directRead then
         return table.freeze ({

package/src/codec/composite/Map.luau

@@ -4,14 +4,15 @@
 
 local Baseline = require (script.Parent.Parent.Parent.internal.Baseline)
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Shared = require (script.Parent.Shared)
 local Types = require (script.Parent.Parent.Parent.Types)
+local Varint = require (script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
-local Varint = require (script.Parent.Parent.primitive.Varint)
+type InternalCodec<T> = Types.InternalCodec<T>
 
+local alloc = Channel.alloc
 local rangeEqual = Shared.rangeEqual
 local acquireScratch = Shared.acquireScratch
 local releaseScratch = Shared.releaseScratch
@@ -20,7 +21,7 @@ local FLAG_DELTA = Shared.FLAG_DELTA
 local FLAG_FULL = Shared.FLAG_FULL
 local FLAG_UNCHANGED = Shared.FLAG_UNCHANGED
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Map = {}
 
@@ -29,12 +30,15 @@ function Map.map (
     valueCodec: Codec<any>,
     maxCount: number?
 ): Codec<{ [any]: any }>
-    local keySize = (keyCodec :: any)._size :: number?
-    local valSize = (valueCodec :: any)._size :: number?
-    local keyDWrite = (keyCodec :: any)._directWrite
-    local valDWrite = (valueCodec :: any)._directWrite
-    local keyDRead = (keyCodec :: any)._directRead
-    local valDRead = (valueCodec :: any)._directRead
+    local keyInternal = keyCodec :: InternalCodec<any>
+    local valInternal = valueCodec :: InternalCodec<any>
+
+    local keySize = keyInternal._size
+    local valSize = valInternal._size
+    local keyDWrite = keyInternal._directWrite
+    local valDWrite = valInternal._directWrite
+    local keyDRead = keyInternal._directRead
+    local valDRead = valInternal._directRead
 
     if keySize and valSize and keyDWrite and valDWrite and keyDRead and valDRead then
         local entrySize = keySize + valSize
@@ -132,12 +136,14 @@ function Map.map (
     })
 end
 
--- Delta map: tracks per-key changes. First frame is full, then upserts + removes only.
---
--- Wire format:
---   FLAG_FULL:      u8(1) + varint(count) + [key+value ...]
---   FLAG_UNCHANGED: u8(2)
---   FLAG_DELTA:     u8(0) + varint(upsertN) + [key+value ...] + varint(removeN) + [key ...]
+--[[
+    Delta map: tracks per-key changes. First frame is full, then upserts + removes only.
+
+    Wire format:
+      FLAG_FULL:      u8(1) + varint(count) + [key+value ...]
+      FLAG_UNCHANGED: u8(2)
+      FLAG_DELTA:     u8(0) + varint(upsertN) + [key+value ...] + varint(removeN) + [key ...]
+]]
 function Map.deltaMap (
     keyCodec: Codec<any>,
     valueCodec: Codec<any>,
@@ -150,23 +156,39 @@ function Map.deltaMap (
     local readKey = keyCodec.read
     local readVal = valueCodec.read
 
-    local keySize = (keyCodec :: any)._size :: number?
-    local valSize = (valueCodec :: any)._size :: number?
-    local keyDWrite = (keyCodec :: any)._directWrite
-    local valDWrite = (valueCodec :: any)._directWrite
-    local keyDRead = (keyCodec :: any)._directRead
-    local valDRead = (valueCodec :: any)._directRead
+    local keyInternal = keyCodec :: InternalCodec<any>
+    local valInternal = valueCodec :: InternalCodec<any>
+
+    local keySize = keyInternal._size
+    local valSize = valInternal._size
+    local keyDWrite = keyInternal._directWrite
+    local valDWrite = valInternal._directWrite
+    local keyDRead = keyInternal._directRead
+    local valDRead = valInternal._directRead
+
     local scratchDirect = keySize and valSize and keyDWrite and valDWrite
     local entrySize = if keySize and valSize then keySize + valSize else nil
 
+    type EntryBounds = {
+        keyOff: number,
+        keyLen: number,
+        valOff: number,
+        valLen: number,
+    }
+
+    type DeltaMapCache = {
+        raw: buffer,
+        entries: { EntryBounds },
+        keyLookup: { [string]: number },
+        count: number,
+    }
+
     return table.freeze ({
         _isDelta = true,
 
         write = function (ch: ChannelState, value: { [any]: any }): ()
             local scratch = acquireScratch ()
 
-            type EntryBounds = { keyOff: number, keyLen: number, valOff: number, valLen: number }
-
             local entries = {} :: { EntryBounds }
             local keyLookup = {} :: { [string]: number }
             local entryCount = 0
@@ -213,14 +235,6 @@ function Map.deltaMap (
             end
 
             local scratchTotal = scratch.cursor
-
-            type DeltaMapCache = {
-                raw: buffer,
-                entries: { EntryBounds },
-                keyLookup: { [string]: number },
-                count: number,
-            }
-
             local cache = ch.deltas[deltaId] :: DeltaMapCache?
 
             if not cache then

package/src/codec/composite/Optional.luau

@@ -3,13 +3,14 @@
 -- Optional codec. 1 byte flag, value only if present.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- Public -----------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Public -------------------------------------------------------------
 
 local Optional = {}
 

package/src/codec/composite/Shared.luau

@@ -3,11 +3,13 @@
 -- Shared helpers for composite codecs: delta flags, scratch pool, struct field extraction, bool packing.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
+local Types = require (script.Parent.Parent.Parent.Types)
+
+type ChannelState = Types.ChannelState
 
-type ChannelState = any
+local alloc = Channel.alloc
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local band = bit32.band
 local bor = bit32.bor
@@ -19,13 +21,13 @@ local FLAG_DELTA = 0
 local FLAG_FULL = 1
 local FLAG_UNCHANGED = 2
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _nextDeltaId = 1
 local _scratchStack = {} :: { ChannelState }
 local _scratchDepth = 0
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Shared = {
     FLAG_DELTA = FLAG_DELTA,

package/src/codec/composite/Struct.luau

@@ -4,13 +4,14 @@
 
 local Baseline = require (script.Parent.Parent.Parent.internal.Baseline)
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Shared = require (script.Parent.Shared)
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
+type InternalCodec<T> = Types.InternalCodec<T>
 
+local alloc = Channel.alloc
 local extractFields = Shared.extractFields
 local packBools = Shared.packBools
 local unpackBools = Shared.unpackBools
@@ -34,7 +35,7 @@ type DeltaCache = {
     total: number,
 }
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Struct = {}
 
@@ -55,7 +56,7 @@ function Struct.struct (schema: { [string]: Codec<any> }): Codec<any>
     local fieldSizes = table.create (dataCount) :: { number }
 
     for i = 1, dataCount do
-        local codec = dataCodecs[i] :: any
+        local codec = dataCodecs[i] :: InternalCodec<any>
         local size = codec._size
         local dw = codec._directWrite
         local dr = codec._directRead
@@ -183,6 +184,7 @@ function Struct.struct (schema: { [string]: Codec<any> }): Codec<any>
         end,
     })
 end
+
 function Struct.deltaStruct (schema: { [string]: Codec<any> }): Codec<any>
     local dataKeys, dataCodecs, boolKeys = extractFields (schema)
 
@@ -213,7 +215,7 @@ function Struct.deltaStruct (schema: { [string]: Codec<any> }): Codec<any>
     local scratchDataTotal = 0
 
     for i = 1, dataCount do
-        local codec = dataCodecs[i] :: any
+        local codec = dataCodecs[i] :: InternalCodec<any>
         local size = codec._size
         local dw = codec._directWrite
         if size and dw then

package/src/codec/composite/Tagged.luau

@@ -3,13 +3,15 @@
 -- Discriminated union codec. u8 variant tag + variant payload.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
+type InternalCodec<T> = Types.InternalCodec<T>
+
+local alloc = Channel.alloc
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Tagged = {}
 
@@ -42,12 +44,12 @@ function Tagged.define (tagField: string, variants: { [string]: Codec<any> }): C
     local tagSizes = table.create (count) :: { number? }
 
     local allDirect = true
-    local uniformSize: number? = (variants[names[1]] :: any)._size
+    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] :: any
+        local codec = variants[name] :: InternalCodec<any>
         nameToTag[name] = i
         tagCodecs[i] = codec
         tagNames[i] = name
@@ -82,8 +84,6 @@ function Tagged.define (tagField: string, variants: { [string]: Codec<any> }): C
 
         -- If uniform size, expose _directWrite/_directRead for parent struct/array
         if fixedSize then
-            local variantBytes = uniformSize :: number
-
             return table.freeze ({
                 _size = fixedSize,
                 _directWrite = function (b: buffer, offset: number, value: any): ()

package/src/codec/composite/Tuple.luau

@@ -3,13 +3,15 @@
 -- Positional ordered codec. Like struct but indexed, not keyed.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
+type InternalCodec<T> = Types.InternalCodec<T>
+
+local alloc = Channel.alloc
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Tuple = {}
 
@@ -29,10 +31,10 @@ function Tuple.define (...: Codec<any>): Codec<{ any }>
     local fieldSizes = table.create (count) :: { number }
 
     for i = 1, count do
-        local codec = codecs[i] :: any
-        local size = codec._size
-        local dw = codec._directWrite
-        local dr = codec._directRead
+        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
@@ -54,7 +56,7 @@ function Tuple.define (...: Codec<any>): Codec<{ any }>
     if not canDirect then
         totalSize = 0 :: any
         for i = 1, count do
-            local size = (codecs[i] :: any)._size
+            local size = (codecs[i] :: InternalCodec<any>)._size
             if size then
                 totalSize = (totalSize :: number) + size
             else

package/src/codec/datatype/Buffer.luau

@@ -3,13 +3,14 @@
 -- Raw buffer codec with varint length prefix.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 local Varint = require (script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 
--- Public -----------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Public -------------------------------------------------------------
 
 local Buffer = {}
 

package/src/codec/datatype/CFrame.luau

@@ -4,9 +4,10 @@
 
 local Base = require (script.Parent.Parent.Base)
 
+local sqrt = math.sqrt
+
 -- f32 machine epsilon * 2 to absorb round-trip noise.
 local EPSILON = 2.4e-7
-local sqrt = math.sqrt
 
 local function writeCFrame (b: buffer, c: number, value: CFrame): ()
     local position = value.Position

package/src/codec/datatype/Instance.luau

@@ -3,12 +3,13 @@
 -- Instance codec via sidecar reference array.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
--- Public -----------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Public -------------------------------------------------------------
 
 local InstanceCodec = {}
 

package/src/codec/datatype/Sequence.luau

@@ -3,15 +3,14 @@
 -- NumberSequence and ColorSequence codecs with varint length prefix.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 local Varint = require (script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 
-type ChannelState = Types.ChannelState
+local alloc = Channel.alloc
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local NS_STRIDE = 12
 local CS_STRIDE = 7
@@ -19,7 +18,7 @@ local CS_STRIDE = 7
 local round = math.round
 local clamp = math.clamp
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Sequence = {}
 

package/src/codec/datatype/String.luau

@@ -3,17 +3,14 @@
 -- Variable-length string codec with varint length prefix.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 local Varint = require (script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 
--- Constants --------------------------------------------------------------
-
-local floor = math.floor
+local alloc = Channel.alloc
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local String = {}
 
@@ -59,7 +56,7 @@ String.string = table.freeze ({
 })
 
 function String.bounded (maxLength: number): any
-    if maxLength <= 0 or maxLength ~= floor (maxLength) then
+    if maxLength <= 0 or maxLength ~= math.floor (maxLength) then
         error (`[Lync] boundedString maxLength must be a positive integer, got {maxLength}`)
     end