@axpecter/lync 1.4.3 → 1.5.0

package/src/codec/composite/Tagged.luau

@@ -2,8 +2,8 @@
 --!native
 -- Discriminated union codec. u8 variant tag + variant payload.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
@@ -11,42 +11,42 @@ type InternalCodec<T> = Types.InternalCodec<T>
 
 local alloc = Channel.alloc
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Tagged = {}
 
 -- Read injects tagField into the decoded table. Variant codecs must return mutable tables.
-function Tagged.define (tagField: string, variants: { [string]: Codec<any> }): Codec<any>
+function Tagged.define(tagField: string, variants: { [string]: Codec<any> }): Codec<any>
     if #tagField == 0 then
-        error ("[Lync] Tagged union tagField must not be empty")
+        error("[Lync] Tagged union tagField must not be empty")
     end
 
     local names = {} :: { string }
     for name in variants do
         if #name == 0 then
-            error ("[Lync] Tagged union variant name must not be empty")
+            error("[Lync] Tagged union variant name must not be empty")
         end
-        table.insert (names, name)
+        table.insert(names, name)
     end
-    table.sort (names)
+    table.sort(names)
 
     local count = #names
     if count == 0 then
-        error ("[Lync] Tagged union requires at least one variant")
+        error("[Lync] Tagged union requires at least one variant")
     end
     if count > 256 then
-        error (`[Lync] Tagged union exceeds 256 variants: {count}`)
+        error(`[Lync] Tagged union exceeds 256 variants: {count}`)
     end
 
     local nameToTag = {} :: { [string]: number }
-    local tagCodecs = table.create (count) :: { Codec<any> }
-    local tagNames = table.create (count) :: { string }
-    local tagSizes = table.create (count) :: { number? }
+    local tagCodecs = table.create(count) :: { Codec<any> }
+    local tagNames = table.create(count) :: { string }
+    local tagSizes = table.create(count) :: { number? }
 
     local allDirect = true
     local uniformSize: number? = (variants[names[1]] :: InternalCodec<any>)._size
-    local directWrites = table.create (count) :: { any }
-    local directReads = table.create (count) :: { any }
+    local directWrites = table.create(count) :: { any }
+    local directReads = table.create(count) :: { any }
 
     for i, name in names do
         local codec = variants[name] :: InternalCodec<any>
@@ -71,63 +71,63 @@ function Tagged.define (tagField: string, variants: { [string]: Codec<any> }): C
         end
     end
 
-    table.freeze (nameToTag)
-    table.freeze (tagCodecs)
-    table.freeze (tagNames)
-    table.freeze (tagSizes)
+    table.freeze(nameToTag)
+    table.freeze(tagCodecs)
+    table.freeze(tagNames)
+    table.freeze(tagSizes)
 
     local fixedSize: number? = if uniformSize then 1 + uniformSize else nil
 
     if allDirect then
-        table.freeze (directWrites)
-        table.freeze (directReads)
+        table.freeze(directWrites)
+        table.freeze(directReads)
 
         -- If uniform size, expose _directWrite/_directRead for parent struct/array
         if fixedSize then
-            return table.freeze ({
+            return table.freeze({
                 _size = fixedSize,
-                _directWrite = function (b: buffer, offset: number, value: any): ()
+                _directWrite = function(b: buffer, offset: number, value: any): ()
                     local tag = nameToTag[value[tagField]]
                     if not tag then
-                        error (`[Lync] Unknown variant: {value[tagField]}`)
+                        error(`[Lync] Unknown variant: {value[tagField]}`)
                     end
-                    buffer.writeu8 (b, offset, tag - 1)
-                    directWrites[tag] (b, offset + 1, value)
+                    buffer.writeu8(b, offset, tag - 1)
+                    directWrites[tag](b, offset + 1, value)
                 end,
-                _directRead = function (b: buffer, offset: number): any
-                    local tag = buffer.readu8 (b, offset) + 1
+                _directRead = function(b: buffer, offset: number): any
+                    local tag = buffer.readu8(b, offset) + 1
                     local name = tagNames[tag]
                     if not name then
-                        error (`[Lync] Unknown variant index: {tag - 1}`)
+                        error(`[Lync] Unknown variant index: {tag - 1}`)
                     end
-                    local data = directReads[tag] (b, offset + 1)
-                    if type (data) == "table" then
+                    local data = directReads[tag](b, offset + 1)
+                    if type(data) == "table" then
                         data[tagField] = name
                     end
                     return data
                 end,
-                write = function (ch: ChannelState, value: any): ()
+                write = function(ch: ChannelState, value: any): ()
                     local tag = nameToTag[value[tagField]]
                     if not tag then
-                        error (`[Lync] Unknown variant: {value[tagField]}`)
+                        error(`[Lync] Unknown variant: {value[tagField]}`)
                     end
                     local c = ch.cursor
                     if c + (fixedSize :: number) > ch.size then
-                        alloc (ch, fixedSize :: number)
+                        alloc(ch, fixedSize :: number)
                     end
                     local b = ch.buff
-                    buffer.writeu8 (b, c, tag - 1)
-                    directWrites[tag] (b, c + 1, value)
+                    buffer.writeu8(b, c, tag - 1)
+                    directWrites[tag](b, c + 1, value)
                     ch.cursor = c + (fixedSize :: number)
                 end,
-                read = function (src: buffer, pos: number, _refs: { Instance }?): (any, number)
-                    local tag = buffer.readu8 (src, pos) + 1
+                read = function(src: buffer, pos: number, _refs: { Instance }?): (any, number)
+                    local tag = buffer.readu8(src, pos) + 1
                     local name = tagNames[tag]
                     if not name then
-                        error (`[Lync] Unknown variant index: {tag - 1}`)
+                        error(`[Lync] Unknown variant index: {tag - 1}`)
                     end
-                    local data = directReads[tag] (src, pos + 1)
-                    if type (data) == "table" then
+                    local data = directReads[tag](src, pos + 1)
+                    if type(data) == "table" then
                         data[tagField] = name
                     end
                     return data, fixedSize :: number
@@ -136,35 +136,35 @@ function Tagged.define (tagField: string, variants: { [string]: Codec<any> }): C
         end
 
         -- Non-uniform sizes but all have direct: use direct dispatch internally
-        local fieldSizes = table.clone (tagSizes) :: { number }
-        table.freeze (fieldSizes)
+        local fieldSizes = table.clone(tagSizes) :: { number }
+        table.freeze(fieldSizes)
 
-        return table.freeze ({
+        return table.freeze({
             _size = nil,
-            write = function (ch: ChannelState, value: any): ()
+            write = function(ch: ChannelState, value: any): ()
                 local tag = nameToTag[value[tagField]]
                 if not tag then
-                    error (`[Lync] Unknown variant: {value[tagField]}`)
+                    error(`[Lync] Unknown variant: {value[tagField]}`)
                 end
                 local varSize = fieldSizes[tag]
                 local totalNeeded = 1 + varSize
                 local c = ch.cursor
                 if c + totalNeeded > ch.size then
-                    alloc (ch, totalNeeded)
+                    alloc(ch, totalNeeded)
                 end
                 local b = ch.buff
-                buffer.writeu8 (b, c, tag - 1)
-                directWrites[tag] (b, c + 1, value)
+                buffer.writeu8(b, c, tag - 1)
+                directWrites[tag](b, c + 1, value)
                 ch.cursor = c + totalNeeded
             end,
-            read = function (src: buffer, pos: number, _refs: { Instance }?): (any, number)
-                local tag = buffer.readu8 (src, pos) + 1
+            read = function(src: buffer, pos: number, _refs: { Instance }?): (any, number)
+                local tag = buffer.readu8(src, pos) + 1
                 local name = tagNames[tag]
                 if not name then
-                    error (`[Lync] Unknown variant index: {tag - 1}`)
+                    error(`[Lync] Unknown variant index: {tag - 1}`)
                 end
-                local data = directReads[tag] (src, pos + 1)
-                if type (data) == "table" then
+                local data = directReads[tag](src, pos + 1)
+                if type(data) == "table" then
                     data[tagField] = name
                 end
                 return data, 1 + fieldSizes[tag]
@@ -172,45 +172,45 @@ function Tagged.define (tagField: string, variants: { [string]: Codec<any> }): C
         })
     end
 
-    local writeFns = table.create (count) :: { any }
-    local readFns = table.create (count) :: { any }
+    local writeFns = table.create(count) :: { any }
+    local readFns = table.create(count) :: { any }
     for i = 1, count do
         writeFns[i] = tagCodecs[i].write
         readFns[i] = tagCodecs[i].read
     end
-    table.freeze (writeFns)
-    table.freeze (readFns)
+    table.freeze(writeFns)
+    table.freeze(readFns)
 
-    return table.freeze ({
+    return table.freeze({
         _size = fixedSize,
-        write = function (ch: ChannelState, value: any): ()
+        write = function(ch: ChannelState, value: any): ()
             local tag = nameToTag[value[tagField]]
             if not tag then
-                error (`[Lync] Unknown variant: {value[tagField]}`)
+                error(`[Lync] Unknown variant: {value[tagField]}`)
             end
 
             local variantSize = tagSizes[tag]
             if variantSize then
-                alloc (ch, 1 + variantSize)
+                alloc(ch, 1 + variantSize)
             else
-                alloc (ch, 1)
+                alloc(ch, 1)
             end
 
             local c = ch.cursor
-            buffer.writeu8 (ch.buff, c, tag - 1)
+            buffer.writeu8(ch.buff, c, tag - 1)
             ch.cursor = c + 1
-            writeFns[tag] (ch, value)
+            writeFns[tag](ch, value)
         end,
-        read = function (src: buffer, pos: number, refs: { Instance }?): (any, number)
-            local tag = buffer.readu8 (src, pos) + 1
+        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
+            local tag = buffer.readu8(src, pos) + 1
             local name = tagNames[tag]
             if not name then
-                error (`[Lync] Unknown variant index: {tag - 1}`)
+                error(`[Lync] Unknown variant index: {tag - 1}`)
             end
 
-            local data, bytes = readFns[tag] (src, pos + 1, refs)
+            local data, bytes = readFns[tag](src, pos + 1, refs)
 
-            if type (data) == "table" then
+            if type(data) == "table" then
                 data[tagField] = name
             end
 
@@ -219,4 +219,4 @@ function Tagged.define (tagField: string, variants: { [string]: Codec<any> }): C
     })
 end
 
-return table.freeze (Tagged)
+return table.freeze(Tagged)

package/src/codec/composite/Tuple.luau

@@ -2,8 +2,8 @@
 --!native
 -- Positional ordered codec. Like struct but indexed, not keyed.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
@@ -11,24 +11,24 @@ type InternalCodec<T> = Types.InternalCodec<T>
 
 local alloc = Channel.alloc
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Tuple = {}
 
-function Tuple.define (...: Codec<any>): Codec<{ any }>
+function Tuple.define(...: Codec<any>): Codec<{ any }>
     local codecs = { ... }
     local count = #codecs
     if count == 0 then
-        error ("[Lync] Tuple requires at least one codec")
+        error("[Lync] Tuple requires at least one codec")
     end
 
-    table.freeze (codecs)
+    table.freeze(codecs)
 
     local canDirect = true
     local totalSize: number = 0
-    local directWrites = table.create (count) :: { any }
-    local directReads = table.create (count) :: { any }
-    local fieldSizes = table.create (count) :: { number }
+    local directWrites = table.create(count) :: { any }
+    local directReads = table.create(count) :: { any }
+    local fieldSizes = table.create(count) :: { number }
 
     for i = 1, count do
         local internal = codecs[i] :: InternalCodec<any>
@@ -67,72 +67,72 @@ function Tuple.define (...: Codec<any>): Codec<{ any }>
     end
 
     if canDirect then
-        table.freeze (directWrites)
-        table.freeze (directReads)
-        table.freeze (fieldSizes)
+        table.freeze(directWrites)
+        table.freeze(directReads)
+        table.freeze(fieldSizes)
 
-        local function directWriteBody (b: buffer, c: number, value: { any }): ()
+        local function directWriteBody(b: buffer, c: number, value: { any }): ()
             for i = 1, count do
-                directWrites[i] (b, c, value[i])
+                directWrites[i](b, c, value[i])
                 c += fieldSizes[i]
             end
         end
 
-        local function directReadBody (b: buffer, pos: number): { any }
-            local result = table.create (count)
+        local function directReadBody(b: buffer, pos: number): { any }
+            local result = table.create(count)
             local c = pos
             for i = 1, count do
-                result[i] = directReads[i] (b, c)
+                result[i] = directReads[i](b, c)
                 c += fieldSizes[i]
             end
             return result
         end
 
-        return table.freeze ({
+        return table.freeze({
             _size = totalSize,
             _directWrite = directWriteBody,
             _directRead = directReadBody,
-            write = function (ch: ChannelState, value: { any }): ()
+            write = function(ch: ChannelState, value: { any }): ()
                 local c = ch.cursor
                 if c + totalSize > ch.size then
-                    alloc (ch, totalSize)
+                    alloc(ch, totalSize)
                 end
-                directWriteBody (ch.buff, c, value)
+                directWriteBody(ch.buff, c, value)
                 ch.cursor = c + totalSize
             end,
-            read = function (src: buffer, pos: number, _refs: { Instance }?): ({ any }, number)
-                return directReadBody (src, pos), totalSize
+            read = function(src: buffer, pos: number, _refs: { Instance }?): ({ any }, number)
+                return directReadBody(src, pos), totalSize
             end,
         })
     end
 
-    local writeFns = table.create (count) :: { any }
-    local readFns = table.create (count) :: { any }
+    local writeFns = table.create(count) :: { any }
+    local readFns = table.create(count) :: { any }
     for i = 1, count do
         writeFns[i] = codecs[i].write
         readFns[i] = codecs[i].read
     end
-    table.freeze (writeFns)
-    table.freeze (readFns)
+    table.freeze(writeFns)
+    table.freeze(readFns)
 
     local hasFixedTotal = totalSize ~= nil
 
-    return table.freeze ({
+    return table.freeze({
         _size = totalSize,
-        write = function (ch: ChannelState, value: { any }): ()
+        write = function(ch: ChannelState, value: { any }): ()
             if hasFixedTotal then
-                alloc (ch, totalSize :: number)
+                alloc(ch, totalSize :: number)
             end
             for i = 1, count do
-                writeFns[i] (ch, value[i])
+                writeFns[i](ch, value[i])
             end
         end,
-        read = function (src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
-            local result = table.create (count)
+        read = function(src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
+            local result = table.create(count)
             local absPos = pos
 
             for i = 1, count do
-                local value, n = readFns[i] (src, absPos, refs)
+                local value, n = readFns[i](src, absPos, refs)
                 result[i] = value
                 absPos += n
             end
@@ -142,4 +142,4 @@ function Tuple.define (...: Codec<any>): Codec<{ any }>
     })
 end
 
-return table.freeze (Tuple)
+return table.freeze(Tuple)

package/src/codec/datatype/Buffer.luau

@@ -2,44 +2,44 @@
 --!native
 -- Raw buffer codec with varint length prefix.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
-local Varint = require (script.Parent.Parent.primitive.Varint)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
+local Varint = require(script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Buffer = {}
 
-Buffer.buff = table.freeze ({
-    write = function (ch: ChannelState, value: buffer): ()
-        local len = buffer.len (value)
-        Varint.write (ch, len)
+Buffer.buff = table.freeze({
+    write = function(ch: ChannelState, value: buffer): ()
+        local len = buffer.len(value)
+        Varint.write(ch, len)
         local c = ch.cursor
         if c + len > ch.size then
-            alloc (ch, len)
+            alloc(ch, len)
         end
-        buffer.copy (ch.buff, c, value, 0, len)
+        buffer.copy(ch.buff, c, value, 0, len)
         ch.cursor = c + len
     end,
-    read = function (src: buffer, pos: number, _refs: { Instance }?): (buffer, number)
-        local len, lenBytes = Varint.read (src, pos)
+    read = function(src: buffer, pos: number, _refs: { Instance }?): (buffer, number)
+        local len, lenBytes = Varint.read(src, pos)
         if len == 0 then
-            return buffer.create (0), lenBytes
+            return buffer.create(0), lenBytes
         end
 
-        local remaining = buffer.len (src) - pos - lenBytes
+        local remaining = buffer.len(src) - pos - lenBytes
         if len > remaining then
-            error (`[Lync] Buffer length exceeds remaining: {len} > {remaining}`)
+            error(`[Lync] Buffer length exceeds remaining: {len} > {remaining}`)
         end
 
-        local out = buffer.create (len)
-        buffer.copy (out, 0, src, pos + lenBytes, len)
+        local out = buffer.create(len)
+        buffer.copy(out, 0, src, pos + lenBytes, len)
         return out, lenBytes + len
     end,
 })
 
-return table.freeze (Buffer)
+return table.freeze(Buffer)

package/src/codec/datatype/CFrame.luau

@@ -2,51 +2,51 @@
 --!native
 -- Axis-angle CFrame codec. Zero axis at identity for clean deltas.
 
-local Base = require (script.Parent.Parent.Base)
+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 function writeCFrame (b: buffer, c: number, value: CFrame): ()
+local function writeCFrame(b: buffer, c: number, value: CFrame): ()
     local position = value.Position
-    local axis, angle = value:ToAxisAngle ()
+    local axis, angle = value:ToAxisAngle()
 
-    buffer.writef32 (b, c, position.X)
-    buffer.writef32 (b, c + 4, position.Y)
-    buffer.writef32 (b, c + 8, position.Z)
+    buffer.writef32(b, c, position.X)
+    buffer.writef32(b, c + 4, position.Y)
+    buffer.writef32(b, c + 8, position.Z)
 
     if angle < EPSILON then
-        buffer.writef32 (b, c + 12, 0)
-        buffer.writef32 (b, c + 16, 0)
-        buffer.writef32 (b, c + 20, 0)
+        buffer.writef32(b, c + 12, 0)
+        buffer.writef32(b, c + 16, 0)
+        buffer.writef32(b, c + 20, 0)
     else
-        buffer.writef32 (b, c + 12, axis.X * angle)
-        buffer.writef32 (b, c + 16, axis.Y * angle)
-        buffer.writef32 (b, c + 20, axis.Z * angle)
+        buffer.writef32(b, c + 12, axis.X * angle)
+        buffer.writef32(b, c + 16, axis.Y * angle)
+        buffer.writef32(b, c + 20, axis.Z * angle)
     end
 end
 
-local function readCFrame (b: buffer, pos: number): CFrame
-    local px = buffer.readf32 (b, pos)
-    local py = buffer.readf32 (b, pos + 4)
-    local pz = buffer.readf32 (b, pos + 8)
-    local rx = buffer.readf32 (b, pos + 12)
-    local ry = buffer.readf32 (b, pos + 16)
-    local rz = buffer.readf32 (b, pos + 20)
+local function readCFrame(b: buffer, pos: number): CFrame
+    local px = buffer.readf32(b, pos)
+    local py = buffer.readf32(b, pos + 4)
+    local pz = buffer.readf32(b, pos + 8)
+    local rx = buffer.readf32(b, pos + 12)
+    local ry = buffer.readf32(b, pos + 16)
+    local rz = buffer.readf32(b, pos + 20)
 
-    local angle = sqrt (rx * rx + ry * ry + rz * rz)
-    local origin = CFrame.new (px, py, pz)
+    local angle = sqrt(rx * rx + ry * ry + rz * rz)
+    local origin = CFrame.new(px, py, pz)
 
     if angle < EPSILON then
         return origin
     end
 
     local inv = 1 / angle
-    return origin * CFrame.fromAxisAngle (Vector3.new (rx * inv, ry * inv, rz * inv), angle)
+    return origin * CFrame.fromAxisAngle(Vector3.new(rx * inv, ry * inv, rz * inv), angle)
 end
 
-return table.freeze ({
-    cframe = Base.define (24, writeCFrame, readCFrame),
+return table.freeze({
+    cframe = Base.define(24, writeCFrame, readCFrame),
 })

package/src/codec/datatype/Color.luau

@@ -2,21 +2,17 @@
 --!native
 -- Color3 codec. 3 bytes, 0-255 per channel, clamped.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
 local round = math.round
 local clamp = math.clamp
 
-return table.freeze ({
-    color3 = Base.define (3, function (b: buffer, o: number, v: Color3): ()
-        buffer.writeu8 (b, o, round (clamp (v.R, 0, 1) * 255))
-        buffer.writeu8 (b, o + 1, round (clamp (v.G, 0, 1) * 255))
-        buffer.writeu8 (b, o + 2, round (clamp (v.B, 0, 1) * 255))
-    end, function (b: buffer, o: number): Color3
-        return Color3.fromRGB (
-            buffer.readu8 (b, o),
-            buffer.readu8 (b, o + 1),
-            buffer.readu8 (b, o + 2)
-        )
+return table.freeze({
+    color3 = Base.define(3, function(b: buffer, o: number, v: Color3): ()
+        buffer.writeu8(b, o, round(clamp(v.R, 0, 1) * 255))
+        buffer.writeu8(b, o + 1, round(clamp(v.G, 0, 1) * 255))
+        buffer.writeu8(b, o + 2, round(clamp(v.B, 0, 1) * 255))
+    end, function(b: buffer, o: number): Color3
+        return Color3.fromRGB(buffer.readu8(b, o), buffer.readu8(b, o + 1), buffer.readu8(b, o + 2))
     end),
 })

package/src/codec/datatype/Instance.luau

@@ -2,48 +2,48 @@
 --!native
 -- Instance codec via sidecar reference array.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local InstanceCodec = {}
 
-InstanceCodec.inst = table.freeze ({
+InstanceCodec.inst = table.freeze({
     _size = 2,
-    write = function (ch: ChannelState, value: Instance): ()
+    write = function(ch: ChannelState, value: Instance): ()
         local refs = ch.refs
         local idx = #refs + 1
         if idx > 65535 then
-            error (`[Lync] Instance ref overflow: {idx} exceeds u16 max`)
+            error(`[Lync] Instance ref overflow: {idx} exceeds u16 max`)
         end
 
         refs[idx] = value
 
         local c = ch.cursor
         if c + 2 > ch.size then
-            alloc (ch, 2)
+            alloc(ch, 2)
         end
-        buffer.writeu16 (ch.buff, c, idx)
+        buffer.writeu16(ch.buff, c, idx)
         ch.cursor = c + 2
     end,
-    read = function (src: buffer, pos: number, refs: { Instance }?): (Instance, number)
-        local idx = buffer.readu16 (src, pos)
+    read = function(src: buffer, pos: number, refs: { Instance }?): (Instance, number)
+        local idx = buffer.readu16(src, pos)
         if not refs then
-            error ("[Lync] Instance read requires refs array")
+            error("[Lync] Instance read requires refs array")
         end
 
         local inst = refs[idx]
         if not inst then
-            error (`[Lync] Instance ref index out of bounds: {idx}`)
+            error(`[Lync] Instance ref index out of bounds: {idx}`)
         end
 
         return inst, 2
     end,
 })
 
-return table.freeze (InstanceCodec)
+return table.freeze(InstanceCodec)