@splitsoftware/splitio-commons 2.10.1 → 2.10.2-rc.0

package/CHANGES.txt

@@ -1,5 +1,9 @@
+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).
+
 2.10.1 (December 18, 2025)
- - Bugfix - Handle `null` prerequisites properly
+ - Bugfix - Handle `null` prerequisites properly.
 
 2.10.0 (December 16, 2025)
  - Added property `impressionsDisabled` in getTreatment(s) `evaluationOptions` parameter, to disable impressions per evaluations.

package/cjs/readiness/readinessManager.js

@@ -13,7 +13,7 @@ function splitsEventEmitterFactory(EventEmitter) {
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
     // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
     // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-    splitsEventEmitter.on(constants_1.SDK_SPLITS_ARRIVED, function (isSplitKill) { if (!isSplitKill)
+    splitsEventEmitter.on(constants_1.SDK_SPLITS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
         splitsEventEmitter.splitsArrived = true; });
     splitsEventEmitter.once(constants_1.SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
     return splitsEventEmitter;
@@ -74,7 +74,11 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
         if (!isReady && !isDestroyed) {
             try {
                 syncLastUpdate();
-                gate.emit(constants_1.SDK_READY_FROM_CACHE, isReady);
+                var metadata = {
+                    initialCacheLoad: true,
+                    lastUpdateTimestamp: lastUpdate
+                };
+                gate.emit(constants_1.SDK_READY_FROM_CACHE, metadata);
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -82,13 +86,13 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
             }
         }
     }
-    function checkIsReadyOrUpdate(diff) {
+    function checkIsReadyOrUpdate(metadata) {
         if (isDestroyed)
             return;
         if (isReady) {
             try {
                 syncLastUpdate();
-                gate.emit(constants_1.SDK_UPDATE, diff);
+                gate.emit(constants_1.SDK_UPDATE, metadata);
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -101,11 +105,20 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
                 isReady = true;
                 try {
                     syncLastUpdate();
+                    var wasReadyFromCache = isReadyFromCache;
                     if (!isReadyFromCache) {
                         isReadyFromCache = true;
-                        gate.emit(constants_1.SDK_READY_FROM_CACHE, isReady);
+                        var metadataFromCache = {
+                            initialCacheLoad: false,
+                            lastUpdateTimestamp: lastUpdate
+                        };
+                        gate.emit(constants_1.SDK_READY_FROM_CACHE, metadataFromCache);
                     }
-                    gate.emit(constants_1.SDK_READY);
+                    var metadataReady = {
+                        initialCacheLoad: wasReadyFromCache,
+                        lastUpdateTimestamp: lastUpdate
+                    };
+                    gate.emit(constants_1.SDK_READY, metadataReady);
                 }
                 catch (e) {
                     // throws user callback exceptions in next tick

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

@@ -42,7 +42,7 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 splitsCache.clear(),
                 splitsCache.update(splits, [], Date.now())
             ]).then(function () {
-                readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
+                readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED, { type: "FLAGS_UPDATE" /* FLAGS_UPDATE */, names: [] });
                 if (startingUp) {
                     startingUp = false;
                     Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
@@ -50,7 +50,7 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                         if (isCacheLoaded)
                             readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
                         // Emits SDK_READY
-                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { type: "SEGMENTS_UPDATE" /* SEGMENTS_UPDATE */, names: [] });
                     });
                 }
                 return true;

package/cjs/sync/polling/pollingManagerCS.js

@@ -49,9 +49,9 @@ function pollingManagerCSFactory(params) {
     function add(matchingKey, readiness, storage) {
         var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
-        function smartReady() {
+        function smartReady(metadata) {
             if (!readiness.isReady() && !(0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
-                readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+                readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED, metadata);
         }
         if (!(0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
             setTimeout(smartReady, 0);

package/cjs/sync/polling/updaters/mySegmentsUpdater.js

@@ -39,7 +39,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
         // Notify update if required
         if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
-            segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+            segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED, { type: "SEGMENTS_UPDATE" /* SEGMENTS_UPDATE */, names: [] });
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache, till) {

package/cjs/sync/polling/updaters/segmentChangesUpdater.js

@@ -66,8 +66,12 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
+                    var metadata = {
+                        type: "SEGMENTS_UPDATE" /* SEGMENTS_UPDATE */,
+                        names: []
+                    };
                     if (readiness)
-                        readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+                        readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED, metadata);
                 }
                 return true;
             });

package/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -79,8 +79,9 @@ function computeMutation(rules, segments, filters) {
         else {
             accum.removed.push(ruleEntity);
         }
+        accum.names.push(ruleEntity.name);
         return accum;
-    }, { added: [], removed: [] });
+    }, { added: [], removed: [], names: [] });
 }
 exports.computeMutation = computeMutation;
 /**
@@ -136,9 +137,11 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFilt
                 splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
                 .then(function (splitChanges) {
                 var usedSegments = new Set();
+                var updatedFlags = [];
                 var ffUpdate = false;
                 if (splitChanges.ff) {
-                    var _a = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed;
+                    var _a = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
+                    updatedFlags = names;
                     log.debug(constants_2.SYNC_SPLITS_UPDATE, [added.length, removed.length]);
                     ffUpdate = splits.update(added, removed, splitChanges.ff.t);
                 }
@@ -161,9 +164,13 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFilt
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
+                            var metadata = {
+                                type: updatedFlags.length > 0 ? "FLAGS_UPDATE" /* FLAGS_UPDATE */ : "SEGMENTS_UPDATE" /* SEGMENTS_UPDATE */,
+                                names: updatedFlags.length > 0 ? updatedFlags : []
+                            };
                             // emit SDK events
                             if (emitSplitsArrivedEvent)
-                                splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED);
+                                splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, metadata);
                             return true;
                         });
                     }

package/cjs/sync/submitters/submitterManager.js

@@ -36,7 +36,7 @@ function submitterManagerFactory(params) {
             var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
             if (telemetrySubmitter)
                 promises.push(telemetrySubmitter.execute());
-            return Promise.all(promises);
+            return Promise.all(promises).then(function () { });
         },
         isExecuting: function () {
             return submitters.some(function (submitter) { return submitter.isExecuting(); });

package/esm/readiness/readinessManager.js

@@ -10,7 +10,7 @@ function splitsEventEmitterFactory(EventEmitter) {
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
     // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
     // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-    splitsEventEmitter.on(SDK_SPLITS_ARRIVED, function (isSplitKill) { if (!isSplitKill)
+    splitsEventEmitter.on(SDK_SPLITS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
         splitsEventEmitter.splitsArrived = true; });
     splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
     return splitsEventEmitter;
@@ -71,7 +71,11 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         if (!isReady && !isDestroyed) {
             try {
                 syncLastUpdate();
-                gate.emit(SDK_READY_FROM_CACHE, isReady);
+                var metadata = {
+                    initialCacheLoad: true,
+                    lastUpdateTimestamp: lastUpdate
+                };
+                gate.emit(SDK_READY_FROM_CACHE, metadata);
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -79,13 +83,13 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
             }
         }
     }
-    function checkIsReadyOrUpdate(diff) {
+    function checkIsReadyOrUpdate(metadata) {
         if (isDestroyed)
             return;
         if (isReady) {
             try {
                 syncLastUpdate();
-                gate.emit(SDK_UPDATE, diff);
+                gate.emit(SDK_UPDATE, metadata);
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -98,11 +102,20 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
                 isReady = true;
                 try {
                     syncLastUpdate();
+                    var wasReadyFromCache = isReadyFromCache;
                     if (!isReadyFromCache) {
                         isReadyFromCache = true;
-                        gate.emit(SDK_READY_FROM_CACHE, isReady);
+                        var metadataFromCache = {
+                            initialCacheLoad: false,
+                            lastUpdateTimestamp: lastUpdate
+                        };
+                        gate.emit(SDK_READY_FROM_CACHE, metadataFromCache);
                     }
-                    gate.emit(SDK_READY);
+                    var metadataReady = {
+                        initialCacheLoad: wasReadyFromCache,
+                        lastUpdateTimestamp: lastUpdate
+                    };
+                    gate.emit(SDK_READY, metadataReady);
                 }
                 catch (e) {
                     // throws user callback exceptions in next tick

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

@@ -39,7 +39,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 splitsCache.clear(),
                 splitsCache.update(splits, [], Date.now())
             ]).then(function () {
-                readiness.splits.emit(SDK_SPLITS_ARRIVED);
+                readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: "FLAGS_UPDATE" /* FLAGS_UPDATE */, names: [] });
                 if (startingUp) {
                     startingUp = false;
                     Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
@@ -47,7 +47,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                         if (isCacheLoaded)
                             readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
                         // Emits SDK_READY
-                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: "SEGMENTS_UPDATE" /* SEGMENTS_UPDATE */, names: [] });
                     });
                 }
                 return true;

package/esm/sync/polling/pollingManagerCS.js

@@ -46,9 +46,9 @@ export function pollingManagerCSFactory(params) {
     function add(matchingKey, readiness, storage) {
         var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
-        function smartReady() {
+        function smartReady(metadata) {
             if (!readiness.isReady() && !usesSegmentsSync(storage))
-                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
         }
         if (!usesSegmentsSync(storage))
             setTimeout(smartReady, 0);

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -36,7 +36,7 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmen
         // Notify update if required
         if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
-            segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
+            segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED, { type: "SEGMENTS_UPDATE" /* SEGMENTS_UPDATE */, names: [] });
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache, till) {

package/esm/sync/polling/updaters/segmentChangesUpdater.js

@@ -63,8 +63,12 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
+                    var metadata = {
+                        type: "SEGMENTS_UPDATE" /* SEGMENTS_UPDATE */,
+                        names: []
+                    };
                     if (readiness)
-                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
                 }
                 return true;
             });

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -75,8 +75,9 @@ export function computeMutation(rules, segments, filters) {
         else {
             accum.removed.push(ruleEntity);
         }
+        accum.names.push(ruleEntity.name);
         return accum;
-    }, { added: [], removed: [] });
+    }, { added: [], removed: [], names: [] });
 }
 /**
  * factory of SplitChanges updater, a task that:
@@ -131,9 +132,11 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                 splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
                 .then(function (splitChanges) {
                 var usedSegments = new Set();
+                var updatedFlags = [];
                 var ffUpdate = false;
                 if (splitChanges.ff) {
-                    var _a = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed;
+                    var _a = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
+                    updatedFlags = names;
                     log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
                     ffUpdate = splits.update(added, removed, splitChanges.ff.t);
                 }
@@ -156,9 +159,13 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
+                            var metadata = {
+                                type: updatedFlags.length > 0 ? "FLAGS_UPDATE" /* FLAGS_UPDATE */ : "SEGMENTS_UPDATE" /* SEGMENTS_UPDATE */,
+                                names: updatedFlags.length > 0 ? updatedFlags : []
+                            };
                             // emit SDK events
                             if (emitSplitsArrivedEvent)
-                                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED);
+                                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
                             return true;
                         });
                     }

package/esm/sync/submitters/submitterManager.js

@@ -33,7 +33,7 @@ export function submitterManagerFactory(params) {
             var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
             if (telemetrySubmitter)
                 promises.push(telemetrySubmitter.execute());
-            return Promise.all(promises);
+            return Promise.all(promises).then(function () { });
         },
         isExecuting: function () {
             return submitters.some(function (submitter) { return submitter.isExecuting(); });

package/package.json

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

package/src/readiness/readinessManager.ts

@@ -15,7 +15,7 @@ function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
   // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
   // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-  splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
+  splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (metadata: SplitIO.SdkUpdateMetadata, isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
   splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
 
   return splitsEventEmitter;
@@ -90,7 +90,11 @@ export function readinessManagerFactory(
     if (!isReady && !isDestroyed) {
       try {
         syncLastUpdate();
-        gate.emit(SDK_READY_FROM_CACHE, isReady);
+        const metadata: SplitIO.SdkReadyMetadata = {
+          initialCacheLoad: true,
+          lastUpdateTimestamp: lastUpdate
+        };
+        gate.emit(SDK_READY_FROM_CACHE, metadata);
       } catch (e) {
         // throws user callback exceptions in next tick
         setTimeout(() => { throw e; }, 0);
@@ -98,12 +102,12 @@ export function readinessManagerFactory(
     }
   }
 
-  function checkIsReadyOrUpdate(diff: any) {
+  function checkIsReadyOrUpdate(metadata: SplitIO.SdkUpdateMetadata) {
     if (isDestroyed) return;
     if (isReady) {
       try {
         syncLastUpdate();
-        gate.emit(SDK_UPDATE, diff);
+        gate.emit(SDK_UPDATE, metadata);
       } catch (e) {
         // throws user callback exceptions in next tick
         setTimeout(() => { throw e; }, 0);
@@ -114,11 +118,20 @@ export function readinessManagerFactory(
         isReady = true;
         try {
           syncLastUpdate();
+          const wasReadyFromCache = isReadyFromCache;
           if (!isReadyFromCache) {
             isReadyFromCache = true;
-            gate.emit(SDK_READY_FROM_CACHE, isReady);
+            const metadataFromCache: SplitIO.SdkReadyMetadata = {
+              initialCacheLoad: false,
+              lastUpdateTimestamp: lastUpdate
+            };
+            gate.emit(SDK_READY_FROM_CACHE, metadataFromCache);
           }
-          gate.emit(SDK_READY);
+          const metadataReady: SplitIO.SdkReadyMetadata = {
+            initialCacheLoad: wasReadyFromCache,
+            lastUpdateTimestamp: lastUpdate
+          };
+          gate.emit(SDK_READY, metadataReady);
         } catch (e) {
           // throws user callback exceptions in next tick
           setTimeout(() => { throw e; }, 0);

package/src/readiness/types.ts

@@ -1,5 +1,30 @@
 import SplitIO from '../../types/splitio';
 
+/** Readiness event types */
+
+export type SDK_READY_TIMED_OUT = 'init::timeout'
+export type SDK_READY = 'init::ready'
+export type SDK_READY_FROM_CACHE = 'init::cache-ready'
+export type SDK_UPDATE = 'state::update'
+export type SDK_DESTROY = 'state::destroy'
+
+export type IReadinessEvent = SDK_READY_TIMED_OUT | SDK_READY | SDK_READY_FROM_CACHE | SDK_UPDATE | SDK_DESTROY
+
+export interface IReadinessEventEmitter extends SplitIO.IEventEmitter {
+  emit(event: IReadinessEvent, ...args: any[]): boolean
+  on(event: SDK_READY, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  on(event: SDK_READY_FROM_CACHE, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  on(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+  once(event: SDK_READY, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  once(event: SDK_READY_FROM_CACHE, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  once(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
+  once(event: string | symbol, listener: (...args: any[]) => void): this;
+  addListener(event: SDK_READY, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  addListener(event: SDK_READY_FROM_CACHE, listener: (metadata: SplitIO.SdkReadyMetadata) => void): this;
+  addListener(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
 /** Splits data emitter */
 
 type SDK_SPLITS_ARRIVED = 'state::splits-arrived'
@@ -9,6 +34,7 @@ type ISplitsEvent = SDK_SPLITS_ARRIVED | SDK_SPLITS_CACHE_LOADED
 export interface ISplitsEventEmitter extends SplitIO.IEventEmitter {
   emit(event: ISplitsEvent, ...args: any[]): boolean
   on(event: ISplitsEvent, listener: (...args: any[]) => void): this;
+  on(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
   once(event: ISplitsEvent, listener: (...args: any[]) => void): this;
   splitsArrived: boolean
   splitsCacheLoaded: boolean
@@ -24,23 +50,11 @@ type ISegmentsEvent = SDK_SEGMENTS_ARRIVED
 export interface ISegmentsEventEmitter extends SplitIO.IEventEmitter {
   emit(event: ISegmentsEvent, ...args: any[]): boolean
   on(event: ISegmentsEvent, listener: (...args: any[]) => void): this;
+  on(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
   once(event: ISegmentsEvent, listener: (...args: any[]) => void): this;
   segmentsArrived: boolean
 }
 
-/** Readiness emitter */
-
-export type SDK_READY_TIMED_OUT = 'init::timeout'
-export type SDK_READY = 'init::ready'
-export type SDK_READY_FROM_CACHE = 'init::cache-ready'
-export type SDK_UPDATE = 'state::update'
-export type SDK_DESTROY = 'state::destroy'
-export type IReadinessEvent = SDK_READY_TIMED_OUT | SDK_READY | SDK_READY_FROM_CACHE | SDK_UPDATE | SDK_DESTROY
-
-export interface IReadinessEventEmitter extends SplitIO.IEventEmitter {
-  emit(event: IReadinessEvent, ...args: any[]): boolean
-}
-
 /** Readiness manager */
 
 export interface IReadinessManager {

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

@@ -9,6 +9,7 @@ import { ISettings } from '../../../types';
 import { CONTROL } from '../../../utils/constants';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
+import { SdkUpdateMetadataKeys } from '../../../../types/splitio';
 
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
@@ -55,7 +56,7 @@ export function fromObjectUpdaterFactory(
         splitsCache.clear(), // required to sync removed splits from mock
         splitsCache.update(splits, [], Date.now())
       ]).then(() => {
-        readiness.splits.emit(SDK_SPLITS_ARRIVED);
+        readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: SdkUpdateMetadataKeys.FLAGS_UPDATE, names: [] });
 
         if (startingUp) {
           startingUp = false;
@@ -63,7 +64,7 @@ export function fromObjectUpdaterFactory(
             // Emits SDK_READY_FROM_CACHE
             if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
             // Emits SDK_READY
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
           });
         }
         return true;

package/src/sync/polling/pollingManagerCS.ts

@@ -9,6 +9,7 @@ import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/consta
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
+import { SdkUpdateMetadata } from '../../../types/splitio';
 
 /**
  * Expose start / stop mechanism for polling data from services.
@@ -59,8 +60,8 @@ export function pollingManagerCSFactory(
     const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
 
     // smart ready
-    function smartReady() {
-      if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+    function smartReady(metadata: SdkUpdateMetadata) {
+      if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
     }
     if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
     else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -9,6 +9,7 @@ import { MySegmentsData } from '../types';
 import { IMembershipsResponse } from '../../../dtos/types';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
 import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
+import { SdkUpdateMetadataKeys } from '../../../../types/splitio';
 
 type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -56,7 +57,7 @@ export function mySegmentsUpdaterFactory(
     // Notify update if required
     if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
-      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
+      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
     }
   }
 

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -5,6 +5,8 @@ import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
 import { timeout } from '../../../utils/promise/timeout';
+import { SdkUpdateMetadata, SdkUpdateMetadataKeys } from '../../../../types/splitio';
+
 
 type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -37,7 +39,7 @@ export function segmentChangesUpdaterFactory(
 
   function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean, retries?: number): Promise<boolean> {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
-    let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
+    const sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
 
     return sincePromise.then(since => {
       // if fetchOnlyNew flag, avoid processing already fetched segments
@@ -83,7 +85,11 @@ export function segmentChangesUpdaterFactory(
         // if at least one segment fetch succeeded, mark segments ready
         if (shouldUpdateFlags.some(update => update) || readyOnAlreadyExistentState) {
           readyOnAlreadyExistentState = false;
-          if (readiness) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+          const metadata: SdkUpdateMetadata = {
+            type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE,
+            names: []
+          };
+          if (readiness) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
         }
         return true;
       });

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -10,6 +10,7 @@ import { startsWith } from '../../../utils/lang';
 import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
 import { SPLIT_UPDATE } from '../../streaming/constants';
+import { SdkUpdateMetadata, SdkUpdateMetadataKeys } from '../../../../types/splitio';
 
 export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
 type SplitChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
@@ -54,7 +55,8 @@ export function parseSegments(ruleEntity: ISplit | IRBSegment, matcherType: type
 
 interface ISplitMutations<T extends ISplit | IRBSegment> {
   added: T[],
-  removed: T[]
+  removed: T[],
+  names: string[]
 }
 
 /**
@@ -95,9 +97,10 @@ export function computeMutation<T extends ISplit | IRBSegment>(rules: Array<T>,
     } else {
       accum.removed.push(ruleEntity);
     }
+    accum.names.push(ruleEntity.name);
 
     return accum;
-  }, { added: [], removed: [] } as ISplitMutations<T>);
+  }, { added: [], removed: [], names: [] } as ISplitMutations<T>);
 }
 
 /**
@@ -165,9 +168,11 @@ export function splitChangesUpdaterFactory(
         .then((splitChanges: ISplitChangesResponse) => {
           const usedSegments = new Set<string>();
 
+          let updatedFlags: string[] = [];
           let ffUpdate: MaybeThenable<boolean> = false;
           if (splitChanges.ff) {
-            const { added, removed } = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation);
+            const { added, removed, names } = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation);
+            updatedFlags = names;
             log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
             ffUpdate = splits.update(added, removed, splitChanges.ff.t);
           }
@@ -192,8 +197,12 @@ export function splitChangesUpdaterFactory(
               return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
+                  const metadata: SdkUpdateMetadata = {
+                    type: updatedFlags.length > 0 ? SdkUpdateMetadataKeys.FLAGS_UPDATE : SdkUpdateMetadataKeys.SEGMENTS_UPDATE,
+                    names: updatedFlags.length > 0 ? updatedFlags : []
+                  };
                   // emit SDK events
-                  if (emitSplitsArrivedEvent) splitsEventEmitter.emit(SDK_SPLITS_ARRIVED);
+                  if (emitSplitsArrivedEvent) splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
                   return true;
                 });
             }

package/src/sync/submitters/submitterManager.ts

@@ -38,7 +38,7 @@ export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmit
     execute(onlyTelemetry?: boolean) {
       const promises = onlyTelemetry ? [] : submitters.map(submitter => submitter.execute());
       if (telemetrySubmitter) promises.push(telemetrySubmitter.execute());
-      return Promise.all(promises);
+      return Promise.all(promises).then(() => { });
     },
 
     isExecuting() {

package/src/sync/submitters/types.ts

@@ -237,5 +237,5 @@ export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
 export interface ISubmitterManager extends ISyncTask {
   start(onlyTelemetry?: boolean): void,
   stop(allExceptTelemetry?: boolean): void,
-  execute(onlyTelemetry?: boolean): Promise<any>
+  execute(onlyTelemetry?: boolean): Promise<void>
 }

package/src/sync/types.ts

@@ -37,7 +37,7 @@ export interface ISyncTask<Input extends any[] = [], Output = any> extends ITask
 /** SyncManager */
 
 export interface ISyncManager extends ITask {
-  flush(): Promise<any>,
+  flush(): Promise<void>,
   pushManager?: IPushManager,
   pollingManager?: IPollingManager,
   submitterManager?: ISubmitterManager

package/types/splitio.d.ts

@@ -492,6 +492,52 @@ declare namespace SplitIO {
     removeItem(key: string): void | Promise<void>;
   }
 
+  /**
+   * Metadata keys for SDK update events.
+   */
+  const enum SdkUpdateMetadataKeys {
+    /**
+     * The update event emitted when the SDK cache is updated with new data for flags.
+     */
+    FLAGS_UPDATE = 'FLAGS_UPDATE',
+    /**
+     * The update event emitted when the SDK cache is updated with new data for segments.
+     */
+    SEGMENTS_UPDATE = 'SEGMENTS_UPDATE'
+  }
+
+  /**
+   * Metadata for the update event emitted when the SDK cache is updated with new data for flags or segments.
+   */
+  type SdkUpdateMetadata = {
+    /**
+     * The type of update event.
+     */
+    type: SdkUpdateMetadataKeys.FLAGS_UPDATE | SdkUpdateMetadataKeys.SEGMENTS_UPDATE
+    /**
+     * The names of the flags or segments that were updated.
+     */
+    names: string[]
+  }
+
+  /**
+   * Metadata for the ready events emitted when the SDK is ready to evaluate feature flags.
+   */
+  type SdkReadyMetadata = {
+    /**
+     * Indicates whether the SDK was loaded from cache initially.
+     * - `true` when SDK_READY_FROM_CACHE is emitted from cache (before SDK_READY)
+     * - `true` when SDK_READY is emitted and the SDK was ready from cache first
+     * - `false` when SDK_READY_FROM_CACHE is emitted because SDK became ready without cache
+     * - `false` when SDK_READY is emitted and the SDK was not ready from cache
+     */
+    initialCacheLoad: boolean
+    /**
+     * Timestamp in milliseconds since epoch when the event was emitted.
+     */
+    lastUpdateTimestamp: number
+  }
+
   /**
    * EventEmitter interface based on a subset of the Node.js EventEmitter methods.
    */
@@ -509,8 +555,17 @@ declare namespace SplitIO {
    * @see {@link https://nodejs.org/api/events.html}
    */
   interface EventEmitter extends IEventEmitter {
+    addListener(event: EventConsts['SDK_READY'], listener: (metadata: SdkReadyMetadata) => void): this;
+    addListener(event: EventConsts['SDK_READY_FROM_CACHE'], listener: (metadata: SdkReadyMetadata) => void): this;
+    addListener(event: EventConsts['SDK_UPDATE'], listener: (metadata: SdkUpdateMetadata) => void): this;
     addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    on(event: EventConsts['SDK_READY'], listener: (metadata: SdkReadyMetadata) => void): this;
+    on(event: EventConsts['SDK_READY_FROM_CACHE'], listener: (metadata: SdkReadyMetadata) => void): this;
+    on(event: EventConsts['SDK_UPDATE'], listener: (metadata: SdkUpdateMetadata) => void): this;
     on(event: string | symbol, listener: (...args: any[]) => void): this;
+    once(event: EventConsts['SDK_READY'], listener: (metadata: SdkReadyMetadata) => void): this;
+    once(event: EventConsts['SDK_READY_FROM_CACHE'], listener: (metadata: SdkReadyMetadata) => void): this;
+    once(event: EventConsts['SDK_UPDATE'], listener: (metadata: SdkUpdateMetadata) => void): this;
     once(event: string | symbol, listener: (...args: any[]) => void): this;
     removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
     off(event: string | symbol, listener: (...args: any[]) => void): this;