@axpecter/lync 2.3.1 → 2.3.2

package/src/codec/composite/Tagged.luau

@@ -4,6 +4,7 @@
 
 local Channel = require(script.Parent.Parent.Parent.internal.Channel)
 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)
 
 -- Private ----------------------------------------------------------------
@@ -37,6 +38,7 @@ function Tagged.define(
     local nameToTag: { [string]: number } = {}
     local tagToCodec = table.create(variantCount)
     local hasUnknown = false
+    local hasDelta = false
 
     for i = 1, variantCount do
         local name = names[i]
@@ -46,6 +48,9 @@ function Tagged.define(
         if codec._hasUnknown then
             hasUnknown = true
         end
+        if Shared.containsDelta(codec) then
+            hasDelta = true
+        end
     end
 
     table.freeze(names)
@@ -89,6 +94,9 @@ function Tagged.define(
     if hasUnknown then
         codec._hasUnknown = true
     end
+    if hasDelta then
+        codec._hasDelta = true
+    end
     return table.freeze(codec)
 end
 

package/src/codec/composite/Tuple.luau

@@ -4,6 +4,7 @@
 
 local Base = require(script.Parent.Parent.Base)
 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)
 
 -- Private ----------------------------------------------------------------
@@ -19,13 +20,17 @@ function Tuple.define(...: Types.InternalCodec<any>): Types.InternalCodec<any>
     local count = #codecs
     Log.assert(count > 0, "requires at least one codec")
 
-    -- Single pass: detect all-direct fast path + propagate _hasUnknown.
+    -- Single pass: detect all-direct fast path + propagate _hasUnknown / _hasDelta.
     local allDirect, totalSize, hasUnknown = true, 0, false
+    local hasDelta = false
     for i = 1, count do
         local c = codecs[i]
         if c._hasUnknown then
             hasUnknown = true
         end
+        if Shared.containsDelta(c) then
+            hasDelta = true
+        end
         if allDirect then
             if c._size and c._directWrite and c._directRead then
                 totalSize += c._size
@@ -96,6 +101,9 @@ function Tuple.define(...: Types.InternalCodec<any>): Types.InternalCodec<any>
         if hasUnknown then
             codec._hasUnknown = true
         end
+        if hasDelta then
+            codec._hasDelta = true
+        end
         return table.freeze(codec)
     end
 
@@ -126,6 +134,9 @@ function Tuple.define(...: Types.InternalCodec<any>): Types.InternalCodec<any>
     if hasUnknown then
         codec._hasUnknown = true
     end
+    if hasDelta then
+        codec._hasDelta = true
+    end
     return table.freeze(codec)
 end
 

package/src/codec/datatype/Buffer.luau

@@ -23,9 +23,7 @@ local function writeBuffer(ch: Types.ChannelState, value: buffer): ()
         end
         local b = ch.buff
         buffer.writeu8(b, cursor, len)
-        if len > 0 then
-            buffer.copy(b, cursor + 1, value, 0, len)
-        end
+        buffer.copy(b, cursor + 1, value, 0, len)
         ch.cursor = cursor + 1 + len
         return
     end

package/src/codec/datatype/CFrame.luau

@@ -3,6 +3,7 @@
 -- CFrame codec. Default lossless (24B); __call yields smallest-three quat (16B).
 
 local Base = require(script.Parent.Parent.Base)
+local Quat = require(script.Parent.Parent.Parent.util.Quat)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Constants --------------------------------------------------------------
@@ -10,10 +11,6 @@ local Types = require(script.Parent.Parent.Parent.Types)
 local EPSILON = 2.4e-7
 local EPSILON_SQ = EPSILON * EPSILON
 
-local INV_SQRT2 = 1 / math.sqrt(2)
-local Q_SCALE = 1023 / (2 * INV_SQRT2)
-local Q_INV = (2 * INV_SQRT2) / 1023
-
 -- Private ----------------------------------------------------------------
 
 local alloc = Base.alloc
@@ -21,19 +18,10 @@ local writef32 = buffer.writef32
 local readf32 = buffer.readf32
 local writeu32 = buffer.writeu32
 local readu32 = buffer.readu32
-
 local sqrt = math.sqrt
-local cos = math.cos
-local sin = math.sin
-local abs = math.abs
-local round = math.round
-local acos = math.acos
-local clamp = math.clamp
-
-local band = bit32.band
-local bor = bit32.bor
-local lshift = bit32.lshift
-local rshift = bit32.rshift
+local quatPack = Quat.pack
+local quatUnpack = Quat.unpack
+local quatFromCFrame = Quat.fromCFrame
 
 local function writeLossless(b: buffer, off: number, value: CFrame): ()
     local pos = value.Position
@@ -82,102 +70,14 @@ local function writeCompressed(b: buffer, off: number, value: CFrame): ()
     writef32(b, off, pos.X)
     writef32(b, off + 4, pos.Y)
     writef32(b, off + 8, pos.Z)
-
-    local axis, angle = value:ToAxisAngle()
-    local h = angle * 0.5
-    local s = sin(h)
-    local qx = axis.X * s
-    local qy = axis.Y * s
-    local qz = axis.Z * s
-    local qw = cos(h)
-
-    -- Smallest-three: drop the largest |component|; track index alongside maxVal.
-    local ax, ay, az, aw = abs(qx), abs(qy), abs(qz), abs(qw)
-    local largest, maxVal = 3, aw
-    if ax > maxVal then
-        largest, maxVal = 0, ax
-    end
-    if ay > maxVal then
-        largest, maxVal = 1, ay
-    end
-    if az > maxVal then
-        largest, maxVal = 2, az
-    end
-
-    --[[
-        Force the dropped component non-negative so the decoder's
-        +sqrt(1 - a^2 - b^2 - c^2) reconstructs the right sign. Dispatch on
-        `largest` instead of building a 4-element table per call.
-    ]]
-    local a: number, bComp: number, c: number
-    if largest == 0 then
-        if qx < 0 then
-            qy, qz, qw = -qy, -qz, -qw
-        end
-        a, bComp, c = qy, qz, qw
-    elseif largest == 1 then
-        if qy < 0 then
-            qx, qz, qw = -qx, -qz, -qw
-        end
-        a, bComp, c = qx, qz, qw
-    elseif largest == 2 then
-        if qz < 0 then
-            qx, qy, qw = -qx, -qy, -qw
-        end
-        a, bComp, c = qx, qy, qw
-    else
-        if qw < 0 then
-            qx, qy, qz = -qx, -qy, -qz
-        end
-        a, bComp, c = qx, qy, qz
-    end
-
-    local qa = clamp(round((a + INV_SQRT2) * Q_SCALE), 0, 1023)
-    local qb = clamp(round((bComp + INV_SQRT2) * Q_SCALE), 0, 1023)
-    local qc = clamp(round((c + INV_SQRT2) * Q_SCALE), 0, 1023)
-
-    writeu32(b, off + 12, bor(lshift(largest, 30), lshift(qa, 20), lshift(qb, 10), qc))
+    writeu32(b, off + 12, quatPack(quatFromCFrame(value)))
 end
 
 local function readCompressed(b: buffer, off: number): CFrame
     local px = readf32(b, off)
     local py = readf32(b, off + 4)
     local pz = readf32(b, off + 8)
-
-    local packed = readu32(b, off + 12)
-    local largest = rshift(packed, 30)
-    local qa = band(rshift(packed, 20), 0x3FF)
-    local qb = band(rshift(packed, 10), 0x3FF)
-    local qc = band(packed, 0x3FF)
-
-    local a = qa * Q_INV - INV_SQRT2
-    local bComp = qb * Q_INV - INV_SQRT2
-    local c = qc * Q_INV - INV_SQRT2
-
-    local sqSum = a * a + bComp * bComp + c * c
-    local d = sqrt(if sqSum < 1 then 1 - sqSum else 0)
-
-    -- Mirror encoder: dropped index gets `d`, others receive (a, bComp, c).
-    local qx: number, qy: number, qz: number, qw: number
-    if largest == 0 then
-        qx, qy, qz, qw = d, a, bComp, c
-    elseif largest == 1 then
-        qx, qy, qz, qw = a, d, bComp, c
-    elseif largest == 2 then
-        qx, qy, qz, qw = a, bComp, d, c
-    else
-        qx, qy, qz, qw = a, bComp, c, d
-    end
-
-    local origin = CFrame.new(px, py, pz)
-    local sqLen = qx * qx + qy * qy + qz * qz
-    if sqLen < EPSILON_SQ then
-        return origin
-    end
-
-    local angle = 2 * acos(clamp(qw, -1, 1))
-    local inv = 1 / sqrt(sqLen)
-    return origin * CFrame.fromAxisAngle(Vector3.new(qx * inv, qy * inv, qz * inv), angle)
+    return CFrame.new(px, py, pz) * quatUnpack(readu32(b, off + 12))
 end
 
 local function compressedFactory(_self): Types.InternalCodec<CFrame>

package/src/codec/meta/DeltaScalar.luau

@@ -0,0 +1,390 @@
+--!strict
+--!native
+-- Delta scalars: zigzag-varint diff against previous frame for ints, floats, vec3, CFrame.
+
+local Base = require(script.Parent.Parent.Base)
+local Baseline = require(script.Parent.Parent.Parent.internal.Baseline)
+local Log = require(script.Parent.Parent.Parent.util.Log)
+local Quantize = require(script.Parent.Parent.Parent.util.Quantize)
+local Quat = require(script.Parent.Parent.Parent.util.Quat)
+local Shared = require(script.Parent.Parent.composite.Shared)
+local Types = require(script.Parent.Parent.Parent.Types)
+local Varint = require(script.Parent.Parent.primitive.Varint)
+local Zint = require(script.Parent.Parent.primitive.Zint)
+
+-- Constants --------------------------------------------------------------
+
+local I32_MIN = -0x80000000
+local I32_MAX = 0x7FFFFFFF
+
+-- deltaCFrame header bits: which components changed since the last frame.
+local CF_X = 0x01
+local CF_Y = 0x02
+local CF_Z = 0x04
+local CF_ROT = 0x08
+local CF_ALL = 0x0F
+
+-- Private ----------------------------------------------------------------
+
+local ensure = Base.ensure
+local allocDeltaId = Shared.allocDeltaId
+local floor = math.floor
+local clamp = math.clamp
+local round = math.round
+local band = bit32.band
+local bor = bit32.bor
+local readu8 = buffer.readu8
+local writeu8 = buffer.writeu8
+local readu32 = buffer.readu32
+local writeu32 = buffer.writeu32
+local bufLen = buffer.len
+local varintWrite = Varint.write
+local varintRead = Varint.read
+local zigzagEncode = Zint.encode
+local zigzagDecode = Zint.decode
+local quatPack = Quat.pack
+local quatUnpack = Quat.unpack
+local quatFromCFrame = Quat.fromCFrame
+
+local function quantizeVec3(
+    v: Vector3,
+    min: number,
+    delta: number,
+    scale: number
+): (number, number, number)
+    return round(clamp(v.X - min, 0, delta) * scale),
+        round(clamp(v.Y - min, 0, delta) * scale),
+        round(clamp(v.Z - min, 0, delta) * scale)
+end
+
+-- Reject out-of-range components rather than silently snapping via clamp().
+local function validateVec3(v: Vector3, min: number, max: number, label: string): ()
+    if v.X < min or v.X > max or v.Y < min or v.Y > max or v.Z < min or v.Z > max then
+        Log.error(`{label} ({v.X}, {v.Y}, {v.Z}) has component out of range [{min}, {max}]`)
+    end
+end
+
+local function getScalarPrev(ch: Types.ChannelState, id: number, fallback: number): number
+    local cache = ch.deltas[id] :: any
+    return if cache then cache.scalar :: number else fallback
+end
+
+local function setScalarCache(ch: Types.ChannelState, id: number, value: number): ()
+    local cache = ch.deltas[id] :: any
+    if cache then
+        cache.scalar = value
+    else
+        ch.deltas[id] = { scalar = value } :: any
+    end
+end
+
+-- Public -----------------------------------------------------------------
+
+local DeltaScalar = {}
+
+--[[
+    Variable-length integer that emits zigzag varint of (current - previous).
+    First frame uses `min` as the implicit prev so the initial value encodes
+    as (value - min). Reliable transport only — a dropped frame desyncs prev.
+
+    Wire: 1 byte for unchanged or [-96, 95] mutations; up to 5 bytes for full i32.
+]]
+function DeltaScalar.deltaInt(min: number, max: number): Types.InternalCodec<number>
+    if min > max then
+        Log.error(`min ({min}) must be <= max ({max})`)
+    end
+    if floor(min) ~= min or floor(max) ~= max then
+        Log.error("bounds must be integers")
+    end
+    if max - min > I32_MAX then
+        Log.error(`range too wide; (max - min) must fit in i32, got {max - min}`)
+    end
+
+    local deltaId = allocDeltaId()
+
+    return table.freeze({
+        _isDelta = true,
+        _typeCheck = "number",
+        _isInteger = true,
+        _min = min,
+        _max = max,
+
+        write = function(ch: Types.ChannelState, value: number): ()
+            if value < min or value > max then
+                Log.error(`value {value} out of range [{min}, {max}]`)
+            end
+            if floor(value) ~= value then
+                Log.error(`value {value} must be an integer`)
+            end
+            varintWrite(ch, zigzagEncode(value - getScalarPrev(ch, deltaId, min)))
+            setScalarCache(ch, deltaId, value)
+        end,
+
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (number, number)
+            local raw, consumed = varintRead(src, pos)
+            if consumed == 0 then
+                Log.error("truncated deltaInt")
+            end
+            local cached = Baseline.getCache(deltaId)
+            local value = (if cached ~= nil then cached :: number else min) + zigzagDecode(raw)
+            if value < min or value > max then
+                Log.error(`deltaInt decoded value {value} out of range [{min}, {max}]`)
+            end
+            Baseline.setCache(deltaId, value)
+            return value, consumed
+        end,
+    }) :: Types.InternalCodec<number>
+end
+
+--[[
+    Quantized float with diffs in integer wire space (post-quantize). Storing
+    the quantized representative — not the float — across frames means
+    accumulating diffs over thousands of frames cannot drift past the grid.
+]]
+function DeltaScalar.deltaFloat(
+    min: number,
+    max: number,
+    precision: number
+): Types.InternalCodec<number>
+    if max - min == 0 then
+        return Base.constant(min)
+    end
+
+    local _, _, _, scale, invScale, delta = Quantize.setup("Lync.deltaFloat", min, max, precision)
+    local deltaId = allocDeltaId()
+
+    return table.freeze({
+        _isDelta = true,
+        _typeCheck = "number",
+        _min = min,
+        _max = max,
+
+        write = function(ch: Types.ChannelState, value: number): ()
+            local q = round(clamp(value - min, 0, delta) * scale)
+            varintWrite(ch, zigzagEncode(q - getScalarPrev(ch, deltaId, 0)))
+            setScalarCache(ch, deltaId, q)
+        end,
+
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (number, number)
+            local raw, consumed = varintRead(src, pos)
+            if consumed == 0 then
+                Log.error("truncated deltaFloat")
+            end
+            local cached = Baseline.getCache(deltaId)
+            local q = (if cached ~= nil then cached :: number else 0) + zigzagDecode(raw)
+            Baseline.setCache(deltaId, q)
+            return q * invScale + min, consumed
+        end,
+    }) :: Types.InternalCodec<number>
+end
+
+--[[
+    Quantized Vector3 with per-axis zigzag varint diffs. Static value: 3 bytes
+    (three zero zigzags); typical < 1 stud motion at 0.01-stud precision: 3-6
+    bytes. Baseline vec3 = 12 bytes, so 4x reduction at the static end.
+]]
+function DeltaScalar.deltaVec3(
+    min: number,
+    max: number,
+    precision: number
+): Types.InternalCodec<Vector3>
+    if max - min == 0 then
+        return Base.constant(Vector3.new(min, min, min)) :: Types.InternalCodec<Vector3>
+    end
+
+    local _, _, _, scale, invScale, delta = Quantize.setup("Lync.deltaVec3", min, max, precision)
+    local deltaId = allocDeltaId()
+
+    return table.freeze({
+        _isDelta = true,
+        _typeCheck = "Vector3",
+        _min = min,
+        _max = max,
+
+        write = function(ch: Types.ChannelState, value: Vector3): ()
+            validateVec3(value, min, max, "Vector3")
+            local qx, qy, qz = quantizeVec3(value, min, delta, scale)
+            local cache = ch.deltas[deltaId] :: any
+            local px, py, pz = 0, 0, 0
+            if cache then
+                px, py, pz = cache.qx :: number, cache.qy :: number, cache.qz :: number
+            end
+
+            varintWrite(ch, zigzagEncode(qx - px))
+            varintWrite(ch, zigzagEncode(qy - py))
+            varintWrite(ch, zigzagEncode(qz - pz))
+
+            if cache then
+                cache.qx, cache.qy, cache.qz = qx, qy, qz
+            else
+                ch.deltas[deltaId] = { qx = qx, qy = qy, qz = qz } :: any
+            end
+        end,
+
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector3, number)
+            local rx, cx = varintRead(src, pos)
+            if cx == 0 then
+                Log.error("truncated deltaVec3 X")
+            end
+            local ry, cy = varintRead(src, pos + cx)
+            if cy == 0 then
+                Log.error("truncated deltaVec3 Y")
+            end
+            local rz, cz = varintRead(src, pos + cx + cy)
+            if cz == 0 then
+                Log.error("truncated deltaVec3 Z")
+            end
+
+            local cached = Baseline.getCache(deltaId) :: any
+            local px, py, pz = 0, 0, 0
+            if cached then
+                px, py, pz = cached.qx, cached.qy, cached.qz
+            end
+            local qx = px + zigzagDecode(rx)
+            local qy = py + zigzagDecode(ry)
+            local qz = pz + zigzagDecode(rz)
+            Baseline.setCache(deltaId, { qx = qx, qy = qy, qz = qz })
+
+            return Vector3.new(qx * invScale + min, qy * invScale + min, qz * invScale + min),
+                cx + cy + cz
+        end,
+    }) :: Types.InternalCodec<Vector3>
+end
+
+--[[
+    Quantized position + smallest-three quaternion rotation. Wire layout:
+      byte 0   header bits: bit0=Δx, bit1=Δy, bit2=Δz, bit3=Δrot
+      For each set position bit: zigzag varint of quantized diff
+      If rotation bit set: 4-byte packed quat
+
+    Static CFrame: 1 byte. Pos-only motion: 1 + 3 zint bytes (~4-7).
+    Full update: 1 + 3 zint + 4 quat (~8-13). Baseline lossless: 24 bytes.
+]]
+function DeltaScalar.deltaCFrame(
+    posMin: number,
+    posMax: number,
+    posPrecision: number
+): Types.InternalCodec<CFrame>
+    -- Quantize.setup itself rejects min == max; the redundant guard is gone.
+    local _, _, _, scale, invScale, delta =
+        Quantize.setup("Lync.deltaCFrame", posMin, posMax, posPrecision)
+    local deltaId = allocDeltaId()
+
+    return table.freeze({
+        _isDelta = true,
+        _typeCheck = "CFrame",
+
+        write = function(ch: Types.ChannelState, value: CFrame): ()
+            local pos = value.Position
+            validateVec3(pos, posMin, posMax, "CFrame position")
+            local qx, qy, qz = quantizeVec3(pos, posMin, delta, scale)
+            local packed = quatPack(quatFromCFrame(value))
+
+            -- prev = 0 so the first frame writes absolute values; receiver also defaults to 0.
+            local cache = ch.deltas[deltaId] :: any
+            local flag: number
+            local px, py, pz = 0, 0, 0
+            if cache then
+                px = cache.qx :: number
+                py = cache.qy :: number
+                pz = cache.qz :: number
+                local ppacked = cache.qrot :: number
+                flag = 0
+                if qx ~= px then
+                    flag = bor(flag, CF_X)
+                end
+                if qy ~= py then
+                    flag = bor(flag, CF_Y)
+                end
+                if qz ~= pz then
+                    flag = bor(flag, CF_Z)
+                end
+                if packed ~= ppacked then
+                    flag = bor(flag, CF_ROT)
+                end
+            else
+                -- First frame: emit everything so the receiver has a baseline.
+                flag = CF_ALL
+            end
+
+            ensure(ch, 1)
+            writeu8(ch.buff, ch.cursor, flag)
+            ch.cursor += 1
+
+            if band(flag, CF_X) ~= 0 then
+                varintWrite(ch, zigzagEncode(qx - px))
+            end
+            if band(flag, CF_Y) ~= 0 then
+                varintWrite(ch, zigzagEncode(qy - py))
+            end
+            if band(flag, CF_Z) ~= 0 then
+                varintWrite(ch, zigzagEncode(qz - pz))
+            end
+            if band(flag, CF_ROT) ~= 0 then
+                ensure(ch, 4)
+                writeu32(ch.buff, ch.cursor, packed)
+                ch.cursor += 4
+            end
+
+            if cache then
+                cache.qx, cache.qy, cache.qz, cache.qrot = qx, qy, qz, packed
+            else
+                ch.deltas[deltaId] = { qx = qx, qy = qy, qz = qz, qrot = packed } :: any
+            end
+        end,
+
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (CFrame, number)
+            if pos >= bufLen(src) then
+                Log.error("truncated deltaCFrame header")
+            end
+            local flag = readu8(src, pos)
+            local total = 1
+
+            local cached = Baseline.getCache(deltaId) :: any
+            local qx, qy, qz, packed = 0, 0, 0, 0
+            if cached then
+                qx, qy, qz, packed = cached.qx, cached.qy, cached.qz, cached.qrot
+            end
+
+            if band(flag, CF_X) ~= 0 then
+                local r, c = varintRead(src, pos + total)
+                if c == 0 then
+                    Log.error("truncated deltaCFrame X")
+                end
+                qx += zigzagDecode(r)
+                total += c
+            end
+            if band(flag, CF_Y) ~= 0 then
+                local r, c = varintRead(src, pos + total)
+                if c == 0 then
+                    Log.error("truncated deltaCFrame Y")
+                end
+                qy += zigzagDecode(r)
+                total += c
+            end
+            if band(flag, CF_Z) ~= 0 then
+                local r, c = varintRead(src, pos + total)
+                if c == 0 then
+                    Log.error("truncated deltaCFrame Z")
+                end
+                qz += zigzagDecode(r)
+                total += c
+            end
+            if band(flag, CF_ROT) ~= 0 then
+                if pos + total + 4 > bufLen(src) then
+                    Log.error("truncated deltaCFrame rotation")
+                end
+                packed = readu32(src, pos + total)
+                total += 4
+            end
+
+            Baseline.setCache(deltaId, { qx = qx, qy = qy, qz = qz, qrot = packed })
+
+            local position =
+                Vector3.new(qx * invScale + posMin, qy * invScale + posMin, qz * invScale + posMin)
+            return CFrame.new(position) * quatUnpack(packed), total
+        end,
+    }) :: Types.InternalCodec<CFrame>
+end
+
+return table.freeze(DeltaScalar)

package/src/codec/primitive/Varint.luau

@@ -35,7 +35,7 @@ local U32_MAX = Constants.U32_MAX
 
 -- Private ----------------------------------------------------------------
 
-local alloc = Base.alloc
+local ensure = Base.ensure
 local band = bit32.band
 local bor = bit32.bor
 local rshift = bit32.rshift
@@ -46,18 +46,24 @@ local readu8 = buffer.readu8
 local readu16 = buffer.readu16
 local readu32 = buffer.readu32
 
-local function ensure(ch: Types.ChannelState, n: number): ()
-    if ch.cursor + n > ch.size then
-        alloc(ch, n)
-    end
-end
-
 -- Public -----------------------------------------------------------------
 
 local Varint = {}
 
 Varint.INLINE_MAX = INLINE_MAX
 
+-- Wire byte count for a value, without encoding it. Used by cost heuristics.
+function Varint.length(value: number): number
+    if value <= INLINE_MAX then
+        return 1
+    elseif value <= TWO_MAX then
+        return 2
+    elseif value <= THREE_MAX then
+        return 3
+    end
+    return 5
+end
+
 function Varint.write(ch: Types.ChannelState, value: number): ()
     if value < 0 or value > U32_MAX or value % 1 ~= 0 then
         Log.error(`value must be an integer in [0, {U32_MAX}], got {value}`)