@axpecter/lync 1.4.0 → 1.4.1

package/src/codec/meta/Auto.luau

@@ -2,29 +2,32 @@
 --!native
 -- Auto (self-describing) codec. Writes a u8 type tag then the value.
 
-local Buffer = require (script.Parent.Parent.datatype.Buffer)
+local BoolCodec = require (script.Parent.Parent.primitive.Bool)
+local BufferCodec = require (script.Parent.Parent.datatype.Buffer)
 local CFrameCodec = require (script.Parent.Parent.datatype.CFrame)
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
-local BoolCodec = require (script.Parent.Parent.primitive.Bool)
-local Color = require (script.Parent.Parent.datatype.Color)
-local IntVector = require (script.Parent.Parent.datatype.IntVector)
-local Number = require (script.Parent.Parent.primitive.Number)
+local ColorCodec = require (script.Parent.Parent.datatype.Color)
+local IntVectorCodec = require (script.Parent.Parent.datatype.IntVector)
+local NumberCodec = require (script.Parent.Parent.primitive.Number)
 local NumberRangeCodec = require (script.Parent.Parent.datatype.NumberRange)
 local RayCodec = require (script.Parent.Parent.datatype.Ray)
 local RectCodec = require (script.Parent.Parent.datatype.Rect)
-local Region = require (script.Parent.Parent.datatype.Region)
-local Sequence = require (script.Parent.Parent.datatype.Sequence)
-local String = require (script.Parent.Parent.datatype.String)
+local RegionCodec = require (script.Parent.Parent.datatype.Region)
+local SequenceCodec = require (script.Parent.Parent.datatype.Sequence)
+local StringCodec = require (script.Parent.Parent.datatype.String)
 local Types = require (script.Parent.Parent.Parent.Types)
 local UDimCodec = require (script.Parent.Parent.datatype.UDim)
 local Varint = require (script.Parent.Parent.primitive.Varint)
-local Vector = require (script.Parent.Parent.datatype.Vector)
+local VectorCodec = require (script.Parent.Parent.datatype.Vector)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
+type InternalCodec<T> = Types.InternalCodec<T>
+
+local alloc = Channel.alloc
+local floor = math.floor
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local TAG_NIL = 0
 local TAG_BOOL = 1
@@ -54,128 +57,130 @@ local TAG_RAY = 24
 local TAG_NUMBERSEQUENCE = 25
 local TAG_COLORSEQUENCE = 26
 
-local floor = math.floor
-
 local READ_DISPATCH = table.freeze ({
     [TAG_BOOL] = BoolCodec.bool,
-    [TAG_U8] = Number.u8,
-    [TAG_U16] = Number.u16,
-    [TAG_U32] = Number.u32,
-    [TAG_I8] = Number.i8,
-    [TAG_I16] = Number.i16,
-    [TAG_I32] = Number.i32,
-    [TAG_F32] = Number.f32,
-    [TAG_F64] = Number.f64,
-    [TAG_STRING] = String.string,
-    [TAG_VEC2] = Vector.vec2,
-    [TAG_VEC3] = Vector.vec3,
-    [TAG_COLOR3] = Color.color3,
+    [TAG_U8] = NumberCodec.u8,
+    [TAG_U16] = NumberCodec.u16,
+    [TAG_U32] = NumberCodec.u32,
+    [TAG_I8] = NumberCodec.i8,
+    [TAG_I16] = NumberCodec.i16,
+    [TAG_I32] = NumberCodec.i32,
+    [TAG_F32] = NumberCodec.f32,
+    [TAG_F64] = NumberCodec.f64,
+    [TAG_STRING] = StringCodec.string,
+    [TAG_VEC2] = VectorCodec.vec2,
+    [TAG_VEC3] = VectorCodec.vec3,
+    [TAG_COLOR3] = ColorCodec.color3,
     [TAG_CFRAME] = CFrameCodec.cframe,
-    [TAG_BUFFER] = Buffer.buff,
+    [TAG_BUFFER] = BufferCodec.buff,
     [TAG_UDIM] = UDimCodec.udim,
     [TAG_UDIM2] = UDimCodec.udim2,
     [TAG_NUMBERRANGE] = NumberRangeCodec.numberRange,
     [TAG_RECT] = RectCodec.rect,
-    [TAG_VEC2INT16] = IntVector.vec2int16,
-    [TAG_VEC3INT16] = IntVector.vec3int16,
-    [TAG_REGION3] = Region.region3,
-    [TAG_REGION3INT16] = Region.region3int16,
+    [TAG_VEC2INT16] = IntVectorCodec.vec2int16,
+    [TAG_VEC3INT16] = IntVectorCodec.vec3int16,
+    [TAG_REGION3] = RegionCodec.region3,
+    [TAG_REGION3INT16] = RegionCodec.region3int16,
     [TAG_RAY] = RayCodec.ray,
-    [TAG_NUMBERSEQUENCE] = Sequence.numberSequence,
-    [TAG_COLORSEQUENCE] = Sequence.colorSequence,
+    [TAG_NUMBERSEQUENCE] = SequenceCodec.numberSequence,
+    [TAG_COLORSEQUENCE] = SequenceCodec.colorSequence,
 })
 
+local function extractDw (codec: any): any
+    return (codec :: InternalCodec<any>)._directWrite
+end
+
 local TYPE_DISPATCH = table.freeze ({
     boolean = { tag = TAG_BOOL, codec = BoolCodec.bool, size = 1, dw = nil },
-    string = { tag = TAG_STRING, codec = String.string, size = nil, dw = nil },
+    string = { tag = TAG_STRING, codec = StringCodec.string, size = nil, dw = nil },
+    buffer = { tag = TAG_BUFFER, codec = BufferCodec.buff, size = nil, dw = nil },
     Vector2 = {
         tag = TAG_VEC2,
-        codec = Vector.vec2,
+        codec = VectorCodec.vec2,
         size = 8,
-        dw = (Vector.vec2 :: any)._directWrite,
+        dw = extractDw (VectorCodec.vec2),
     },
     Vector3 = {
         tag = TAG_VEC3,
-        codec = Vector.vec3,
+        codec = VectorCodec.vec3,
         size = 12,
-        dw = (Vector.vec3 :: any)._directWrite,
+        dw = extractDw (VectorCodec.vec3),
     },
     Color3 = {
         tag = TAG_COLOR3,
-        codec = Color.color3,
+        codec = ColorCodec.color3,
         size = 3,
-        dw = (Color.color3 :: any)._directWrite,
+        dw = extractDw (ColorCodec.color3),
     },
     CFrame = {
         tag = TAG_CFRAME,
         codec = CFrameCodec.cframe,
         size = 24,
-        dw = (CFrameCodec.cframe :: any)._directWrite,
+        dw = extractDw (CFrameCodec.cframe),
     },
-    buffer = { tag = TAG_BUFFER, codec = Buffer.buff, size = nil, dw = nil },
     UDim = {
         tag = TAG_UDIM,
         codec = UDimCodec.udim,
         size = 8,
-        dw = (UDimCodec.udim :: any)._directWrite,
+        dw = extractDw (UDimCodec.udim),
     },
     UDim2 = {
         tag = TAG_UDIM2,
         codec = UDimCodec.udim2,
         size = 16,
-        dw = (UDimCodec.udim2 :: any)._directWrite,
+        dw = extractDw (UDimCodec.udim2),
     },
     NumberRange = {
         tag = TAG_NUMBERRANGE,
         codec = NumberRangeCodec.numberRange,
         size = 8,
-        dw = (NumberRangeCodec.numberRange :: any)._directWrite,
+        dw = extractDw (NumberRangeCodec.numberRange),
     },
     Rect = {
         tag = TAG_RECT,
         codec = RectCodec.rect,
         size = 16,
-        dw = (RectCodec.rect :: any)._directWrite,
+        dw = extractDw (RectCodec.rect),
     },
     Vector2int16 = {
         tag = TAG_VEC2INT16,
-        codec = IntVector.vec2int16,
+        codec = IntVectorCodec.vec2int16,
         size = 4,
-        dw = (IntVector.vec2int16 :: any)._directWrite,
+        dw = extractDw (IntVectorCodec.vec2int16),
     },
     Vector3int16 = {
         tag = TAG_VEC3INT16,
-        codec = IntVector.vec3int16,
+        codec = IntVectorCodec.vec3int16,
         size = 6,
-        dw = (IntVector.vec3int16 :: any)._directWrite,
+        dw = extractDw (IntVectorCodec.vec3int16),
     },
     Region3 = {
         tag = TAG_REGION3,
-        codec = Region.region3,
+        codec = RegionCodec.region3,
         size = 24,
-        dw = (Region.region3 :: any)._directWrite,
+        dw = extractDw (RegionCodec.region3),
     },
     Region3int16 = {
         tag = TAG_REGION3INT16,
-        codec = Region.region3int16,
+        codec = RegionCodec.region3int16,
         size = 12,
-        dw = (Region.region3int16 :: any)._directWrite,
+        dw = extractDw (RegionCodec.region3int16),
     },
     Ray = {
         tag = TAG_RAY,
         codec = RayCodec.ray,
         size = 24,
-        dw = (RayCodec.ray :: any)._directWrite,
+        dw = extractDw (RayCodec.ray),
     },
     NumberSequence = {
         tag = TAG_NUMBERSEQUENCE,
-        codec = Sequence.numberSequence,
+        codec = SequenceCodec.numberSequence,
         size = nil,
         dw = nil,
     },
     ColorSequence = {
         tag = TAG_COLORSEQUENCE,
-        codec = Sequence.colorSequence,
+        codec = SequenceCodec.colorSequence,
         size = nil,
         dw = nil,
     },
@@ -187,24 +192,24 @@ local NUM_DWRITES = {} :: { [number]: any }
 
 for _, pair in
     {
-        { TAG_U8, Number.u8, 1 },
-        { TAG_U16, Number.u16, 2 },
-        { TAG_U32, Number.u32, 4 },
-        { TAG_I8, Number.i8, 1 },
-        { TAG_I16, Number.i16, 2 },
-        { TAG_I32, Number.i32, 4 },
-        { TAG_F32, Number.f32, 4 },
-        { TAG_F64, Number.f64, 8 },
+        { TAG_U8, NumberCodec.u8, 1 },
+        { TAG_U16, NumberCodec.u16, 2 },
+        { TAG_U32, NumberCodec.u32, 4 },
+        { TAG_I8, NumberCodec.i8, 1 },
+        { TAG_I16, NumberCodec.i16, 2 },
+        { TAG_I32, NumberCodec.i32, 4 },
+        { TAG_F32, NumberCodec.f32, 4 },
+        { TAG_F64, NumberCodec.f64, 8 },
     }
 do
     NUM_SIZES[pair[1]] = pair[3]
-    NUM_DWRITES[pair[1]] = (pair[2] :: any)._directWrite
+    NUM_DWRITES[pair[1]] = (pair[2] :: InternalCodec<number>)._directWrite
 end
 
 table.freeze (NUM_SIZES)
 table.freeze (NUM_DWRITES)
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local _f32Temp = buffer.create (4)
 
@@ -246,7 +251,7 @@ local function selectNumberTag (value: number): number
     return TAG_F64
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local auto = table.freeze ({
     write = function (ch: ChannelState, value: any): ()
@@ -312,17 +317,17 @@ local auto = table.freeze ({
             error (`[Lync] Auto unsupported type: {valueType}`)
         end
 
-        local dw = entry.dw
-        local size = entry.size
-        if dw and size then
-            local totalSize = 1 + size
+        local entryDw = entry.dw
+        local entrySize = entry.size
+        if entryDw and entrySize then
+            local totalSize = 1 + entrySize
             local c = ch.cursor
             if c + totalSize > ch.size then
                 alloc (ch, totalSize)
             end
             local b = ch.buff
             buffer.writeu8 (b, c, entry.tag)
-            dw (b, c + 1, value)
+            entryDw (b, c + 1, value)
             ch.cursor = c + totalSize
         else
             local c = ch.cursor

package/src/codec/meta/Bitfield.luau

@@ -3,20 +3,21 @@
 -- Pack booleans, unsigned and signed integers at the bit level.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- Constants --------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Constants ----------------------------------------------------------
 
 local band = bit32.band
 local bor = bit32.bor
 local lshift = bit32.lshift
 local rshift = bit32.rshift
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 type FieldSpec = {
     type: "bool" | "uint" | "int",
@@ -36,7 +37,7 @@ local function selectIO (bytes: number): ((b: buffer, offset: number, v: number)
     return buffer.writeu32, buffer.readu32
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Bitfield = {}
 

package/src/codec/meta/Enum.luau

@@ -3,13 +3,14 @@
 -- String enum codec. Maps values to u8 indices at definition time.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- Public -----------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Public -------------------------------------------------------------
 
 local EnumCodec = {}
 
@@ -28,7 +29,7 @@ function EnumCodec.define (...: string): Codec<string>
 
     for i, value in values do
         if toIndex[value] ~= nil then
-            error (`[Lync] Duplicate enum value: \"{value}\"`)
+            error (`[Lync] Duplicate enum value: "{value}"`)
         end
         toIndex[value] = i - 1
         toValue[i] = value
@@ -42,7 +43,7 @@ function EnumCodec.define (...: string): Codec<string>
         _directWrite = function (b: buffer, offset: number, value: string): ()
             local idx = toIndex[value]
             if idx == nil then
-                error (`[Lync] Invalid enum value: \"{value}\"`)
+                error (`[Lync] Invalid enum value: "{value}"`)
             end
             buffer.writeu8 (b, offset, idx)
         end,
@@ -57,7 +58,7 @@ function EnumCodec.define (...: string): Codec<string>
         write = function (ch: ChannelState, value: string): ()
             local idx = toIndex[value]
             if idx == nil then
-                error (`[Lync] Invalid enum value: \"{value}\"`)
+                error (`[Lync] Invalid enum value: "{value}"`)
             end
             local c = ch.cursor
             if c + 1 > ch.size then

package/src/codec/meta/Quantized.luau

@@ -3,13 +3,14 @@
 -- Fixed-point compression. Maps float ranges to integer ranges.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- Constants --------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Constants ----------------------------------------------------------
 
 local clamp = math.clamp
 local round = math.round
@@ -19,7 +20,7 @@ local max = math.max
 
 local U32_MAX = 4294967295
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function selectIO (bytes: number): ((b: buffer, offset: number, v: number) -> (), (
     b: buffer,
@@ -44,7 +45,7 @@ local function selectWidth (maxInt: number): number
     return 4
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Quantized = {}
 

package/src/codec/meta/Unknown.luau

@@ -3,11 +3,15 @@
 -- Sidecar codec. Bypasses buffer serialization, uses Roblox remote refs.
 
 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
 
 return table.freeze ({
     unknown = table.freeze ({
-        write = function (ch: any, value: any): ()
+        write = function (ch: ChannelState, value: any): ()
             local refs = ch.refs
             local idx = #refs + 1
             if idx > 65535 then

package/src/codec/primitive/Float16.luau

@@ -3,12 +3,13 @@
 -- Half-precision float codec. 2 bytes, ±65504, ~3 decimal digits.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
+local alloc = Channel.alloc
+
 type ChannelState = Types.ChannelState
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local MAX_HALF = 65504
 local BIAS = 15
@@ -28,7 +29,7 @@ local ldexp = math.ldexp
 local round = math.round
 local huge = math.huge
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function encode (value: number): number
     if value ~= value then
@@ -83,7 +84,7 @@ local function decode (packed: number): number
     return if band (packed, SIGN_BIT) ~= 0 then -result else result
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Float16 = {}
 

package/src/codec/primitive/Varint.luau

@@ -9,7 +9,7 @@ type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local CONT = 0x80
 local MASK = 0x7F
@@ -21,7 +21,7 @@ local bor = bit32.bor
 local rshift = bit32.rshift
 local lshift = bit32.lshift
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Varint = {}
 

package/src/init.luau

@@ -7,22 +7,22 @@ local RunService = game:GetService ("RunService")
 -- Codec: primitive
 local BoolCodec = require (script.codec.primitive.Bool)
 local Float16 = require (script.codec.primitive.Float16)
-local Number = require (script.codec.primitive.Number)
+local NumberCodec = require (script.codec.primitive.Number)
 
 -- Codec: datatype
-local Buffer = require (script.codec.datatype.Buffer)
+local BufferCodec = require (script.codec.datatype.Buffer)
 local CFrameCodec = require (script.codec.datatype.CFrame)
-local Color = require (script.codec.datatype.Color)
+local ColorCodec = require (script.codec.datatype.Color)
 local InstanceCodec = require (script.codec.datatype.Instance)
-local IntVector = require (script.codec.datatype.IntVector)
+local IntVectorCodec = require (script.codec.datatype.IntVector)
 local NumberRangeCodec = require (script.codec.datatype.NumberRange)
 local RayCodec = require (script.codec.datatype.Ray)
 local RectCodec = require (script.codec.datatype.Rect)
-local Region = require (script.codec.datatype.Region)
-local Sequence = require (script.codec.datatype.Sequence)
-local String = require (script.codec.datatype.String)
+local RegionCodec = require (script.codec.datatype.Region)
+local SequenceCodec = require (script.codec.datatype.Sequence)
+local StringCodec = require (script.codec.datatype.String)
 local UDimCodec = require (script.codec.datatype.UDim)
-local Vector = require (script.codec.datatype.Vector)
+local VectorCodec = require (script.codec.datatype.Vector)
 
 -- Codec: composite
 local Array = require (script.codec.composite.Array)
@@ -43,10 +43,14 @@ local Unknown = require (script.codec.meta.Unknown)
 
 -- Internal
 local Channel = require (script.internal.Channel)
-local Gate = require (script.transport.Gate)
 local Middleware = require (script.internal.Middleware)
 local Pool = require (script.internal.Pool)
 
+-- Transport
+local Client = require (script.transport.Client)
+local Gate = require (script.transport.Gate)
+local Server = require (script.transport.Server)
+
 -- API
 local Group = require (script.api.Group)
 local Namespace = require (script.api.Namespace)
@@ -54,14 +58,12 @@ local Packet = require (script.api.Packet)
 local Query = require (script.api.Query)
 local Scope = require (script.api.Scope)
 
--- Transport
-local Client = require (script.transport.Client)
-local Server = require (script.transport.Server)
-
--- Sentinels --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local ALL = table.freeze ({ _tag = "all" })
 
+-- Private ------------------------------------------------------------
+
 local function except (...: any): any
     local count = select ("#", ...)
     local set = {} :: { [Player]: true }
@@ -71,8 +73,6 @@ local function except (...: any): any
     return { _tag = "except", _set = set }
 end
 
--- Public -----------------------------------------------------------------
-
 local function start (): ()
     if RunService:IsServer () then
         Server.start ()
@@ -81,8 +81,10 @@ local function start (): ()
     end
 end
 
+-- Public -------------------------------------------------------------
+
 local Lync = {
-    VERSION = "1.4.0",
+    VERSION = "1.4.1",
 
     -- Lifecycle
     start = start,
@@ -93,37 +95,37 @@ local Lync = {
     defineNamespace = Namespace.define,
 
     -- Primitives
-    u8 = Number.u8,
-    u16 = Number.u16,
-    u32 = Number.u32,
-    i8 = Number.i8,
-    i16 = Number.i16,
-    i32 = Number.i32,
-    f32 = Number.f32,
-    f64 = Number.f64,
+    u8 = NumberCodec.u8,
+    u16 = NumberCodec.u16,
+    u32 = NumberCodec.u32,
+    i8 = NumberCodec.i8,
+    i16 = NumberCodec.i16,
+    i32 = NumberCodec.i32,
+    f32 = NumberCodec.f32,
+    f64 = NumberCodec.f64,
     bool = BoolCodec.bool,
     f16 = Float16.f16,
 
     -- Datatypes
-    string = String.string,
-    boundedString = String.bounded,
-    vec2 = Vector.vec2,
-    vec3 = Vector.vec3,
+    string = StringCodec.string,
+    boundedString = StringCodec.bounded,
+    vec2 = VectorCodec.vec2,
+    vec3 = VectorCodec.vec3,
     cframe = CFrameCodec.cframe,
-    color3 = Color.color3,
+    color3 = ColorCodec.color3,
     inst = InstanceCodec.inst,
-    buff = Buffer.buff,
+    buff = BufferCodec.buff,
     udim = UDimCodec.udim,
     udim2 = UDimCodec.udim2,
     numberRange = NumberRangeCodec.numberRange,
     rect = RectCodec.rect,
-    vec2int16 = IntVector.vec2int16,
-    vec3int16 = IntVector.vec3int16,
-    region3 = Region.region3,
-    region3int16 = Region.region3int16,
+    vec2int16 = IntVectorCodec.vec2int16,
+    vec3int16 = IntVectorCodec.vec3int16,
+    region3 = RegionCodec.region3,
+    region3int16 = RegionCodec.region3int16,
     ray = RayCodec.ray,
-    numberSequence = Sequence.numberSequence,
-    colorSequence = Sequence.colorSequence,
+    numberSequence = SequenceCodec.numberSequence,
+    colorSequence = SequenceCodec.colorSequence,
 
     -- Composites
     struct = Struct.struct,

package/src/internal/Baseline.luau

@@ -2,15 +2,18 @@
 --!optimize 2
 -- Read-side baseline cache keyed by source (player or client sentinel).
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _readKey = false :: any
 local _readCaches = {} :: { [any]: { [number]: any } }
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Baseline = {}
 
+-- One-way latch: set to true on first delta write, never reset. This
+-- avoids a setReadKey call on every non-delta frame at the cost of a
+-- cheap branch once deltas are first used in the session.
 Baseline.hasDelta = false
 
 function Baseline.setReadKey (key: any): ()
@@ -38,4 +41,5 @@ function Baseline.clearSource (key: any): ()
     _readCaches[key] = nil
 end
 
+-- Not frozen: hasDelta is mutated at runtime by setCache.
 return Baseline