@axpecter/lync 2.3.1 → 2.3.3

package/src/codec/composite/Shared.luau

@@ -11,14 +11,14 @@ local Types = require(script.Parent.Parent.Parent.Types)
 -- Constants --------------------------------------------------------------
 
 --[[
-    Delta flag space, shared across deltaStruct/deltaArray/deltaMap:
-      0    UNCHANGED  (decoder reuses cache)
-      1    FULL       (full payload follows)
-    Struct's per-segment scheme uses [1..segCount] as a single-dirty-segment
-    index, then segCount + DELTA_FULL_OFFSET / + DELTA_MULTI_OFFSET.
+    Delta flag base shared by deltaStruct's per-segment scheme:
+      0    UNCHANGED
+      1..segCount             single dirty segment k
+      segCount + FULL_OFFSET  FULL payload
+      segCount + MULTI_OFFSET MULTI: bitmap + dirty segs in order
+    deltaArray and deltaMap manage their own flag spaces.
 ]]
 local DELTA_UNCHANGED = 0
-local DELTA_FULL = 1
 local DELTA_FULL_OFFSET = 1
 local DELTA_MULTI_OFFSET = 2
 
@@ -37,9 +37,29 @@ local lshift = bit32.lshift
 local readu8 = buffer.readu8
 local writeu8 = buffer.writeu8
 local bufCopy = buffer.copy
+local bufLen = buffer.len
 local rangeEqual = Buf.rangeEqual
 local snapshot = Buf.snapshot
 
+--[[
+    Reuse `existing` when it's already large enough, else snapshot via
+    Buf.snapshot. Avoids per-write buffer allocations on delta caches that
+    hover at a stable size.
+]]
+local function copyToBuf(existing: buffer?, src: buffer, srcOff: number, len: number): buffer
+    if existing and bufLen(existing) >= len then
+        bufCopy(existing, 0, src, srcOff, len)
+        return existing
+    end
+    return snapshot(src, len, srcOff)
+end
+
+-- Update a `{raw, len}` cache shape from scratch bytes; reuses raw via copyToBuf.
+local function refreshCache(cache: any, src: buffer, len: number): ()
+    cache.raw = copyToBuf(cache.raw, src, 0, len)
+    cache.len = len
+end
+
 -- Public -----------------------------------------------------------------
 
 local Shared = {}
@@ -49,6 +69,20 @@ Shared.DELTA_FULL_OFFSET = DELTA_FULL_OFFSET
 Shared.DELTA_MULTI_OFFSET = DELTA_MULTI_OFFSET
 Shared.rangeEqual = rangeEqual
 Shared.snapshot = snapshot
+Shared.refreshCache = refreshCache
+Shared.copyToBuf = copyToBuf
+
+-- True when `c` itself is a delta codec OR contains one in its tree.
+function Shared.containsDelta(c: Types.InternalCodec<any>): boolean
+    return c._isDelta == true or c._hasDelta == true
+end
+
+-- Common bounds check for variable-length container codecs.
+function Shared.enforceMaxCount(len: number, maxCount: number?, label: string?): ()
+    if maxCount and len > maxCount then
+        Log.error(`{label or "count"} {len} exceeds max {maxCount}`)
+    end
+end
 
 function Shared.allocDeltaId(): number
     _nextDeltaId += 1
@@ -63,7 +97,9 @@ end
 --[[
     Stack-based scratch ChannelState pool. Re-entrant codec serialization
     (a codec writing into scratch that triggers another codec's scratch
-    acquire) works without aliasing.
+    acquire) works without aliasing. Full scrub on reuse so any codec that
+    reads framing fields (lastId/singleMode/itemCount/countPos) on scratch
+    sees a clean state, not stale bytes from the previous owner.
 ]]
 function Shared.acquireScratch(): Types.ChannelState
     _scratchDepth += 1
@@ -71,6 +107,15 @@ function Shared.acquireScratch(): Types.ChannelState
     if ch then
         ch.cursor = 0
         ch.refCount = 0
+        ch.lastId = -1
+        ch.countPos = -1
+        ch.itemCount = 0
+        ch.singleMode = false
+        ch.singlePos = 0
+        ch.currentPacket = nil
+        if next(ch.deltas) ~= nil then
+            table.clear(ch.deltas)
+        end
         return ch
     end
     ch = Channel.create()
@@ -82,6 +127,26 @@ function Shared.releaseScratch(): ()
     _scratchDepth -= 1
 end
 
+--[[
+    Reset module-private state. Called by Sandbox in tests so that a thrown
+    codec.write (which skips releaseScratch and leaves depth inflated) can't
+    leak into the next test's scratch acquisition. Also resets the deltaId
+    counter so test ordering doesn't bleed.
+]]
+function Shared.reset(): ()
+    _scratchDepth = 0
+    _nextDeltaId = 0
+    for i = 1, #_scratchStack do
+        local ch = _scratchStack[i]
+        ch.cursor = 0
+        ch.refCount = 0
+        if ch.refCount > 0 then
+            table.clear(ch.refs)
+        end
+        table.clear(ch.deltas)
+    end
+end
+
 --[[
     Split a struct schema into (dataKeys, dataCodecs, boolKeys), each sorted
     alphabetically for deterministic wire layout.
@@ -117,25 +182,27 @@ function Shared.extractFields(
     return dataKeys, dataCodecs, boolKeys
 end
 
+-- `byteCount` is `(boolCount + 7) // 8`; callers with it cached pass it through.
 function Shared.packBools(
     ch: Types.ChannelState,
     value: { [string]: any },
     boolKeys: { string },
-    boolCount: number
+    boolCount: number,
+    byteCount: number?
 ): ()
     if boolCount == 0 then
         return
     end
 
-    local byteCount = (boolCount + 7) // 8
+    local bc = byteCount or (boolCount + 7) // 8
     local cursor = ch.cursor
-    if cursor + byteCount > ch.size then
-        alloc(ch, byteCount)
+    if cursor + bc > ch.size then
+        alloc(ch, bc)
     end
 
     local idx = 1
     local b = ch.buff
-    for byteIdx = 0, byteCount - 1 do
+    for byteIdx = 0, bc - 1 do
         local packed = 0
         local remaining = boolCount - idx + 1
         local limit = if remaining >= 8 then 8 else remaining
@@ -148,27 +215,32 @@ function Shared.packBools(
         writeu8(b, cursor + byteIdx, packed)
     end
 
-    ch.cursor = cursor + byteCount
+    ch.cursor = cursor + bc
 end
 
 --[[
     Integer-indexed bool-array pack. Split from packBools to skip the
     per-bit string-key getter on the bool-array hot path.
 ]]
-function Shared.packBoolArray(ch: Types.ChannelState, value: { boolean }, count: number): ()
+function Shared.packBoolArray(
+    ch: Types.ChannelState,
+    value: { boolean },
+    count: number,
+    byteCount: number?
+): ()
     if count == 0 then
         return
     end
 
-    local byteCount = (count + 7) // 8
+    local bc = byteCount or (count + 7) // 8
     local cursor = ch.cursor
-    if cursor + byteCount > ch.size then
-        alloc(ch, byteCount)
+    if cursor + bc > ch.size then
+        alloc(ch, bc)
     end
 
     local idx = 1
     local b = ch.buff
-    for byteIdx = 0, byteCount - 1 do
+    for byteIdx = 0, bc - 1 do
         local packed = 0
         local remaining = count - idx + 1
         local limit = if remaining >= 8 then 8 else remaining
@@ -181,7 +253,7 @@ function Shared.packBoolArray(ch: Types.ChannelState, value: { boolean }, count:
         writeu8(b, cursor + byteIdx, packed)
     end
 
-    ch.cursor = cursor + byteCount
+    ch.cursor = cursor + bc
 end
 
 function Shared.unpackBools(
@@ -189,15 +261,16 @@ function Shared.unpackBools(
     pos: number,
     boolKeys: { string },
     boolCount: number,
-    result: { [string]: any }
+    result: { [string]: any },
+    byteCount: number?
 ): number
     if boolCount == 0 then
         return 0
     end
 
-    local byteCount = (boolCount + 7) // 8
+    local bc = byteCount or (boolCount + 7) // 8
     local idx = 1
-    for byteIdx = 0, byteCount - 1 do
+    for byteIdx = 0, bc - 1 do
         local byte = readu8(src, pos + byteIdx)
         local remaining = boolCount - idx + 1
         local limit = if remaining >= 8 then 8 else remaining
@@ -206,7 +279,7 @@ function Shared.unpackBools(
             idx += 1
         end
     end
-    return byteCount
+    return bc
 end
 
 -- Fills `result[1..count]` in place.
@@ -214,15 +287,16 @@ function Shared.unpackBoolArray(
     src: buffer,
     pos: number,
     count: number,
-    result: { boolean }
+    result: { boolean },
+    byteCount: number?
 ): number
     if count == 0 then
         return 0
     end
 
-    local byteCount = (count + 7) // 8
+    local bc = byteCount or (count + 7) // 8
     local idx = 1
-    for byteIdx = 0, byteCount - 1 do
+    for byteIdx = 0, bc - 1 do
         local byte = readu8(src, pos + byteIdx)
         local remaining = count - idx + 1
         local limit = if remaining >= 8 then 8 else remaining
@@ -231,82 +305,7 @@ function Shared.unpackBoolArray(
             idx += 1
         end
     end
-    return byteCount
-end
-
---[[
-    Build a byte-equality delta codec around any inner codec. Wire:
-      [DELTA_UNCHANGED]                       1 byte
-      [DELTA_FULL]  <inner-encoded payload>   1 + N bytes
-    Used by deltaArray and deltaMap. The FULL path encodes once into scratch
-    then bufCopies into the channel — avoids a double encode.
-]]
-function Shared.makeUnchangedOrFullDelta(
-    inner: Types.InternalCodec<any>,
-    deltaId: number,
-    Baseline: {
-        getCache: (number) -> any,
-        setCache: (number, any) -> (),
-    }
-): Types.InternalCodec<any>
-    return table.freeze({
-        _isDelta = true,
-
-        write = function(ch: Types.ChannelState, value: any): ()
-            local scratch = Shared.acquireScratch()
-            inner.write(scratch, value)
-            local scratchLen = scratch.cursor
-
-            local cache = ch.deltas[deltaId]
-            if
-                cache
-                and scratchLen == cache.len
-                and rangeEqual(scratch.buff, 0, cache.raw, 0, scratchLen)
-            then
-                local cursor = ch.cursor
-                if cursor + 1 > ch.size then
-                    alloc(ch, 1)
-                end
-                writeu8(ch.buff, cursor, DELTA_UNCHANGED)
-                ch.cursor = cursor + 1
-                Shared.releaseScratch()
-                return
-            end
-
-            local cursor = ch.cursor
-            if cursor + 1 + scratchLen > ch.size then
-                alloc(ch, 1 + scratchLen)
-            end
-            local b = ch.buff
-            writeu8(b, cursor, DELTA_FULL)
-            if scratchLen > 0 then
-                bufCopy(b, cursor + 1, scratch.buff, 0, scratchLen)
-            end
-            ch.cursor = cursor + 1 + scratchLen
-
-            local snap = snapshot(scratch.buff, scratchLen)
-            if cache then
-                cache.raw = snap
-                cache.len = scratchLen
-            else
-                ch.deltas[deltaId] = { raw = snap, len = scratchLen }
-            end
-            Shared.releaseScratch()
-        end,
-
-        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
-            if readu8(src, pos) == DELTA_UNCHANGED then
-                local cached = Baseline.getCache(deltaId)
-                if not cached then
-                    Log.error("UNCHANGED flag before any FULL frame; baseline missing")
-                end
-                return cached, 1
-            end
-            local value, consumed = inner.read(src, pos + 1, refs)
-            Baseline.setCache(deltaId, value)
-            return value, 1 + consumed
-        end,
-    })
+    return bc
 end
 
 return table.freeze(Shared)

package/src/codec/composite/Struct.luau

@@ -55,6 +55,7 @@ local packBools = Shared.packBools
 local unpackBools = Shared.unpackBools
 local rangeEqual = Shared.rangeEqual
 local snapshot = Shared.snapshot
+local refreshCache = Shared.refreshCache
 local acquireScratch = Shared.acquireScratch
 local releaseScratch = Shared.releaseScratch
 local allocDeltaId = Shared.allocDeltaId
@@ -89,14 +90,18 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
     local boolCount = #boolKeys
     local boolBytes = Shared.boolBytes(boolCount)
 
-    -- Single pass: detect all-direct fast-write path + propagate _hasUnknown.
+    -- Single pass: detect all-direct fast-write path + propagate _hasUnknown / _hasDelta.
     local allDirect, fixedSize = true, 0
     local hasUnknown = false
+    local hasDelta = false
     for i = 1, dataCount do
         local c = dataCodecs[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
                 fixedSize += c._size
@@ -160,7 +165,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                     result[dataKeys[i]] = directReads[i](b, off + offsets[i])
                 end
                 if boolCount > 0 then
-                    unpackBools(b, off + fixedSize, boolKeys, boolCount, result)
+                    unpackBools(b, off + fixedSize, boolKeys, boolCount, result, boolBytes)
                 end
                 return result
             end,
@@ -176,7 +181,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                 end
                 ch.cursor = cursor + fixedSize
                 if boolCount > 0 then
-                    packBools(ch, value, boolKeys, boolCount)
+                    packBools(ch, value, boolKeys, boolCount, boolBytes)
                 end
             end,
 
@@ -186,7 +191,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                     result[dataKeys[i]] = directReads[i](src, pos + offsets[i])
                 end
                 if boolCount > 0 then
-                    unpackBools(src, pos + fixedSize, boolKeys, boolCount, result)
+                    unpackBools(src, pos + fixedSize, boolKeys, boolCount, result, boolBytes)
                 end
                 return result, totalFixed
             end,
@@ -194,6 +199,9 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
         if hasUnknown then
             codec._hasUnknown = true
         end
+        if hasDelta then
+            codec._hasDelta = true
+        end
         return table.freeze(codec)
     end
 
@@ -205,7 +213,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                 dataCodecs[i].write(ch, value[dataKeys[i]])
             end
             if boolCount > 0 then
-                packBools(ch, value, boolKeys, boolCount)
+                packBools(ch, value, boolKeys, boolCount, boolBytes)
             end
         end,
 
@@ -218,7 +226,7 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
                 total += consumed
             end
             if boolCount > 0 then
-                total += unpackBools(src, pos + total, boolKeys, boolCount, result)
+                total += unpackBools(src, pos + total, boolKeys, boolCount, result, boolBytes)
             end
             return result, total
         end,
@@ -226,6 +234,9 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
     if hasUnknown then
         codec._hasUnknown = true
     end
+    if hasDelta then
+        codec._hasDelta = true
+    end
     return table.freeze(codec)
 end
 
@@ -305,7 +316,7 @@ function Struct.deltaStruct(
         refs: { Instance }?
     ): number
         if hasBoolSeg and segIdx == boolSegIdx then
-            return unpackBools(src, pos, boolKeys, boolCount, target)
+            return unpackBools(src, pos, boolKeys, boolCount, target, boolBytes)
         end
         local v, consumed = dataCodecs[segIdx].read(src, pos, refs)
         target[dataKeys[segIdx]] = v
@@ -350,7 +361,7 @@ function Struct.deltaStruct(
                     prev = cur
                 end
                 if hasBoolSeg then
-                    packBools(scratch, value, boolKeys, boolCount)
+                    packBools(scratch, value, boolKeys, boolCount, boolBytes)
                     segOff[boolSegIdx] = prev
                     segLen[boolSegIdx] = scratch.cursor - prev
                 end
@@ -421,8 +432,7 @@ function Struct.deltaStruct(
                 end
             end
 
-            cache.raw = snapshot(scratch.buff, scratchLen)
-            cache.len = scratchLen;
+            refreshCache(cache, scratch.buff, scratchLen);
             (cache :: any).segOff = segOff;
             (cache :: any).segLen = segLen
             releaseScratch()

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>