@axpecter/lync 2.3.1 → 2.3.2

package/README.md

@@ -16,7 +16,7 @@ Schemas, packets, queries, groups, validation, rate limiting. Every send batches
 Wally — add to your `wally.toml`:
 
 ```toml
-Lync = "axp3cter/lync@2.3.1"
+Lync = "axp3cter/lync@2.3.2"
 ```
 
 npm (roblox-ts):
@@ -250,8 +250,9 @@ Enable with `Lync.configure({ stats = true })`.
 | Codec | Bytes | Notes |
 |:---|---:|:---|
 | `int(min, max)` | 1 / 2 / 4 | Picks narrowest u8/u16/u32/i8/i16/i32. |
+| `zint(min?, max?)` | 1 – 5 | Variable-length signed via zigzag varint. 1 byte for [-96, 95]. |
 | `f16` / `f32` / `f64` | 2 / 4 / 8 | `f16` ≈ ±65504, ~3 digits. |
-| `float(min, max, precision)` | 1 / 2 / 4 | Quantized; clamped to range. |
+| `float(min, max, precision)` | 1 / 2 / 3 / 4 | Quantized; picks u8 / u16 / u24 / u32 wire form. |
 | `bool` | 1 | Auto-bitpacked inside `struct` and `array`. |
 
 ### Strings & buffers
@@ -284,8 +285,8 @@ Call as a function for compression.
 
 | Codec | Bytes | Notes |
 |:---|---:|:---|
-| `vec2(min, max, precision)` | 2 / 4 / 8 | Per-component quantization. |
-| `vec3(min, max, precision)` | 3 / 6 / 12 | Per-component quantization. |
+| `vec2(min, max, precision)` | 2 / 4 / 6 / 8 | Per-component, narrowest fitting width. |
+| `vec3(min, max, precision)` | 3 / 6 / 9 / 12 | Per-component, narrowest fitting width. |
 | `cframe()` | 16 | Smallest-three quaternion. ≤ 0.16° rotation error. |
 
 ### Composites
@@ -301,13 +302,20 @@ Call as a function for compression.
 
 ### Delta — reliable transport only
 
-Sends 1 byte when the value is byte-equal to the cached previous frame.
+Tracks the previous frame's value and ships only what changed. Rejected on `unreliable = true`.
 
-| Codec | Notes |
-|:---|:---|
-| `deltaStruct(schema)` | Per-segment dirty bitmap; single-segment fast path. |
-| `deltaArray(c, max?)` | Whole-array byte-equality. |
-| `deltaMap(k, v, max?)` | Whole-map byte-equality. |
+| Codec | Static | Mutation |
+|:---|:---:|:---:|
+| `deltaStruct(schema)` | 1 B | per-field |
+| `deltaArray(c, max?)` | 1 B | per-changed-index |
+| `deltaMap(k, v, max?)` | 1 B | per-changed-key |
+| `deltaInt(min, max)` | 1 B | 1–5 B |
+| `deltaFloat(min, max, precision)` | 1 B | 1–5 B |
+| `deltaVec3(min, max, precision)` | 3 B | 3–15 B |
+| `deltaCFrame(posMin, posMax, precision)` | 1 B | 4–13 B |
+
+- `deltaArray` element / `deltaMap` key+value cannot themselves contain delta state. Use `deltaStruct` for per-field deltas inside.
+- `deltaVec3` and `deltaCFrame` error on out-of-range components.
 
 ### Meta
 
@@ -351,21 +359,23 @@ Global per-player cap: `Lync.configure({ globalRateLimit = { maxPerSecond = N }
 | Tool | `array<entity>[100]` | `array<bool>[1000]` |
 |:---|:---|:---|
 | roblox | 16 fps · 559,364 Kbps | 21 fps · 353,107 Kbps |
-| **lync** | **60 fps · 3.44 Kbps** | **60 fps · 2.46 Kbps** |
+| **lync** | **59 fps · 3.37 Kbps** | **61 fps · 2.45 Kbps** |
 | blink | 42 fps · 41.81 Kbps | 97 fps · 7.91 Kbps |
 | zap | 39 fps · 41.71 Kbps | 52 fps · 8.10 Kbps |
 | bytenet | 32 fps · 41.64 Kbps | 35 fps · 8.11 Kbps |
 
 ### Network bandwidth — 100 fires/frame, 8 s
 
-| Workload | Kbps |
-|:---|---:|
-| `array<entity>[100]` randomised | 3,608 |
-| `array<entity>[100]` reused | **2.4** |
-| `array<bool>[1000]` randomised | 763 |
-| `array<bool>[1000]` 1 bit flipped | **20.5** |
-| `struct(state)` randomised | 201 |
-| `deltaStruct(state)` 1 field mutated | **29.2** |
+| Workload | Naive Kbps | Optimized | Savings |
+|:---|---:|:---|---:|
+| `array<entity>[100]` random | 3,607 | `deltaArray` 3 of 100 mutated | **154** (–96%) |
+| `array<entity>[100]` reused | 3,607 | XOR baseline (identical frames) | **2.4** (–99.9%) |
+| `array<bool>[1000]` random | 762 | XOR baseline (1 bit flipped) | **20.4** (–97%) |
+| `struct(state)` random | 201 | `deltaStruct` 1 field mutated | **29.0** (–86%) |
+| `map<id, vec3>[200]` 5 keys mutated | 657 | `deltaMap` 5 keys mutated | **393** (–40%) |
+| `array<cframe>[50]` random | 4,585 | — | — |
+| `vec3` walking motion (continuous diff) | — | `deltaVec3` | **19.5** |
+| `CFrame` walking pose (pos + rot) | — | `deltaCFrame` | **41.1** |
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@axpecter/lync",
-    "version": "2.3.1",
+    "version": "2.3.2",
     "description": "Buffer networking for Roblox. Delta compression, XOR framing, built-in security",
     "main": "src/init.luau",
     "types": "src/index.d.ts",

package/src/Types.luau

@@ -12,17 +12,18 @@ export type ChannelState = {
     itemCount: number,
     singleMode: boolean,
     singlePos: number,
-    deltas: { [number]: DeltaCacheEntry },
+    --[[
+        Per-codec write-side delta state, keyed by deltaId. Shape is opaque
+        and codec-internal: deltaStruct stores `{raw, len, segOff, segLen}`,
+        deltaArray stores `{perIdx, length}`, deltaMap stores `{perKey}`,
+        delta scalars store quantized previous values.
+    ]]
+    deltas: { [number]: any },
     prevDump: buffer?,
     prevDumpLen: number,
     currentPacket: string?,
 }
 
-export type DeltaCacheEntry = {
-    raw: buffer,
-    len: number,
-}
-
 export type Codec<T> = {
     write: (ch: ChannelState, value: T) -> (),
     read: (src: buffer, pos: number, refs: { Instance }?) -> (T, number),
@@ -39,6 +40,11 @@ export type InternalCodec<T> = {
     _directWrite: ((b: buffer, offset: number, value: T) -> ())?,
     _directRead: ((b: buffer, offset: number) -> T)?,
     _isDelta: boolean?,
+    --[[
+        True if any nested codec is delta. Lets the broadcast hot path skip
+        encode-once when delta state would diverge per-receiver.
+    ]]
+    _hasDelta: boolean?,
     _isBool: boolean?,
     _hasUnknown: boolean?,
     _min: number?,

package/src/api/Packet.luau

@@ -11,6 +11,7 @@ local Log = require(script.Parent.Parent.util.Log)
 local Middleware = require(script.Parent.Parent.internal.Middleware)
 local Player = require(script.Parent.Parent.util.Player)
 local Registry = require(script.Parent.Parent.internal.Registry)
+local Shared = require(script.Parent.Parent.codec.composite.Shared)
 local Transport = require(script.Parent.Parent.internal.Transport)
 local Types = require(script.Parent.Parent.Types)
 
@@ -129,14 +130,102 @@ function Packet.define<T>(
         return false, sendData
     end
 
-    -- Caller has already run send middleware once for the broadcast.
+    -- Non-delta codecs are stateless wire-encoders, so broadcast can encode
+    -- once and bufCopy the payload to every player. Falls through if the
+    -- encoded payload includes ref indices (the indices would need rewriting
+    -- per channel, which no codec exposes).
+    local canEncodeOnce = not codec._isDelta and not codec._hasDelta
+
     local function broadcast(players: { Player }, data: any): ()
-        for _, p in players do
-            sendToPlayer(p, data)
+        local count = #players
+        if count == 0 then
+            bumpFires()
+            return
+        end
+
+        if canEncodeOnce then
+            local scratch = Shared.acquireScratch()
+            scratch.currentPacket = name
+            codec.write(scratch, data)
+            scratch.currentPacket = nil
+            if scratch.refCount == 0 then
+                local payload = scratch.buff
+                local payloadLen = scratch.cursor
+                local server = Transport.server()
+                -- Channel.writeBatchEncoded is hot-swapped by enableStats; re-read per call.
+                local writeBatchEncoded = Channel.writeBatchEncoded
+                for i = 1, count do
+                    writeBatchEncoded(
+                        server.getChannel(players[i], isUnreliable),
+                        reg,
+                        payload,
+                        payloadLen
+                    )
+                end
+                Shared.releaseScratch()
+                bumpFires()
+                return
+            end
+            Shared.releaseScratch()
+        end
+
+        for i = 1, count do
+            sendToPlayer(players[i], data)
         end
         bumpFires()
     end
 
+    --[[
+        Resolve a target table into a { Player } list. Returns nil for unknown
+        sentinel kinds; the caller errors with the original target type.
+    ]]
+    local function resolveAudience(target: any): { Player }?
+        local kind = target._lyncKind
+        if kind == "all" then
+            return Players:GetPlayers()
+        end
+
+        if kind == "except" then
+            local excluded = target._excluded :: { [Player]: boolean }
+            local all = Players:GetPlayers()
+            local list = table.create(#all)
+            local n = 0
+            for _, player in all do
+                if not excluded[player] then
+                    n += 1
+                    list[n] = player
+                end
+            end
+            return list
+        end
+
+        if kind == "group" then
+            local members = target._members :: { [Player]: boolean }
+            local list: { Player } = {}
+            local n = 0
+            for player in members do
+                n += 1
+                list[n] = player
+            end
+            return list
+        end
+
+        if kind == nil then
+            -- Plain { Player } array. Validate entries on the way to a clean list.
+            local list: { Player } = {}
+            local n = 0
+            for _, player in target do
+                if isPlayer(player) then
+                    n += 1
+                    list[n] = player :: Player
+                end
+            end
+            return list
+        end
+
+        return nil
+    end
+
     local function sendToTarget(data: any, target: any): ()
         if isPlayer(target) then
             local dropped, sendData = applySend(data, target :: Player)
@@ -153,40 +242,11 @@ function Packet.define<T>(
             if dropped then
                 return
             end
-
-            local kind = target._lyncKind
-            if kind == "all" then
-                broadcast(Players:GetPlayers(), sendData)
-                return
-            end
-
-            if kind == "except" then
-                local excluded = target._excluded :: { [Player]: boolean }
-                for _, p in Players:GetPlayers() do
-                    if not excluded[p] then
-                        sendToPlayer(p, sendData)
-                    end
-                end
-                bumpFires()
-                return
-            end
-
-            if kind == "group" then
-                for p in target._members :: { [Player]: boolean } do
-                    sendToPlayer(p, sendData)
-                end
-                bumpFires()
+            local audience = resolveAudience(target)
+            if audience then
+                broadcast(audience, sendData)
                 return
             end
-
-            -- Plain { Player } array.
-            for _, p in target do
-                if isPlayer(p) then
-                    sendToPlayer(p :: Player, sendData)
-                end
-            end
-            bumpFires()
-            return
         end
 
         Log.error(`"{name}" expected Player, table, Group, or Lync.all, got {typeof(target)}`)

package/src/codec/Base.luau

@@ -56,6 +56,13 @@ local Base = {}
 Base.INITIAL_BUF = INITIAL_BUF
 Base.alloc = alloc
 
+-- Cheap inline guard hoisted into every codec that grows a channel directly.
+function Base.ensure(ch: Types.ChannelState, n: number): ()
+    if ch.cursor + n > ch.size then
+        alloc(ch, n)
+    end
+end
+
 -- Floor is INITIAL_BUF: anything smaller errors on the very first write.
 function Base.setMaxSize(bytes: number): ()
     if bytes < INITIAL_BUF then

package/src/codec/composite/Array.luau

@@ -9,15 +9,36 @@ local Shared = require(script.Parent.Parent.composite.Shared)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
+-- Constants --------------------------------------------------------------
+
+-- deltaArray wire flags. Distinct from Shared's struct/map flag spaces.
+local DA_UNCHANGED = 0
+local DA_FULL = 1
+local DA_PATCH = 2
+
 -- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
+local ensure = Base.ensure
 local allocDeltaId = Shared.allocDeltaId
+local acquireScratch = Shared.acquireScratch
+local releaseScratch = Shared.releaseScratch
+local rangeEqual = Shared.rangeEqual
+local copyToBuf = Shared.copyToBuf
+local containsDelta = Shared.containsDelta
+local enforceMaxCount = Shared.enforceMaxCount
 local boolBytes = Shared.boolBytes
 local packBoolArray = Shared.packBoolArray
 local unpackBoolArray = Shared.unpackBoolArray
 local varintRead = Varint.read
 local varintWrite = Varint.write
+local varintLength = Varint.length
+local writeu8 = buffer.writeu8
+local readu8 = buffer.readu8
+local bufCopy = buffer.copy
+local bufLen = buffer.len
+
+type DeltaArrayEntry = { eBuf: buffer, eLen: number }
 
 -- Bit-packed bool element fast path: 1 bit per entry instead of 1 byte.
 local function makeBoolArray(
@@ -37,16 +58,14 @@ local function makeBoolArray(
 
         read = function(src: buffer, pos: number, _refs: { Instance }?): ({ boolean }, number)
             local len, lenBytes = varintRead(src, pos)
-            if maxCount and len > maxCount then
-                Log.error(`count {len} exceeds max {maxCount}`)
-            end
+            enforceMaxCount(len, maxCount)
             if len == 0 then
                 return {}, lenBytes
             end
 
             local byteCount = boolBytes(len)
             local dataStart = pos + lenBytes
-            if dataStart + byteCount > buffer.len(src) then
+            if dataStart + byteCount > bufLen(src) then
                 Log.error(`payload {byteCount}B exceeds remaining buffer`)
             end
             local result = table.create(len, false)
@@ -92,16 +111,14 @@ local function makeDirectArray(
 
         read = function(src: buffer, pos: number, _refs: { Instance }?): ({ any }, number)
             local len, lenBytes = varintRead(src, pos)
-            if maxCount and len > maxCount then
-                Log.error(`count {len} exceeds max {maxCount}`)
-            end
+            enforceMaxCount(len, maxCount)
             if len == 0 then
                 return {}, lenBytes
             end
 
             local payloadBytes = len * elemSize
             local dataStart = pos + lenBytes
-            if payloadBytes > buffer.len(src) - dataStart then
+            if payloadBytes > bufLen(src) - dataStart then
                 Log.error(`payload {payloadBytes}B exceeds remaining buffer`)
             end
 
@@ -136,9 +153,7 @@ local function makeGenericArray(
 
         read = function(src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
             local len, lenBytes = varintRead(src, pos)
-            if maxCount and len > maxCount then
-                Log.error(`count {len} exceeds max {maxCount}`)
-            end
+            enforceMaxCount(len, maxCount)
             if len == 0 then
                 return {}, lenBytes
             end
@@ -179,19 +194,263 @@ function Array.array(element: Types.InternalCodec<any>, maxCount: number?): Type
     if element._hasUnknown then
         codec._hasUnknown = true
     end
+    if containsDelta(element) then
+        codec._hasDelta = true
+    end
     return table.freeze(codec)
 end
 
 --[[
-    UNCHANGED-or-FULL delta. Useful only when contents AND order are stable
-    across frames; for unstable lists, plain array() avoids a 1-byte tax on
-    every frame the byte-equality cache misses.
+    Per-index deltaArray. Wire:
+      [0] UNCHANGED  (1 byte)
+      [1] FULL       <count varint> <element bytes ...>
+      [2] PATCH      <newLen varint> <changeCount varint>
+                     <(idx varint, element bytes) ...>
+
+    Length shrinkage is implicit in newLen — entries past newLen drop from
+    the cached map. Length growth: appended indices show up as changes.
+    Reordered lists tend to mark every index changed; the writer falls back
+    to FULL when changeCount * 2 >= newLen since PATCH index varints eat
+    any savings past that ratio.
 ]]
 function Array.deltaArray(
     element: Types.InternalCodec<any>,
     maxCount: number?
 ): Types.InternalCodec<any>
-    return Shared.makeUnchangedOrFullDelta(Array.array(element, maxCount), allocDeltaId(), Baseline)
+    -- Inner delta would chain-diff across elements within a frame, not across frames.
+    if containsDelta(element) then
+        Log.error("deltaArray element cannot contain delta state")
+    end
+
+    local deltaId = allocDeltaId()
+    local inner = Array.array(element, maxCount)
+
+    --[[
+        Encode each element into `scratch` and capture per-index byte ranges.
+        Returns the array length plus parallel arrays of offset/length so the
+        diff path can compare and emit individual entries without re-encoding.
+    ]]
+    local function encodePerIdx(
+        scratch: Types.ChannelState,
+        value: { any }
+    ): (number, { number }, { number })
+        local len = #value
+        enforceMaxCount(len, maxCount)
+        local off = table.create(len)
+        local elen = table.create(len)
+        for i = 1, len do
+            local before = scratch.cursor
+            element.write(scratch, value[i])
+            off[i] = before
+            elen[i] = scratch.cursor - before
+        end
+        return len, off, elen
+    end
+
+    return table.freeze({
+        _isDelta = true,
+        _isArray = true,
+        _element = element,
+        _maxCount = maxCount,
+
+        write = function(ch: Types.ChannelState, value: { any }): ()
+            if typeof(value) ~= "table" then
+                Log.error(`expected table, got {typeof(value)}`)
+            end
+
+            local cache = ch.deltas[deltaId] :: any
+            local scratch = acquireScratch()
+            local len, off, elen = encodePerIdx(scratch, value)
+            local scratchBuf = scratch.buff
+
+            -- First frame: emit FULL using the per-index scratch bytes.
+            if not cache then
+                ensure(ch, 1)
+                writeu8(ch.buff, ch.cursor, DA_FULL)
+                ch.cursor += 1
+                varintWrite(ch, len)
+                local payloadLen = scratch.cursor
+                ensure(ch, payloadLen)
+                bufCopy(ch.buff, ch.cursor, scratchBuf, 0, payloadLen)
+                ch.cursor += payloadLen
+
+                local perIdx: { [number]: DeltaArrayEntry } = {}
+                for i = 1, len do
+                    local n = elen[i]
+                    perIdx[i] = { eBuf = copyToBuf(nil, scratchBuf, off[i], n), eLen = n }
+                end
+                ch.deltas[deltaId] = { perIdx = perIdx, length = len } :: any
+                releaseScratch()
+                return
+            end
+
+            local cachedPerIdx = cache.perIdx :: { [number]: DeltaArrayEntry }
+            local cachedLen = cache.length :: number
+
+            -- Find changed indices in the overlap; appended indices count as changed.
+            local changed: { number } = {}
+            local changedCount = 0
+            local overlap = if len < cachedLen then len else cachedLen
+            for i = 1, overlap do
+                local entry = cachedPerIdx[i]
+                local n = elen[i]
+                if
+                    not entry
+                    or n ~= entry.eLen
+                    or not rangeEqual(scratchBuf, off[i], entry.eBuf, 0, n)
+                then
+                    changedCount += 1
+                    changed[changedCount] = i
+                end
+            end
+            for i = overlap + 1, len do
+                changedCount += 1
+                changed[changedCount] = i
+            end
+
+            if changedCount == 0 and len == cachedLen then
+                ensure(ch, 1)
+                writeu8(ch.buff, ch.cursor, DA_UNCHANGED)
+                ch.cursor += 1
+                releaseScratch()
+                return
+            end
+
+            -- Pick FULL vs PATCH on actual byte cost. Both share `1 + varintLength(len)`
+            -- so it cancels: compare PATCH's index-header overhead + changed payload
+            -- against FULL's full payload.
+            local fullPayload = scratch.cursor
+            local patchPayload = varintLength(changedCount)
+            for i = 1, changedCount do
+                local idx = changed[i]
+                patchPayload += varintLength(idx) + elen[idx]
+            end
+
+            if patchPayload < fullPayload then
+                ensure(ch, 1)
+                writeu8(ch.buff, ch.cursor, DA_PATCH)
+                ch.cursor += 1
+                varintWrite(ch, len)
+                varintWrite(ch, changedCount)
+                for i = 1, changedCount do
+                    local idx = changed[i]
+                    varintWrite(ch, idx)
+                    local n = elen[idx]
+                    ensure(ch, n)
+                    bufCopy(ch.buff, ch.cursor, scratchBuf, off[idx], n)
+                    ch.cursor += n
+                end
+            else
+                ensure(ch, 1)
+                writeu8(ch.buff, ch.cursor, DA_FULL)
+                ch.cursor += 1
+                varintWrite(ch, len)
+                ensure(ch, fullPayload)
+                bufCopy(ch.buff, ch.cursor, scratchBuf, 0, fullPayload)
+                ch.cursor += fullPayload
+            end
+
+            -- Update cache: refresh changed (and appended), drop truncated.
+            for i = 1, changedCount do
+                local idx = changed[i]
+                local n = elen[idx]
+                local entry = cachedPerIdx[idx]
+                if entry then
+                    entry.eBuf = copyToBuf(entry.eBuf, scratchBuf, off[idx], n)
+                    entry.eLen = n
+                else
+                    cachedPerIdx[idx] = { eBuf = copyToBuf(nil, scratchBuf, off[idx], n), eLen = n }
+                end
+            end
+            for i = len + 1, cachedLen do
+                cachedPerIdx[i] = nil
+            end
+            cache.length = len
+
+            releaseScratch()
+        end,
+
+        read = function(src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
+            if pos >= bufLen(src) then
+                Log.error("truncated deltaArray header")
+            end
+            local flag = readu8(src, pos)
+
+            if flag == DA_UNCHANGED then
+                local cached = Baseline.getCache(deltaId)
+                if cached == nil then
+                    Log.error("UNCHANGED flag before any FULL frame; baseline missing")
+                end
+                return cached, 1
+            end
+
+            if flag == DA_FULL then
+                local value, consumed = inner.read(src, pos + 1, refs)
+                Baseline.setCache(deltaId, value)
+                return value, 1 + consumed
+            end
+
+            if flag == DA_PATCH then
+                local cached = Baseline.getCache(deltaId)
+                if cached == nil then
+                    Log.error("deltaArray PATCH before any FULL frame; baseline missing")
+                end
+                --[[
+                    Capture the cached length BEFORE clone+mutate; #result
+                    becomes unreliable once we set entries at appended indices
+                    past the original boundary.
+                ]]
+                local cachedLen = #cached
+                local result: { any } = table.clone(cached)
+                local total = 1
+
+                local newLen, lLen = varintRead(src, pos + total)
+                if lLen == 0 then
+                    Log.error("truncated deltaArray length")
+                end
+                enforceMaxCount(newLen, maxCount, "newLen")
+                total += lLen
+
+                local changeCount, cLen = varintRead(src, pos + total)
+                if cLen == 0 then
+                    Log.error("truncated deltaArray change count")
+                end
+                -- changeCount is also bounded by newLen: every index appears at most once.
+                if changeCount > newLen then
+                    Log.error(`deltaArray changeCount {changeCount} exceeds newLen {newLen}`)
+                end
+                total += cLen
+
+                for _ = 1, changeCount do
+                    local idx, iLen = varintRead(src, pos + total)
+                    if iLen == 0 then
+                        Log.error("truncated deltaArray index")
+                    end
+                    -- Reject out-of-range idx so the wire can't poison the cache with
+                    -- arbitrary keys that survive truncation.
+                    if idx < 1 or idx > newLen then
+                        Log.error(`deltaArray index {idx} out of range [1, {newLen}]`)
+                    end
+                    total += iLen
+                    local v, vc = element.read(src, pos + total, refs)
+                    if vc == 0 then
+                        Log.error("truncated deltaArray element")
+                    end
+                    total += vc
+                    result[idx] = v
+                end
+
+                for i = newLen + 1, cachedLen do
+                    result[i] = nil
+                end
+
+                Baseline.setCache(deltaId, result)
+                return result, total
+            end
+
+            Log.error(`invalid deltaArray flag {flag}`)
+        end,
+    }) :: Types.InternalCodec<any>
 end
 
 return table.freeze(Array)