@axpecter/lync 1.5.2 → 2.0.0

package/README.md

@@ -13,7 +13,7 @@
 
 ```toml
 [dependencies]
-Lync = "axp3cter/lync@1.5.2"
+Lync = "axp3cter/lync@2.0.0"
 ```
 
 **npm (roblox-ts)**
@@ -163,7 +163,7 @@ end
 | | What it does |
 |:---------|:------------|
 | `Lync.start()` | Sets up transport. Server creates remotes, client connects. Call once after all definitions. |
-| `Lync.VERSION` | `"1.5.2"` |
+| `Lync.VERSION` | `"2.0.0"` |
 
 ## Packets
 
@@ -176,6 +176,7 @@ end
 | `rateLimit` | `{ maxPerSecond, burstAllowance? }` | No | Server-side token bucket. Burst defaults to maxPerSecond if you dont set it. |
 | `validate` | `(data, player) → (bool, string?)` | No | Server-side. Return `false, "reason"` to drop. Runs after NaN scan. |
 | `maxPayloadBytes` | number | No | Server-side. Max bytes a single batch of this packet can consume. Fires `onDrop` with reason `"size"` if exceeded. |
+| `timestamp` | `"frame" \| "offset" \| "full"` | No | Prepends a timestamp to each item. `"frame"` = u8 wrapping counter (1B), `"offset"` = u16 ms (2B), `"full"` = f64 clock (8B). Listeners receive it as a third argument. |
 
 **Server, single `send` with targets:**
 
@@ -198,8 +199,8 @@ packet:send(data)  -- send to server
 
 | Method | What it does |
 |:-------|:------------|
-| `packet:listen(fn(data, sender))` | Sender is `Player` on server, `nil` on client. Returns a Connection. |
-| `packet:once(fn(data, sender))` | Auto-disconnects after one fire. |
+| `packet:listen(fn(data, sender, timestamp?))` | Sender is `Player` on server, `nil` on client. `timestamp` is present when the packet has a `timestamp` config. Returns a Connection. |
+| `packet:once(fn(data, sender, timestamp?))` | Auto-disconnects after one fire. |
 | `packet:wait()` | Returns `(data, sender)`. |
 | `packet:disconnectAll()` | Kills all listeners on this packet. |
 
@@ -271,7 +272,7 @@ Access packets and queries by their short name on the returned object: `ns.Packe
 
 | Method | What it does |
 |:-------|:------------|
-| `ns:listenAll(fn(name, data, sender))` | Listens to every packet in the namespace. `name` is the short name without prefix. Returns a Connection. |
+| `ns:listenAll(fn(name, data, sender, timestamp?))` | Listens to every packet in the namespace. `name` is the short name without prefix. Returns a Connection. |
 | `ns:onSend(fn(data, name, player) → data?)` | Send middleware that only runs for this namespace. Returns a remover. |
 | `ns:onReceive(fn(data, name, player) → data?)` | Receive middleware that only runs for this namespace. Returns a remover. |
 | `ns:disconnectAll()` | Kills all listeners made through `listenAll`. |
@@ -386,7 +387,7 @@ Used as the second argument to `packet:send()` on the server.
 | `Lync.f16` | 2 | ±65,504, roughly 3 digits of precision |
 | `Lync.f32` | 4 | IEEE 754 single |
 | `Lync.f64` | 8 | IEEE 754 double |
-| `Lync.bool` | 1 | true/false. Gets packed into bitfields when inside structs. |
+| `Lync.bool` | 1 | true/false. Gets packed into bitfields when inside structs, and 8-per-byte when inside arrays. |
 
 ### Datatypes
 
@@ -417,7 +418,7 @@ Used as the second argument to `packet:send()` on the server.
 | Constructor | What it does |
 |:------------|:------------|
 | `Lync.struct({ key = codec })` | Named fields. Bools get packed into bitfields automatically. |
-| `Lync.array(codec, maxCount?)` | Variable length list with varint count. Optional `maxCount` rejects on read if exceeded. |
+| `Lync.array(codec, maxCount?)` | Variable length list with varint count. Optional `maxCount` rejects on read if exceeded. Bool arrays are bitpacked (8 per byte). |
 | `Lync.map(keyCodec, valueCodec, maxCount?)` | Key-value pairs with varint count. Optional `maxCount` rejects on read if exceeded. |
 | `Lync.optional(codec)` | 1 byte flag, value only if present. |
 | `Lync.tuple(codec, codec, ...)` | Ordered positional values, no keys. |
@@ -502,17 +503,109 @@ Same data shapes and methodology as [Blink's benchmark suite](https://github.com
 > [!NOTE]
 > Lync benchmarks run on Ryzen 7 7800X3D, 32GB DDR5-4800. Other tool numbers are from [Blink's published benchmarks](https://github.com/1Axen/blink/blob/main/benchmark/Benchmarks.md) (v0.17.1, Ryzen 9 7900X, 34GB DDR5-4800). Different CPUs so FPS numbers arent directly comparable but bandwidth numbers are since Kbps is scaled by 60/FPS. Lync hits the 60 FPS frame cap in both tests.
 
+## Stats
+
+Off by default. Call `Lync.enableStats()` before `Lync.start()` to activate. When disabled, zero overhead on send and receive paths.
+
+Per-packet counters are available directly on the Packet object. Per-player counters are available via `Lync.getPlayerStats()`.
+
+```luau
+Lync.enableStats()
+Lync.start()
+
+-- Per-packet (both sides)
+print(Net.State:getBytesSent(), Net.State:getFires(), Net.State:getDrops())
+
+-- Per-player (server only)
+local stats = Lync.getPlayerStats(player)
+if stats then
+    print(stats.bytesSent, stats.bytesReceived)
+end
+
+Lync.resetStats()  -- zeros everything in-place
+```
+
+| Function / Method | What it does |
+|:-------|:----------------|
+| `Lync.enableStats()` | Activates stat counters. Call before `start()`. |
+| `packet:getBytesSent()` | Wire bytes produced (includes batch header overhead). |
+| `packet:getBytesReceived()` | Wire bytes consumed on receive. |
+| `packet:getFires()` | Send fire count. |
+| `packet:getRecvFires()` | Receive fire count. |
+| `packet:getDrops()` | Gate rejections (rate limit, NaN, validate). |
+| `Lync.getPlayerStats(player)` | Returns `{ bytesSent, bytesReceived }` or nil. Server only. |
+| `Lync.resetStats()` | Zeros all counters in-place. |
+
+## Flush Control
+
+By default Lync flushes at 60hz (every Heartbeat). You can change this at runtime.
+
+```luau
+Lync.setFlushRate(30)  -- flush every ~33ms instead of ~16ms
+Lync.flush()           -- force an immediate flush, resets the accumulator
+```
+
+| Function | What it does |
+|:---------|:------------|
+| `Lync.setFlushRate(hz)` | 1 to 60. Default 60. Callable at runtime. At 60hz, flushes every Heartbeat directly (no accumulator). Below 60, uses an elapsed-time accumulator with drift correction. |
+| `Lync.flush()` | Immediate flush. Skips the next scheduled Heartbeat flush to prevent double-sending and XOR chain desync. |
+
+## Security
+
+### Bandwidth Throttle
+
+Server-side per-player bandwidth strike counter. Counts consecutive oversized frames with decay. Protects against clients flooding the server.
+
+```luau
+Lync.setBandwidthLimit(16384, 10)  -- 16KB soft limit, 10 strikes before drop
+```
+
+Fires `onDrop` with reason `"bandwidth"` when a player exceeds the threshold. Read failures (corrupted buffers, XOR desync) also count as strikes.
+
+### Unknown Codec Warning
+
+If a packet uses `Lync.unknown` anywhere in its codec tree without a `validate` callback, Lync prints a warning at define time. The `unknown` codec bypasses schema validation entirely; client data goes through Roblox's sidecar without type checking. Adding `validate` suppresses the warning.
+
+## Packet Capture
+
+Server-only debug tool. Records raw and XOR'd buffer hex for analysis.
+
+```luau
+Lync.startCapture("My test")
+-- fire packets...
+Lync.flush()
+Lync.stopCapture()
+
+Lync.startCapture("Another test")
+-- fire packets...
+Lync.flush()
+Lync.stopCapture()
+
+Lync.dumpCaptures()  -- writes JSON to ServerStorage.LyncCapture
+```
+
+Each entry contains the label, frame number, raw hex (pre-XOR), XOR'd hex (post-XOR, nil for unreliable), byte count, and refs count. Hex is capped at 512 bytes per buffer to keep the output manageable.
+
+| Function | What it does |
+|:---------|:------------|
+| `Lync.startCapture(label?)` | Start recording. Tags entries with the label. |
+| `Lync.stopCapture()` | Stop recording. |
+| `Lync.dumpCaptures()` | Writes all entries as JSON to a StringValue in ServerStorage, then clears. |
+
 ## Limits & Configuration
 
-Call these before `Lync.start()`.
+Call these before `Lync.start()` unless noted otherwise.
 
 | What | Default | How to change | Notes |
 |:-----|--------:|:--------------|:------|
 | Packet types | 255 | Cant change | u8 on the wire. Each query eats 2 IDs. |
 | Buffer per channel per frame | 256 KB | `Lync.setChannelMaxSize(n)` | 4 KB to 1 MB. |
-| Concurrent queries | 65,536 | Cant change | u16 correlation IDs. Freed on response or timeout. `Lync.queryPendingCount()` returns in-flight count. |
+| Concurrent queries | 65,536 | Cant change | Varint correlation IDs. Freed on response or timeout. `Lync.queryPendingCount()` returns in-flight count. Queries default to 30/s rate limit. |
+| Stats | Off | `Lync.enableStats()` | Zero overhead when off. Counters on packets and players. |
 | NaN/inf scan depth | 16 | `Lync.setValidationDepth(n)` | 4 to 32. |
 | Channel pool | 16 | `Lync.setPoolSize(n)` | 2 to 128. Extra gets GCd. |
+| Flush rate | 60 hz | `Lync.setFlushRate(n)` | 1 to 60. Runtime-safe. |
+| Bandwidth limit | 16 KB / 10 strikes | `Lync.setBandwidthLimit(n, m)` | Server-only. Per-player. |
 | Namespaces | 64 | Cant change | |
 | Delta + unreliable | Nope | Cant change | Errors at define time. |
 

package/package.json

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

package/src/Types.luau

@@ -41,6 +41,7 @@ export type PacketConfig<T> = {
     rateLimit: RateLimitConfig?,
     validate: ((data: T, player: Player) -> (boolean, string?))?,
     maxPayloadBytes: number?,
+    timestamp: ("frame" | "offset" | "full")?,
 }
 
 export type QueryConfig<Req, Resp> = {
@@ -76,6 +77,15 @@ export type Registration = {
     validate: ((data: any, player: Player) -> (boolean, string?))?,
     needsGate: boolean,
     maxPayloadBytes: number?,
+    timestampMode: number,
+    _openFn: (ch: ChannelState, id: number, name: string) -> (), -- resolved at define time (#2)
+
+    -- Stats counters (mutable, incremented at runtime)
+    bytesSent: number,
+    bytesReceived: number,
+    fires: number,
+    recvFires: number,
+    drops: number,
 }
 
 export type Connection = {

package/src/api/Namespace.luau

@@ -62,7 +62,12 @@ export type Namespace = typeof(setmetatable({} :: NamespaceFields, NamespaceImpl
 -- Listens on every packet in this namespace. Returns a Connection.
 function NamespaceImpl.listenAll(
     self: Namespace,
-    callback: (name: string, data: any, sender: Player?) -> ()
+    callback: (
+        name: string,
+        data: any,
+        sender: Player?,
+        timestamp: number?
+    ) -> ()
 ): Connection
     local connections = {} :: { Connection }
     local prefix = self._name .. "."
@@ -70,8 +75,8 @@ function NamespaceImpl.listenAll(
 
     for fullName, packet in self._packets do
         local shortName = string.sub(fullName, prefixLen + 1)
-        local conn = packet:listen(function(data: any, sender: Player?): ()
-            callback(shortName, data, sender)
+        local conn = packet:listen(function(data: any, sender: Player?, timestamp: number?): ()
+            callback(shortName, data, sender, timestamp)
         end)
         table.insert(connections, conn)
         table.insert(self._tracked, conn)

package/src/api/Packet.luau

@@ -4,6 +4,7 @@
 
 local RunService = game:GetService("RunService")
 
+local Channel = require(script.Parent.Parent.internal.Channel)
 local Client = require(script.Parent.Parent.transport.Client)
 local Registry = require(script.Parent.Parent.internal.Registry)
 local Server = require(script.Parent.Parent.transport.Server)
@@ -14,34 +15,44 @@ type Connection = Types.Connection
 type Codec<T> = Types.Codec<T>
 type InternalCodec<T> = Types.InternalCodec<T>
 type PacketConfig<T> = Types.PacketConfig<T>
+type Registration = Types.Registration
 
 -- Constants -----------------------------------------------------------
 
 local IS_SERVER = RunService:IsServer()
 
-local serverWriteTo = Server.writeTo
-local serverWriteToAll = Server.writeToAll
-local serverWriteToList = Server.writeToList
-local serverWriteToAllExcept = Server.writeToAllExcept
-local serverWriteToSet = Server.writeToSet
-local clientWrite = Client.write
-
 local DELTA_TARGETED = 1
 local DELTA_BROADCAST = 2
 
+local TS_LOOKUP = {
+    frame = Channel.TS_FRAME,
+    offset = Channel.TS_OFFSET,
+    full = Channel.TS_FULL,
+}
+
 -- Private -------------------------------------------------------------
 
 type PacketFields = {
-    _id: number,
-    _name: string,
-    _codec: Codec<any>,
+    _reg: Registration,
     _isUnreliable: boolean,
     _isDelta: boolean,
     _deltaMode: number,
     _signal: Signal.Signal,
 }
 
--- Server-only metatable. Single send() dispatches on target type.
+local function checkDeltaMode(self: any, mode: number): ()
+    if not self._isDelta then
+        return
+    end
+    local current = self._deltaMode
+    if current == 0 then
+        self._deltaMode = mode
+    elseif current ~= mode then
+        error(`[Lync] Delta packet cannot mix targeted and broadcast: "{self._reg.name}"`)
+    end
+end
+
+-- Server-only metatable
 local ServerImpl = {}
 ServerImpl.__index = ServerImpl
 
@@ -63,67 +74,68 @@ function ServerImpl.disconnectAll(self: Packet): ()
     self._signal:disconnectAll()
 end
 
-local function checkDeltaMode(self: Packet, mode: number): ()
-    if not self._isDelta then
-        return
-    end
-    local current = self._deltaMode
-    if current == 0 then
-        self._deltaMode = mode
-    elseif current ~= mode then
-        error(`[Lync] Delta packet cannot mix targeted and broadcast: "{self._name}"`)
-    end
-end
-
 function ServerImpl.send(self: Packet, data: any, target: any?): ()
     if target == nil then
         error("[Lync] Server packet:send requires a target")
     end
 
-    local id = self._id
-    local name = self._name
-    local codec = self._codec
+    local reg = self._reg
     local isUnreliable = self._isUnreliable
 
-    -- Single player
     if typeof(target) == "Instance" then
         checkDeltaMode(self, DELTA_TARGETED)
-        serverWriteTo(target :: Player, id, name, codec, data, isUnreliable)
+        Server.writeTo(target :: Player, reg, data, isUnreliable)
         return
     end
 
-    -- Must be a table from here
     local tag = target._tag
 
-    -- Lync.all sentinel
     if tag == "all" then
         checkDeltaMode(self, DELTA_BROADCAST)
-        serverWriteToAll(id, name, codec, data, isUnreliable)
+        Server.writeToAll(reg, data, isUnreliable)
         return
     end
 
-    -- Lync.except(player, ...) descriptor
     if tag == "except" then
         checkDeltaMode(self, DELTA_BROADCAST)
-        serverWriteToAllExcept(target._set, id, name, codec, data, isUnreliable)
+        Server.writeToAllExcept(target._set, reg, data, isUnreliable)
         return
     end
 
-    -- Group object
     if tag == "group" then
         checkDeltaMode(self, DELTA_BROADCAST)
-        serverWriteToSet(target:getSet(), id, name, codec, data, isUnreliable)
+        Server.writeToSet(target:getSet(), reg, data, isUnreliable)
         return
     end
 
-    -- Player list(array)
     checkDeltaMode(self, DELTA_TARGETED)
-    serverWriteToList(target :: { Player }, id, name, codec, data, isUnreliable)
+    Server.writeToList(target :: { Player }, reg, data, isUnreliable)
+end
+
+-- Stats: read directly from registration
+function ServerImpl.getBytesSent(self: Packet): number
+    return self._reg.bytesSent
+end
+
+function ServerImpl.getBytesReceived(self: Packet): number
+    return self._reg.bytesReceived
+end
+
+function ServerImpl.getFires(self: Packet): number
+    return self._reg.fires
+end
+
+function ServerImpl.getRecvFires(self: Packet): number
+    return self._reg.recvFires
+end
+
+function ServerImpl.getDrops(self: Packet): number
+    return self._reg.drops
 end
 
 table.freeze(ServerImpl)
 
--- Client-only metatable. Has send(), no target needed.
+-- Client-only metatable
 local ClientImpl = {}
 ClientImpl.__index = ClientImpl
 
@@ -144,9 +156,15 @@ function ClientImpl.disconnectAll(self: Packet): ()
 end
 
 function ClientImpl.send(self: Packet, data: any): ()
-    clientWrite(self._id, self._name, self._codec, data, self._isUnreliable)
+    Client.write(self._reg, data, self._isUnreliable)
 end
 
+ClientImpl.getBytesSent = ServerImpl.getBytesSent
+ClientImpl.getBytesReceived = ServerImpl.getBytesReceived
+ClientImpl.getFires = ServerImpl.getFires
+ClientImpl.getRecvFires = ServerImpl.getRecvFires
+ClientImpl.getDrops = ServerImpl.getDrops
+
 table.freeze(ClientImpl)
 
 -- Public --------------------------------------------------------------
@@ -167,6 +185,22 @@ function PacketModule.define(name: string, config: PacketConfig<any>): Packet
         error(`[Lync] Delta codec requires reliable delivery: "{name}"`)
     end
 
+    local timestampMode = if config.timestamp then TS_LOOKUP[config.timestamp] else nil
+    if config.timestamp and not timestampMode then
+        error(`[Lync] Invalid timestamp mode: "{config.timestamp}" on packet "{name}"`)
+    end
+
+    if timestampMode then
+        Channel.enableTimestamps()
+    end
+
+    local hasUnknown = (config.value :: any)._hasUnknown
+    if hasUnknown and not config.validate then
+        warn(
+            `[Lync] Packet "{name}" uses Lync.unknown: client data bypasses schema validation. Add a validate callback.`
+        )
+    end
+
     local signal = Signal.create()
 
     local reg = Registry.register(
@@ -176,15 +210,14 @@ function PacketModule.define(name: string, config: PacketConfig<any>): Packet
         signal,
         config.rateLimit,
         config.validate,
-        config.maxPayloadBytes
+        config.maxPayloadBytes,
+        timestampMode
     )
 
     local isDelta = (config.value :: InternalCodec<any>)._isDelta == true
 
     local fields: PacketFields = {
-        _id = reg.id,
-        _name = reg.name,
-        _codec = reg.codec,
+        _reg = reg,
         _isUnreliable = isUnreliable,
         _isDelta = isDelta,
         _deltaMode = 0,

package/src/api/Query.luau

@@ -316,13 +316,15 @@ function QueryModule.define(name: string, config: QueryConfig<any, any>): Query
     local reqSignal = Signal.create()
     local respSignal = Signal.create()
 
+    local rateLimit = config.rateLimit or { maxPerSecond = 30 }
+
     local reqReg, respReg = Registry.registerQueryPair(
         name,
         config.request,
         config.response,
         reqSignal,
         respSignal,
-        config.rateLimit,
+        rateLimit,
         config.validate
     )
 

package/src/codec/composite/Array.luau

@@ -38,6 +38,7 @@ function Array.deltaArray(element: Codec<any>, maxCount: number?): Codec<{ any }
 
     return table.freeze({
         _isDelta = true,
+        _hasUnknown = (element :: any)._hasUnknown or nil,
 
         write = function(ch: ChannelState, value: { any }): ()
             local len = #value
@@ -110,12 +111,14 @@ function Array.deltaArray(element: Codec<any>, maxCount: number?): Codec<{ any }
                 ch.cursor += 1
                 Varint.write(ch, dirtyN)
 
+                local prevIdx = 0
                 for j = 1, dirtyN do
                     local i = dirty[j]
                     local newOff = bounds[i]
                     local newLen = bounds[i + 1] - newOff
 
-                    Varint.write(ch, i - 1)
+                    Varint.write(ch, (i - 1) - prevIdx)
+                    prevIdx = i - 1
                     alloc(ch, newLen)
                     buffer.copy(ch.buff, ch.cursor, scratch.buff, newOff, newLen)
                     ch.cursor += newLen
@@ -167,21 +170,26 @@ function Array.deltaArray(element: Codec<any>, maxCount: number?): Codec<{ any }
             end
 
             local cache = Baseline.getCache(deltaId) :: { any }?
-            local result = if cache then table.clone(cache) else {}
+            if not cache then
+                error("[Lync] Delta frame without baseline")
+            end
+            local result = table.clone(cache)
 
             local dirtyN, dnBytes = Varint.read(src, absPos)
             absPos += dnBytes
 
+            local runningIdx = 0
             for _ = 1, dirtyN do
-                local idx, idxBytes = Varint.read(src, absPos)
-                absPos += idxBytes
+                local delta, deltaBytes = Varint.read(src, absPos)
+                absPos += deltaBytes
+                runningIdx += delta
 
                 if elemRead and elemSize then
-                    result[idx + 1] = elemRead(src, absPos)
+                    result[runningIdx + 1] = elemRead(src, absPos)
                     absPos += elemSize
                 else
                     local val, n = readElement(src, absPos, refs)
-                    result[idx + 1] = val
+                    result[runningIdx + 1] = val
                     absPos += n
                 end
             end
@@ -198,8 +206,78 @@ function Array.array(element: Codec<any>, maxCount: number?): Codec<{ any }>
     local directWrite = internal._directWrite
     local directRead = internal._directRead
 
+    local band = bit32.band
+    local bor = bit32.bor
+    local lshift = bit32.lshift
+    local rshift = bit32.rshift
+    local ceil = math.ceil
+
+    -- Bitpacked bool array: 8 bools per byte
+    if internal._isBool then
+        return table.freeze({
+            _hasUnknown = nil,
+            write = function(ch: ChannelState, value: { any }): ()
+                local len = #value
+                Varint.write(ch, len)
+                if len == 0 then
+                    return
+                end
+
+                local byteCount = ceil(len / 8)
+                local c = ch.cursor
+                if c + byteCount > ch.size then
+                    alloc(ch, byteCount)
+                end
+
+                local b = ch.buff
+                local byteIdx = 0
+                local acc = 0
+                for i = 1, len do
+                    local bit = (i - 1) % 8
+                    if value[i] then
+                        acc = bor(acc, lshift(1, bit))
+                    end
+                    if bit == 7 then
+                        buffer.writeu8(b, c + byteIdx, acc)
+                        byteIdx += 1
+                        acc = 0
+                    end
+                end
+                -- Flush remaining bits
+                if len % 8 ~= 0 then
+                    buffer.writeu8(b, c + byteIdx, acc)
+                end
+                ch.cursor = c + byteCount
+            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 count {len} exceeds max {maxCount}`)
+                end
+
+                local result = table.create(len)
+                if len == 0 then
+                    return result, lenBytes
+                end
+
+                local byteCount = ceil(len / 8)
+                local c = pos + lenBytes
+                for i = 1, len do
+                    local byteIdx = rshift(i - 1, 3)
+                    local bit = (i - 1) % 8
+                    local byte = buffer.readu8(src, c + byteIdx)
+                    result[i] = band(byte, lshift(1, bit)) ~= 0
+                end
+
+                return result, lenBytes + byteCount
+            end,
+        })
+    end
+
     if elementSize and directWrite and directRead then
         return table.freeze({
+            _hasUnknown = (element :: any)._hasUnknown or nil,
             write = function(ch: ChannelState, value: { any }): ()
                 local len = #value
                 Varint.write(ch, len)
@@ -244,6 +322,7 @@ function Array.array(element: Codec<any>, maxCount: number?): Codec<{ any }>
     local readElement = element.read
 
     return table.freeze({
+        _hasUnknown = (element :: any)._hasUnknown or nil,
         write = function(ch: ChannelState, value: { any }): ()
             local len = #value
             Varint.write(ch, len)

package/src/codec/composite/Map.luau

@@ -44,6 +44,7 @@ function Map.map(
         local entrySize = keySize + valSize
 
         return table.freeze({
+            _hasUnknown = (keyCodec :: any)._hasUnknown or (valueCodec :: any)._hasUnknown or nil,
             write = function(ch: ChannelState, value: { [any]: any }): ()
                 local count = 0
                 for _ in value do
@@ -100,6 +101,7 @@ function Map.map(
     local readVal = valueCodec.read
 
     return table.freeze({
+        _hasUnknown = (keyCodec :: any)._hasUnknown or (valueCodec :: any)._hasUnknown or nil,
         write = function(ch: ChannelState, value: { [any]: any }): ()
             local count = 0
             for _ in value do
@@ -185,6 +187,7 @@ function Map.deltaMap(
 
     return table.freeze({
         _isDelta = true,
+        _hasUnknown = (keyCodec :: any)._hasUnknown or (valueCodec :: any)._hasUnknown or nil,
 
         write = function(ch: ChannelState, value: { [any]: any }): ()
             local scratch = acquireScratch()
@@ -378,7 +381,10 @@ function Map.deltaMap(
             end
 
             local cache = Baseline.getCache(deltaId) :: { [any]: any }?
-            local result = if cache then table.clone(cache) else {}
+            if not cache then
+                error("[Lync] Delta frame without baseline")
+            end
+            local result = table.clone(cache)
 
             local upsertN, unBytes = Varint.read(src, absPos)
             absPos += unBytes

package/src/codec/composite/Optional.luau

@@ -19,6 +19,7 @@ function Optional.optional(inner: Codec<any>): Codec<any>
     local innerRead = inner.read
 
     return table.freeze({
+        _hasUnknown = (inner :: any)._hasUnknown or nil,
         write = function(ch: ChannelState, value: any): ()
             local c = ch.cursor
             if c + 1 > ch.size then