@axpecter/lync 2.3.3 → 3.0.0

package/src/codec/composite/Tuple.luau

@@ -1,143 +0,0 @@
---!strict
---!native
--- Positional ordered codec. Like struct but indexed.
-
-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 ----------------------------------------------------------------
-
-local alloc = Base.alloc
-
--- Public -----------------------------------------------------------------
-
-local Tuple = {}
-
-function Tuple.define(...: Types.InternalCodec<any>): Types.InternalCodec<any>
-    local codecs = { ... }
-    local count = #codecs
-    Log.assert(count > 0, "requires at least one codec")
-
-    -- 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
-            else
-                allDirect = false
-            end
-        end
-    end
-    table.freeze(codecs)
-
-    -- All-direct: pre-compute offsets so write/read avoids the cursor dance per element.
-    if allDirect then
-        local offsets = table.create(count)
-        local directWrites = table.create(count)
-        local directReads = table.create(count)
-        local runningOffset = 0
-
-        for i = 1, count do
-            local c = codecs[i]
-            offsets[i] = runningOffset
-            directWrites[i] = c._directWrite
-            directReads[i] = c._directRead
-            runningOffset += c._size :: number
-        end
-        table.freeze(offsets)
-        table.freeze(directWrites)
-        table.freeze(directReads)
-
-        local codec: Types.InternalCodec<any> = {
-            _size = totalSize,
-            _isTuple = true,
-            _elements = codecs,
-
-            _directWrite = function(b: buffer, off: number, value: any): ()
-                for i = 1, count do
-                    directWrites[i](b, off + offsets[i], value[i])
-                end
-            end,
-
-            _directRead = function(b: buffer, off: number): any
-                local result = table.create(count)
-                for i = 1, count do
-                    result[i] = directReads[i](b, off + offsets[i])
-                end
-                return result
-            end,
-
-            write = function(ch: Types.ChannelState, value: any): ()
-                local cursor = ch.cursor
-                if cursor + totalSize > ch.size then
-                    alloc(ch, totalSize)
-                end
-                local b = ch.buff
-                for i = 1, count do
-                    directWrites[i](b, cursor + offsets[i], value[i])
-                end
-                ch.cursor = cursor + totalSize
-            end,
-
-            read = function(src: buffer, pos: number, _refs: { Instance }?): (any, number)
-                local result = table.create(count)
-                for i = 1, count do
-                    result[i] = directReads[i](src, pos + offsets[i])
-                end
-                return result, totalSize
-            end,
-        }
-        if hasUnknown then
-            codec._hasUnknown = true
-        end
-        if hasDelta then
-            codec._hasDelta = true
-        end
-        return table.freeze(codec)
-    end
-
-    local codec: Types.InternalCodec<any> = {
-        _isTuple = true,
-        _elements = codecs,
-
-        write = function(ch: Types.ChannelState, value: any): ()
-            for i = 1, count do
-                codecs[i].write(ch, value[i])
-            end
-        end,
-
-        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
-            local result = table.create(count)
-            local total = 0
-            for i = 1, count do
-                local v, consumed = codecs[i].read(src, pos + total, refs)
-                if consumed == 0 then
-                    Log.error(`element codec consumed 0 bytes at index {i}`)
-                end
-                result[i] = v
-                total += consumed
-            end
-            return result, total
-        end,
-    }
-    if hasUnknown then
-        codec._hasUnknown = true
-    end
-    if hasDelta then
-        codec._hasDelta = true
-    end
-    return table.freeze(codec)
-end
-
-return table.freeze(Tuple)

package/src/codec/datatype/Buffer.luau

@@ -1,66 +0,0 @@
---!strict
---!native
--- Raw buffer codec with dense-prefix-varint length prefix.
-
-local Base = require(script.Parent.Parent.Base)
-local Log = require(script.Parent.Parent.Parent.util.Log)
-local Types = require(script.Parent.Parent.Parent.Types)
-local Varint = require(script.Parent.Parent.primitive.Varint)
-
--- Private ----------------------------------------------------------------
-
-local alloc = Base.alloc
-local INLINE_MAX = Varint.INLINE_MAX
-
-local function writeBuffer(ch: Types.ChannelState, value: buffer): ()
-    local len = buffer.len(value)
-    local cursor = ch.cursor
-
-    -- Single-byte length fast path skips the full varint encode.
-    if len <= INLINE_MAX then
-        if cursor + 1 + len > ch.size then
-            alloc(ch, 1 + len)
-        end
-        local b = ch.buff
-        buffer.writeu8(b, cursor, len)
-        buffer.copy(b, cursor + 1, value, 0, len)
-        ch.cursor = cursor + 1 + len
-        return
-    end
-
-    Varint.write(ch, len)
-    cursor = ch.cursor
-    if cursor + len > ch.size then
-        alloc(ch, len)
-    end
-    buffer.copy(ch.buff, cursor, value, 0, len)
-    ch.cursor = cursor + len
-end
-
-local function readBuffer(src: buffer, pos: number, _refs: { Instance }?): (buffer, number)
-    local len, lenBytes = Varint.readLengthPrefix(src, pos)
-    if len == 0 then
-        return buffer.create(0), lenBytes
-    end
-
-    local dataStart = pos + lenBytes
-    if dataStart + len > buffer.len(src) then
-        Log.error(`length {len}B exceeds remaining buffer`)
-    end
-
-    local out = buffer.create(len)
-    buffer.copy(out, 0, src, dataStart, len)
-    return out, lenBytes + len
-end
-
--- Public -----------------------------------------------------------------
-
-local BufferCodec = {}
-
-BufferCodec.buff = table.freeze({
-    _typeCheck = "buffer",
-    write = writeBuffer,
-    read = readBuffer,
-})
-
-return table.freeze(BufferCodec)

package/src/codec/datatype/CFrame.luau

@@ -1,109 +0,0 @@
---!strict
---!native
--- 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 --------------------------------------------------------------
-
-local EPSILON = 2.4e-7
-local EPSILON_SQ = EPSILON * EPSILON
-
--- Private ----------------------------------------------------------------
-
-local alloc = Base.alloc
-local writef32 = buffer.writef32
-local readf32 = buffer.readf32
-local writeu32 = buffer.writeu32
-local readu32 = buffer.readu32
-local sqrt = math.sqrt
-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
-    writef32(b, off, pos.X)
-    writef32(b, off + 4, pos.Y)
-    writef32(b, off + 8, pos.Z)
-
-    local axis, angle = value:ToAxisAngle()
-    if angle < EPSILON then
-        writef32(b, off + 12, 0)
-        writef32(b, off + 16, 0)
-        writef32(b, off + 20, 0)
-        return
-    end
-    writef32(b, off + 12, axis.X * angle)
-    writef32(b, off + 16, axis.Y * angle)
-    writef32(b, off + 20, axis.Z * angle)
-end
-
-local function readLossless(b: buffer, off: number): CFrame
-    local px = readf32(b, off)
-    local py = readf32(b, off + 4)
-    local pz = readf32(b, off + 8)
-    local rx = readf32(b, off + 12)
-    local ry = readf32(b, off + 16)
-    local rz = readf32(b, off + 20)
-
-    local sqLen = rx * rx + ry * ry + rz * rz
-    if sqLen < EPSILON_SQ then
-        return CFrame.new(px, py, pz)
-    end
-
-    local angle = sqrt(sqLen)
-    local inv = 1 / angle
-    return CFrame.new(px, py, pz)
-        * CFrame.fromAxisAngle(Vector3.new(rx * inv, ry * inv, rz * inv), angle)
-end
-
---[[
-    Compressed wire (16B):
-      [0..11]  position 3x f32
-      [12..15] packed [largest:2][a:10][b:10][c:10] (smallest-three quat)
-]]
-local function writeCompressed(b: buffer, off: number, value: CFrame): ()
-    local pos = value.Position
-    writef32(b, off, pos.X)
-    writef32(b, off + 4, pos.Y)
-    writef32(b, off + 8, pos.Z)
-    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)
-    return CFrame.new(px, py, pz) * quatUnpack(readu32(b, off + 12))
-end
-
-local function compressedFactory(_self): Types.InternalCodec<CFrame>
-    return Base.define(16, writeCompressed, readCompressed, { _typeCheck = "CFrame" })
-end
-
--- Public -----------------------------------------------------------------
-
-local CFrameCodec = {}
-
-CFrameCodec.cframe = table.freeze(setmetatable({
-    _size = 24,
-    _directWrite = writeLossless,
-    _directRead = readLossless,
-    _typeCheck = "CFrame",
-    write = function(ch: Types.ChannelState, value: CFrame): ()
-        local cursor = ch.cursor
-        if cursor + 24 > ch.size then
-            alloc(ch, 24)
-        end
-        writeLossless(ch.buff, cursor, value)
-        ch.cursor = cursor + 24
-    end,
-    read = function(src: buffer, pos: number, _refs: { Instance }?): (CFrame, number)
-        return readLossless(src, pos), 24
-    end,
-}, table.freeze({ __call = compressedFactory })))
-
-return table.freeze(CFrameCodec)

package/src/codec/datatype/Color.luau

@@ -1,32 +0,0 @@
---!strict
---!native
--- Color3 codec. 3 bytes (R/G/B u8 per channel), clamped to [0, 1].
-
-local Base = require(script.Parent.Parent.Base)
-local Constants = require(script.Parent.Parent.Parent.util.Constants)
-
--- Private ----------------------------------------------------------------
-
-local U8_MAX = Constants.U8_MAX
-local writeu8 = buffer.writeu8
-local readu8 = buffer.readu8
-local round = math.round
-local clamp = math.clamp
-
-local function writeColor3(b: buffer, off: number, value: Color3): ()
-    writeu8(b, off, round(clamp(value.R, 0, 1) * U8_MAX))
-    writeu8(b, off + 1, round(clamp(value.G, 0, 1) * U8_MAX))
-    writeu8(b, off + 2, round(clamp(value.B, 0, 1) * U8_MAX))
-end
-
-local function readColor3(b: buffer, off: number): Color3
-    return Color3.fromRGB(readu8(b, off), readu8(b, off + 1), readu8(b, off + 2))
-end
-
--- Public -----------------------------------------------------------------
-
-local Color = {}
-
-Color.color3 = Base.define(3, writeColor3, readColor3, { _typeCheck = "Color3" })
-
-return table.freeze(Color)

package/src/codec/datatype/Instance.luau

@@ -1,52 +0,0 @@
---!strict
---!native
--- Instance codec via the channel's sidecar reference array.
-
-local Channel = require(script.Parent.Parent.Parent.internal.Channel)
-local Log = require(script.Parent.Parent.Parent.util.Log)
-local Types = require(script.Parent.Parent.Parent.Types)
-
--- Private ----------------------------------------------------------------
-
-local pushRef = Channel.pushRef
-local readu16 = buffer.readu16
-
-local function writeInstance(ch: Types.ChannelState, value: Instance): ()
-    pushRef(ch, value)
-end
-
-local function readInstance(src: buffer, pos: number, refs: { Instance }?): (Instance, number)
-    local r = refs
-    if not r then
-        Log.error("refs array is required")
-    end
-
-    local idx = readu16(src, pos)
-    if idx < 1 or idx > #r then
-        Log.error(`ref index {idx} out of bounds`)
-    end
-
-    --[[
-        Crafted clients can name a slot we never wrote; reject non-Instances.
-        Unknown codec skips this since it can legitimately hold any sidecar value.
-    ]]
-    local inst = r[idx]
-    if typeof(inst) ~= "Instance" then
-        Log.error("ref is not an Instance")
-    end
-    return inst, 2
-end
-
--- Public -----------------------------------------------------------------
-
-local InstanceCodec = {}
-
--- No _directWrite/_directRead: write needs ch.refs (no fast path).
-InstanceCodec.inst = table.freeze({
-    _size = 2,
-    _typeCheck = "Instance",
-    write = writeInstance,
-    read = readInstance,
-})
-
-return table.freeze(InstanceCodec)

package/src/codec/datatype/IntVector.luau

@@ -1,39 +0,0 @@
---!strict
---!native
--- Vector2int16 (4B) and Vector3int16 (6B) codecs.
-
-local Base = require(script.Parent.Parent.Base)
-local Signed = require(script.Parent.Parent.primitive.Signed)
-
--- Private ----------------------------------------------------------------
-
-local writeI16 = Signed.writeI16
-local readi16 = buffer.readi16
-
-local function writeVec2I16(b: buffer, off: number, value: Vector2int16): ()
-    writeI16(b, off, value.X)
-    writeI16(b, off + 2, value.Y)
-end
-
-local function readVec2I16(b: buffer, off: number): Vector2int16
-    return Vector2int16.new(readi16(b, off), readi16(b, off + 2))
-end
-
-local function writeVec3I16(b: buffer, off: number, value: Vector3int16): ()
-    writeI16(b, off, value.X)
-    writeI16(b, off + 2, value.Y)
-    writeI16(b, off + 4, value.Z)
-end
-
-local function readVec3I16(b: buffer, off: number): Vector3int16
-    return Vector3int16.new(readi16(b, off), readi16(b, off + 2), readi16(b, off + 4))
-end
-
--- Public -----------------------------------------------------------------
-
-local IntVector = {}
-
-IntVector.vec2int16 = Base.define(4, writeVec2I16, readVec2I16, { _typeCheck = "Vector2int16" })
-IntVector.vec3int16 = Base.define(6, writeVec3I16, readVec3I16, { _typeCheck = "Vector3int16" })
-
-return table.freeze(IntVector)

package/src/codec/datatype/NumberRange.luau

@@ -1,39 +0,0 @@
---!strict
---!native
--- NumberRange codec. 8B: Min f32 + Max f32.
-
-local Base = require(script.Parent.Parent.Base)
-local Log = require(script.Parent.Parent.Parent.util.Log)
-
--- Private ----------------------------------------------------------------
-
-local writef32 = buffer.writef32
-local readf32 = buffer.readf32
-
-local function writeNumberRange(b: buffer, off: number, value: NumberRange): ()
-    writef32(b, off, value.Min)
-    writef32(b, off + 4, value.Max)
-end
-
---[[
-    Reject min > max instead of silently swapping. A swap masks a desync;
-    erroring aborts the frame so the transport can reset its baseline.
-]]
-local function readNumberRange(b: buffer, off: number): NumberRange
-    local minV = readf32(b, off)
-    local maxV = readf32(b, off + 4)
-    if minV > maxV then
-        Log.error(`min ({minV}) > max ({maxV})`)
-    end
-    return NumberRange.new(minV, maxV)
-end
-
--- Public -----------------------------------------------------------------
-
-local NumberRangeCodec = {}
-
-NumberRangeCodec.numberRange = Base.define(8, writeNumberRange, readNumberRange, {
-    _typeCheck = "NumberRange",
-})
-
-return table.freeze(NumberRangeCodec)

package/src/codec/datatype/Ray.luau

@@ -1,36 +0,0 @@
---!strict
---!native
--- Ray codec. 24B: Origin (3x f32) + Direction (3x f32).
-
-local Base = require(script.Parent.Parent.Base)
-
--- Private ----------------------------------------------------------------
-
-local writef32 = buffer.writef32
-local readf32 = buffer.readf32
-
-local function writeRay(b: buffer, off: number, value: Ray): ()
-    local o = value.Origin
-    local d = value.Direction
-    writef32(b, off, o.X)
-    writef32(b, off + 4, o.Y)
-    writef32(b, off + 8, o.Z)
-    writef32(b, off + 12, d.X)
-    writef32(b, off + 16, d.Y)
-    writef32(b, off + 20, d.Z)
-end
-
-local function readRay(b: buffer, off: number): Ray
-    return Ray.new(
-        Vector3.new(readf32(b, off), readf32(b, off + 4), readf32(b, off + 8)),
-        Vector3.new(readf32(b, off + 12), readf32(b, off + 16), readf32(b, off + 20))
-    )
-end
-
--- Public -----------------------------------------------------------------
-
-local RayCodec = {}
-
-RayCodec.ray = Base.define(24, writeRay, readRay, { _typeCheck = "Ray" })
-
-return table.freeze(RayCodec)

package/src/codec/datatype/Rect.luau

@@ -1,31 +0,0 @@
---!strict
---!native
--- Rect codec. 16B: 4x f32 (Min.X, Min.Y, Max.X, Max.Y).
-
-local Base = require(script.Parent.Parent.Base)
-
--- Private ----------------------------------------------------------------
-
-local writef32 = buffer.writef32
-local readf32 = buffer.readf32
-
-local function writeRect(b: buffer, off: number, value: Rect): ()
-    local minV = value.Min
-    local maxV = value.Max
-    writef32(b, off, minV.X)
-    writef32(b, off + 4, minV.Y)
-    writef32(b, off + 8, maxV.X)
-    writef32(b, off + 12, maxV.Y)
-end
-
-local function readRect(b: buffer, off: number): Rect
-    return Rect.new(readf32(b, off), readf32(b, off + 4), readf32(b, off + 8), readf32(b, off + 12))
-end
-
--- Public -----------------------------------------------------------------
-
-local RectCodec = {}
-
-RectCodec.rect = Base.define(16, writeRect, readRect, { _typeCheck = "Rect" })
-
-return table.freeze(RectCodec)

package/src/codec/datatype/Region.luau

@@ -1,62 +0,0 @@
---!strict
---!native
--- Region3 (24B) and Region3int16 (12B) codecs.
-
-local Base = require(script.Parent.Parent.Base)
-local Signed = require(script.Parent.Parent.primitive.Signed)
-
--- Private ----------------------------------------------------------------
-
-local writef32 = buffer.writef32
-local readf32 = buffer.readf32
-local writeI16 = Signed.writeI16
-local readi16 = buffer.readi16
-
--- Region3 has no Min/Max accessors; reconstruct from CFrame.Position +/- Size/2.
-local function writeRegion3(b: buffer, off: number, value: Region3): ()
-    local pos = value.CFrame.Position
-    local half = value.Size * 0.5
-    local minV = pos - half
-    local maxV = pos + half
-    writef32(b, off, minV.X)
-    writef32(b, off + 4, minV.Y)
-    writef32(b, off + 8, minV.Z)
-    writef32(b, off + 12, maxV.X)
-    writef32(b, off + 16, maxV.Y)
-    writef32(b, off + 20, maxV.Z)
-end
-
-local function readRegion3(b: buffer, off: number): Region3
-    return Region3.new(
-        Vector3.new(readf32(b, off), readf32(b, off + 4), readf32(b, off + 8)),
-        Vector3.new(readf32(b, off + 12), readf32(b, off + 16), readf32(b, off + 20))
-    )
-end
-
-local function writeRegion3I16(b: buffer, off: number, value: Region3int16): ()
-    local minV = value.Min
-    local maxV = value.Max
-    writeI16(b, off, minV.X)
-    writeI16(b, off + 2, minV.Y)
-    writeI16(b, off + 4, minV.Z)
-    writeI16(b, off + 6, maxV.X)
-    writeI16(b, off + 8, maxV.Y)
-    writeI16(b, off + 10, maxV.Z)
-end
-
-local function readRegion3I16(b: buffer, off: number): Region3int16
-    return Region3int16.new(
-        Vector3int16.new(readi16(b, off), readi16(b, off + 2), readi16(b, off + 4)),
-        Vector3int16.new(readi16(b, off + 6), readi16(b, off + 8), readi16(b, off + 10))
-    )
-end
-
--- Public -----------------------------------------------------------------
-
-local Region = {}
-
-Region.region3 = Base.define(24, writeRegion3, readRegion3, { _typeCheck = "Region3" })
-Region.region3int16 =
-    Base.define(12, writeRegion3I16, readRegion3I16, { _typeCheck = "Region3int16" })
-
-return table.freeze(Region)