@splitsoftware/splitio-commons 2.10.2-rc.4 → 2.10.2-rc.5

package/CHANGES.txt

@@ -1,6 +1,6 @@
 2.11.0 (January XX, 2026)
  - Added metadata to SDK_UPDATE events to indicate the type of update (FLAGS_UPDATE or SEGMENTS_UPDATE) and the names of updated flags or segments.
- - Added metadata to SDK_READY and SDK_READY_FROM_CACHE events, including `initialCacheLoad` (boolean indicating if SDK was loaded from cache) and `lastUpdateTimestamp` (Int64 milliseconds since epoch).
+ - Added metadata to SDK_READY and SDK_READY_FROM_CACHE events, including `initialCacheLoad` (boolean: `true` for fresh install/first app launch, `false` for warm cache/second app launch) and `lastUpdateTimestamp` (Int64 milliseconds since epoch).
 
 2.10.1 (December 18, 2025)
  - Bugfix - Handle `null` prerequisites properly.

package/cjs/readiness/readinessManager.js

@@ -41,6 +41,7 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
     }
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;
+    var cacheLastUpdateTimestamp = null;
     if (splits.splitsCacheLoaded)
         isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
     else
@@ -68,17 +69,17 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
     splits.initCallbacks.push(__init);
     if (splits.hasInit)
         __init();
-    function checkIsReadyFromCache() {
+    function checkIsReadyFromCache(cacheMetadata) {
         isReadyFromCache = true;
+        cacheLastUpdateTimestamp = cacheMetadata.lastUpdateTimestamp;
         // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
         if (!isReady && !isDestroyed) {
             try {
                 syncLastUpdate();
-                var metadata = {
-                    initialCacheLoad: true,
-                    lastUpdateTimestamp: lastUpdate
-                };
-                gate.emit(constants_1.SDK_READY_FROM_CACHE, metadata);
+                gate.emit(constants_1.SDK_READY_FROM_CACHE, {
+                    initialCacheLoad: !cacheMetadata.isCacheValid,
+                    lastUpdateTimestamp: cacheLastUpdateTimestamp
+                });
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -104,19 +105,18 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
-                    syncLastUpdate();
                     var wasReadyFromCache = isReadyFromCache;
                     if (!isReadyFromCache) {
                         isReadyFromCache = true;
-                        var metadataFromCache = {
-                            initialCacheLoad: false,
-                            lastUpdateTimestamp: lastUpdate
+                        var metadataReadyFromCache = {
+                            initialCacheLoad: true,
+                            lastUpdateTimestamp: null // No cache timestamp when fresh install
                         };
-                        gate.emit(constants_1.SDK_READY_FROM_CACHE, metadataFromCache);
+                        gate.emit(constants_1.SDK_READY_FROM_CACHE, metadataReadyFromCache);
                     }
                     var metadataReady = {
-                        initialCacheLoad: wasReadyFromCache,
-                        lastUpdateTimestamp: lastUpdate
+                        initialCacheLoad: !wasReadyFromCache,
+                        lastUpdateTimestamp: wasReadyFromCache ? cacheLastUpdateTimestamp : null
                     };
                     gate.emit(constants_1.SDK_READY, metadataReady);
                 }

package/cjs/sdkFactory/index.js

@@ -46,17 +46,17 @@ function sdkFactory(params) {
                 return;
             }
             readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
-            readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+            readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { isCacheValid: true, lastUpdateTimestamp: null });
         },
         onReadyFromCacheCb: function () {
-            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
         }
     });
     var fallbackTreatmentsCalculator = new fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, storage, key && (0, key_1.getMatching)(key));
         if (storage.splits.getChangeNumber() > -1)
-            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
     }
     var clients = {};
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);

package/cjs/storages/inLocalStorage/index.js

@@ -60,7 +60,10 @@ function InLocalStorage(options) {
             telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCachePromise || (validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
+                if (!validateCachePromise) {
+                    validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
+                }
+                return validateCachePromise;
             },
             save: function () {
                 return storage.save && storage.save();

package/cjs/storages/inLocalStorage/validateCache.js

@@ -55,12 +55,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
  * - `clearOnInit` was set and cache was not cleared in the last 24 hours
  *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
+ * @returns Metadata object with `isCacheValid` (true if cache is ready to be used, false otherwise) and `lastUpdateTimestamp` (timestamp of last cache update or null)
  */
 function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
     return Promise.resolve(storage.load && storage.load()).then(function () {
         var currentTimestamp = Date.now();
         var isThereCache = splits.getChangeNumber() > -1;
+        // Get lastUpdateTimestamp from storage
+        var lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
+        var lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : null;
+        var lastUpdateTimestamp = (!(0, lang_1.isNaNNumber)(lastUpdatedTimestamp) && lastUpdatedTimestamp !== null) ? lastUpdatedTimestamp : null;
         if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
             splits.clear();
             rbSegments.clear();
@@ -76,10 +80,16 @@ function validateCache(options, storage, settings, keys, splits, rbSegments, seg
             // Persist clear
             if (storage.save)
                 storage.save();
-            return false;
+            return {
+                isCacheValid: false,
+                lastUpdateTimestamp: null
+            };
         }
         // Check if ready from cache
-        return isThereCache;
+        return {
+            isCacheValid: isThereCache,
+            lastUpdateTimestamp: lastUpdateTimestamp
+        };
     });
 }
 exports.validateCache = validateCache;

package/cjs/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -45,10 +45,11 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED, { type: constants_2.FLAGS_UPDATE, names: [] });
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then(function (cacheMetadata) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+                        if (cacheMetadata.isCacheValid) {
+                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                        }
                         // Emits SDK_READY
                         readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { type: constants_2.SEGMENTS_UPDATE, names: [] });
                     });

package/cjs/sync/syncManagerOnline.js

@@ -71,13 +71,14 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 running = true;
                 // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
                 submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
-                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                return Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then(function (cacheMetadata) {
                     if (!running)
                         return;
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED);
+                        if (cacheMetadata.isCacheValid) {
+                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                        }
                     }
                     // start syncing splits and segments
                     if (pollingManager) {

package/cjs/utils/settingsValidation/storage/storageCS.js

@@ -6,7 +6,7 @@ var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
 function __InLocalStorageMockFactory(params) {
     var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
-    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return Promise.resolve({ isCacheValid: true, lastUpdateTimestamp: null }); }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;

package/esm/readiness/readinessManager.js

@@ -38,6 +38,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
     }
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;
+    var cacheLastUpdateTimestamp = null;
     if (splits.splitsCacheLoaded)
         isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
     else
@@ -65,17 +66,17 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
     splits.initCallbacks.push(__init);
     if (splits.hasInit)
         __init();
-    function checkIsReadyFromCache() {
+    function checkIsReadyFromCache(cacheMetadata) {
         isReadyFromCache = true;
+        cacheLastUpdateTimestamp = cacheMetadata.lastUpdateTimestamp;
         // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
         if (!isReady && !isDestroyed) {
             try {
                 syncLastUpdate();
-                var metadata = {
-                    initialCacheLoad: true,
-                    lastUpdateTimestamp: lastUpdate
-                };
-                gate.emit(SDK_READY_FROM_CACHE, metadata);
+                gate.emit(SDK_READY_FROM_CACHE, {
+                    initialCacheLoad: !cacheMetadata.isCacheValid,
+                    lastUpdateTimestamp: cacheLastUpdateTimestamp
+                });
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -101,19 +102,18 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
-                    syncLastUpdate();
                     var wasReadyFromCache = isReadyFromCache;
                     if (!isReadyFromCache) {
                         isReadyFromCache = true;
-                        var metadataFromCache = {
-                            initialCacheLoad: false,
-                            lastUpdateTimestamp: lastUpdate
+                        var metadataReadyFromCache = {
+                            initialCacheLoad: true,
+                            lastUpdateTimestamp: null // No cache timestamp when fresh install
                         };
-                        gate.emit(SDK_READY_FROM_CACHE, metadataFromCache);
+                        gate.emit(SDK_READY_FROM_CACHE, metadataReadyFromCache);
                     }
                     var metadataReady = {
-                        initialCacheLoad: wasReadyFromCache,
-                        lastUpdateTimestamp: lastUpdate
+                        initialCacheLoad: !wasReadyFromCache,
+                        lastUpdateTimestamp: wasReadyFromCache ? cacheLastUpdateTimestamp : null
                     };
                     gate.emit(SDK_READY, metadataReady);
                 }

package/esm/sdkFactory/index.js

@@ -43,17 +43,17 @@ export function sdkFactory(params) {
                 return;
             }
             readiness.splits.emit(SDK_SPLITS_ARRIVED);
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { isCacheValid: true, lastUpdateTimestamp: null });
         },
         onReadyFromCacheCb: function () {
-            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
         }
     });
     var fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
         if (storage.splits.getChangeNumber() > -1)
-            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
     }
     var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);

package/esm/storages/inLocalStorage/index.js

@@ -57,7 +57,10 @@ export function InLocalStorage(options) {
             telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
+                if (!validateCachePromise) {
+                    validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
+                }
+                return validateCachePromise;
             },
             save: function () {
                 return storage.save && storage.save();

package/esm/storages/inLocalStorage/validateCache.js

@@ -52,12 +52,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
  * - `clearOnInit` was set and cache was not cleared in the last 24 hours
  *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
+ * @returns Metadata object with `isCacheValid` (true if cache is ready to be used, false otherwise) and `lastUpdateTimestamp` (timestamp of last cache update or null)
  */
 export function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
     return Promise.resolve(storage.load && storage.load()).then(function () {
         var currentTimestamp = Date.now();
         var isThereCache = splits.getChangeNumber() > -1;
+        // Get lastUpdateTimestamp from storage
+        var lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
+        var lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : null;
+        var lastUpdateTimestamp = (!isNaNNumber(lastUpdatedTimestamp) && lastUpdatedTimestamp !== null) ? lastUpdatedTimestamp : null;
         if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
             splits.clear();
             rbSegments.clear();
@@ -73,9 +77,15 @@ export function validateCache(options, storage, settings, keys, splits, rbSegmen
             // Persist clear
             if (storage.save)
                 storage.save();
-            return false;
+            return {
+                isCacheValid: false,
+                lastUpdateTimestamp: null
+            };
         }
         // Check if ready from cache
-        return isThereCache;
+        return {
+            isCacheValid: isThereCache,
+            lastUpdateTimestamp: lastUpdateTimestamp
+        };
     });
 }

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -42,10 +42,11 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then(function (cacheMetadata) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                        if (cacheMetadata.isCacheValid) {
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                        }
                         // Emits SDK_READY
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
                     });

package/esm/sync/syncManagerOnline.js

@@ -68,13 +68,14 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 running = true;
                 // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
                 submitterManager.start(!isConsentGranted(settings));
-                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                return Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then(function (cacheMetadata) {
                     if (!running)
                         return;
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                        if (cacheMetadata.isCacheValid) {
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                        }
                     }
                     // start syncing splits and segments
                     if (pollingManager) {

package/esm/utils/settingsValidation/storage/storageCS.js

@@ -3,7 +3,7 @@ import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
 export function __InLocalStorageMockFactory(params) {
     var result = InMemoryStorageCSFactory(params);
-    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return Promise.resolve({ isCacheValid: true, lastUpdateTimestamp: null }); }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.10.2-rc.4",
+  "version": "2.10.2-rc.5",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/readiness/readinessManager.ts

@@ -3,6 +3,7 @@ import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
+import { CacheValidationMetadata } from '../storages/inLocalStorage/validateCache';
 
 function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISplitsEventEmitter {
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
@@ -55,6 +56,7 @@ export function readinessManagerFactory(
 
   // emit SDK_READY_FROM_CACHE
   let isReadyFromCache = false;
+  let cacheLastUpdateTimestamp: number | null = null;
   if (splits.splitsCacheLoaded) isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
   else splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
 
@@ -84,17 +86,17 @@ export function readinessManagerFactory(
   splits.initCallbacks.push(__init);
   if (splits.hasInit) __init();
 
-  function checkIsReadyFromCache() {
+  function checkIsReadyFromCache(cacheMetadata: CacheValidationMetadata) {
     isReadyFromCache = true;
+    cacheLastUpdateTimestamp = cacheMetadata.lastUpdateTimestamp;
     // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
     if (!isReady && !isDestroyed) {
       try {
         syncLastUpdate();
-        const metadata: SplitIO.SdkReadyMetadata = {
-          initialCacheLoad: true,
-          lastUpdateTimestamp: lastUpdate
-        };
-        gate.emit(SDK_READY_FROM_CACHE, metadata);
+        gate.emit(SDK_READY_FROM_CACHE, {
+          initialCacheLoad: !cacheMetadata.isCacheValid,
+          lastUpdateTimestamp: cacheLastUpdateTimestamp
+        });
       } catch (e) {
         // throws user callback exceptions in next tick
         setTimeout(() => { throw e; }, 0);
@@ -117,19 +119,18 @@ export function readinessManagerFactory(
         clearTimeout(readyTimeoutId);
         isReady = true;
         try {
-          syncLastUpdate();
           const wasReadyFromCache = isReadyFromCache;
           if (!isReadyFromCache) {
             isReadyFromCache = true;
-            const metadataFromCache: SplitIO.SdkReadyMetadata = {
-              initialCacheLoad: false,
-              lastUpdateTimestamp: lastUpdate
+            const metadataReadyFromCache: SplitIO.SdkReadyMetadata = {
+              initialCacheLoad: true,
+              lastUpdateTimestamp: null // No cache timestamp when fresh install
             };
-            gate.emit(SDK_READY_FROM_CACHE, metadataFromCache);
+            gate.emit(SDK_READY_FROM_CACHE, metadataReadyFromCache);
           }
           const metadataReady: SplitIO.SdkReadyMetadata = {
-            initialCacheLoad: wasReadyFromCache,
-            lastUpdateTimestamp: lastUpdate
+            initialCacheLoad: !wasReadyFromCache,
+            lastUpdateTimestamp: wasReadyFromCache ? cacheLastUpdateTimestamp : null
           };
           gate.emit(SDK_READY, metadataReady);
         } catch (e) {

package/src/sdkFactory/index.ts

@@ -54,10 +54,10 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
         return;
       }
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
-      readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+      readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { isCacheValid: true, lastUpdateTimestamp: null });
     },
     onReadyFromCacheCb() {
-      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
     }
   });
 
@@ -65,7 +65,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
   if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));
-    if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+    if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
   }
 
   const clients: Record<string, SplitIO.IBasicClient> = {};

package/src/storages/inLocalStorage/index.ts

@@ -14,7 +14,7 @@ import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
-import { validateCache } from './validateCache';
+import { validateCache, CacheValidationMetadata } from './validateCache';
 import { ILogger } from '../../logger/types';
 import SplitIO from '../../../types/splitio';
 import { storageAdapter } from './storageAdapter';
@@ -54,7 +54,7 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
     const rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
     const segments = new MySegmentsCacheInLocal(log, keys, storage);
     const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);
-    let validateCachePromise: Promise<boolean> | undefined;
+    let validateCachePromise: Promise<CacheValidationMetadata> | undefined;
 
     return {
       splits,
@@ -68,7 +68,10 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
       uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
       validateCache() {
-        return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
+        if (!validateCachePromise) {
+          validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
+        }
+        return validateCachePromise;
       },
 
       save() {

package/src/storages/inLocalStorage/validateCache.ts

@@ -12,6 +12,11 @@ import { StorageAdapter } from '../types';
 const DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
 const MILLIS_IN_A_DAY = 86400000;
 
+export interface CacheValidationMetadata {
+  isCacheValid: boolean;
+  lastUpdateTimestamp: number | null;
+}
+
 /**
  * Validates if cache should be cleared and sets the cache `hash` if needed.
  *
@@ -66,14 +71,19 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, storage: Sto
  * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
  * - `clearOnInit` was set and cache was not cleared in the last 24 hours
  *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
+ * @returns Metadata object with `isCacheValid` (true if cache is ready to be used, false otherwise) and `lastUpdateTimestamp` (timestamp of last cache update or null)
  */
-export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<boolean> {
+export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<CacheValidationMetadata> {
 
   return Promise.resolve(storage.load && storage.load()).then(() => {
     const currentTimestamp = Date.now();
     const isThereCache = splits.getChangeNumber() > -1;
 
+    // Get lastUpdateTimestamp from storage
+    const lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
+    const lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : null;
+    const lastUpdateTimestamp = (!isNaNNumber(lastUpdatedTimestamp) && lastUpdatedTimestamp !== null) ? lastUpdatedTimestamp : null;
+
     if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
       splits.clear();
       rbSegments.clear();
@@ -90,10 +100,16 @@ export function validateCache(options: SplitIO.InLocalStorageOptions, storage: S
       // Persist clear
       if (storage.save) storage.save();
 
-      return false;
+      return {
+        isCacheValid: false,
+        lastUpdateTimestamp: null
+      };
     }
 
     // Check if ready from cache
-    return isThereCache;
+    return {
+      isCacheValid: isThereCache,
+      lastUpdateTimestamp
+    };
   });
 }

package/src/storages/types.ts

@@ -499,7 +499,7 @@ export interface IStorageSync extends IStorageBase<
   IUniqueKeysCacheSync
 > {
   // Defined in client-side
-  validateCache?: () => Promise<boolean>,
+  validateCache?: () => Promise<{ isCacheValid: boolean; lastUpdateTimestamp: number | null }>,
   largeSegments?: ISegmentsCacheSync,
 }
 

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -59,9 +59,11 @@ export function fromObjectUpdaterFactory(
 
         if (startingUp) {
           startingUp = false;
-          Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
+          Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then((cacheMetadata) => {
             // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            if (cacheMetadata.isCacheValid) {
+              readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+            }
             // Emits SDK_READY
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
           });

package/src/sync/syncManagerOnline.ts

@@ -92,12 +92,14 @@ export function syncManagerOnlineFactory(
         // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
         submitterManager.start(!isConsentGranted(settings));
 
-        return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
+        return Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then((cacheMetadata) => {
           if (!running) return;
 
           if (startFirstTime) {
             // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            if (cacheMetadata.isCacheValid) {
+              readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+            }
 
           }
 

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -8,7 +8,7 @@ import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
 
 export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
   const result = InMemoryStorageCSFactory(params);
-  result.validateCache = () => Promise.resolve(true); // to emit SDK_READY_FROM_CACHE
+  result.validateCache = () => Promise.resolve({ isCacheValid: true, lastUpdateTimestamp: null }); // to emit SDK_READY_FROM_CACHE
   return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/types/splitio.d.ts

@@ -530,7 +530,7 @@ declare namespace SplitIO {
     /**
      * Timestamp in milliseconds since epoch when the event was emitted.
      */
-    lastUpdateTimestamp: number
+    lastUpdateTimestamp: number | null
   }
 
   /**