@splitsoftware/splitio-commons 2.7.9-rc.2 → 2.8.0

package/CHANGES.txt

@@ -1,4 +1,4 @@
-2.8.0 (October 28, 2025)
+2.8.0 (October 30, 2025)
  - Added new configuration for Fallback Treatments, which allows setting a treatment value and optional config to be returned in place of "control", either globally or by flag. Read more in our docs.
  - Added `client.getStatus()` method to retrieve the client readiness status properties (`isReady`, `isReadyFromCache`, etc).
  - Added `client.whenReady()` and `client.whenReadyFromCache()` methods to replace the deprecated `client.ready()` method, which has an issue causing the returned promise to hang when using async/await syntax if it was rejected.

package/cjs/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.js

@@ -1,51 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FallbacksSanitizer = void 0;
+exports.sanitizeFallbacks = exports.isValidTreatment = exports.isValidFlagName = void 0;
 var lang_1 = require("../../../utils/lang");
 var FallbackDiscardReason;
 (function (FallbackDiscardReason) {
     FallbackDiscardReason["FlagName"] = "Invalid flag name (max 100 chars, no spaces)";
     FallbackDiscardReason["Treatment"] = "Invalid treatment (max 100 chars and must match pattern)";
 })(FallbackDiscardReason || (FallbackDiscardReason = {}));
-var FallbacksSanitizer = /** @class */ (function () {
-    function FallbacksSanitizer() {
+var TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
+function isValidFlagName(name) {
+    return name.length <= 100 && !name.includes(' ');
+}
+exports.isValidFlagName = isValidFlagName;
+function isValidTreatment(t) {
+    var treatment = (0, lang_1.isObject)(t) ? t.treatment : t;
+    if (!(0, lang_1.isString)(treatment) || treatment.length > 100) {
+        return false;
     }
-    FallbacksSanitizer.isValidFlagName = function (name) {
-        return name.length <= 100 && !name.includes(' ');
-    };
-    FallbacksSanitizer.isValidTreatment = function (t) {
-        var treatment = (0, lang_1.isObject)(t) ? t.treatment : t;
-        if (!(0, lang_1.isString)(treatment) || treatment.length > 100) {
-            return false;
+    return TREATMENT_PATTERN.test(treatment);
+}
+exports.isValidTreatment = isValidTreatment;
+function sanitizeGlobal(logger, treatment) {
+    if (treatment === undefined)
+        return undefined;
+    if (!isValidTreatment(treatment)) {
+        logger.error("Fallback treatments - Discarded fallback: " + FallbackDiscardReason.Treatment);
+        return undefined;
+    }
+    return treatment;
+}
+function sanitizeByFlag(logger, byFlagFallbacks) {
+    var sanitizedByFlag = {};
+    if (!(0, lang_1.isObject)(byFlagFallbacks))
+        return sanitizedByFlag;
+    Object.keys(byFlagFallbacks).forEach(function (flag) {
+        var t = byFlagFallbacks[flag];
+        if (!isValidFlagName(flag)) {
+            logger.error("Fallback treatments - Discarded flag '" + flag + "': " + FallbackDiscardReason.FlagName);
+            return;
         }
-        return FallbacksSanitizer.pattern.test(treatment);
-    };
-    FallbacksSanitizer.sanitizeGlobal = function (logger, treatment) {
-        if (!this.isValidTreatment(treatment)) {
-            logger.error("Fallback treatments - Discarded fallback: " + FallbackDiscardReason.Treatment);
-            return undefined;
+        if (!isValidTreatment(t)) {
+            logger.error("Fallback treatments - Discarded treatment for flag '" + flag + "': " + FallbackDiscardReason.Treatment);
+            return;
         }
-        return treatment;
-    };
-    FallbacksSanitizer.sanitizeByFlag = function (logger, byFlagFallbacks) {
-        var _this = this;
-        var sanitizedByFlag = {};
-        var entries = Object.keys(byFlagFallbacks);
-        entries.forEach(function (flag) {
-            var t = byFlagFallbacks[flag];
-            if (!_this.isValidFlagName(flag)) {
-                logger.error("Fallback treatments - Discarded flag '" + flag + "': " + FallbackDiscardReason.FlagName);
-                return;
-            }
-            if (!_this.isValidTreatment(t)) {
-                logger.error("Fallback treatments - Discarded treatment for flag '" + flag + "': " + FallbackDiscardReason.Treatment);
-                return;
-            }
-            sanitizedByFlag[flag] = t;
-        });
-        return sanitizedByFlag;
+        sanitizedByFlag[flag] = t;
+    });
+    return sanitizedByFlag;
+}
+function sanitizeFallbacks(logger, fallbacks) {
+    if (!(0, lang_1.isObject)(fallbacks)) {
+        logger.error('Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties');
+        return;
+    }
+    return {
+        global: sanitizeGlobal(logger, fallbacks.global),
+        byFlag: sanitizeByFlag(logger, fallbacks.byFlag)
     };
-    FallbacksSanitizer.pattern = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
-    return FallbacksSanitizer;
-}());
-exports.FallbacksSanitizer = FallbacksSanitizer;
+}
+exports.sanitizeFallbacks = sanitizeFallbacks;

package/cjs/evaluator/fallbackTreatmentsCalculator/index.js

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FallbackTreatmentsCalculator = exports.FALLBACK_PREFIX = void 0;
-var fallbackSanitizer_1 = require("./fallbackSanitizer");
 var constants_1 = require("../../utils/constants");
 var lang_1 = require("../../utils/lang");
 exports.FALLBACK_PREFIX = 'fallback - ';
 var FallbackTreatmentsCalculator = /** @class */ (function () {
-    function FallbackTreatmentsCalculator(logger, fallbacks) {
-        var sanitizedGlobal = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.global) ? fallbackSanitizer_1.FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
-        var sanitizedByFlag = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.byFlag) ? fallbackSanitizer_1.FallbacksSanitizer.sanitizeByFlag(logger, fallbacks.byFlag) : {};
-        this.fallbacks = {
-            global: sanitizedGlobal,
-            byFlag: sanitizedByFlag
-        };
+    function FallbackTreatmentsCalculator(fallbacks) {
+        if (fallbacks === void 0) { fallbacks = {}; }
+        this.fallbacks = fallbacks;
     }
     FallbackTreatmentsCalculator.prototype.resolve = function (flagName, label) {
         var _a;

package/cjs/sdkFactory/index.js

@@ -52,7 +52,7 @@ function sdkFactory(params) {
             readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
         }
     });
-    var fallbackTreatmentsCalculator = new fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator(settings.log, settings.fallbackTreatments);
+    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)

package/cjs/utils/settingsValidation/index.js

@@ -9,6 +9,7 @@ var impressionsMode_1 = require("./impressionsMode");
 var key_1 = require("../inputValidation/key");
 var constants_2 = require("../../logger/constants");
 var setRolloutPlan_1 = require("../../storages/setRolloutPlan");
+var fallbackSanitizer_1 = require("../../evaluator/fallbackTreatmentsCalculator/fallbackSanitizer");
 // Exported for telemetry
 exports.base = {
     // Define which kind of object you want to retrieve from SplitFactory
@@ -183,6 +184,8 @@ function settingsValidation(config, validationParams) {
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
     withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
+    // @ts-ignore, modify readonly prop
+    withDefaults.fallbackTreatments = withDefaults.fallbackTreatments ? (0, fallbackSanitizer_1.sanitizeFallbacks)(log, withDefaults.fallbackTreatments) : undefined;
     return withDefaults;
 }
 exports.settingsValidation = settingsValidation;

package/esm/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.js

@@ -4,45 +4,51 @@ var FallbackDiscardReason;
     FallbackDiscardReason["FlagName"] = "Invalid flag name (max 100 chars, no spaces)";
     FallbackDiscardReason["Treatment"] = "Invalid treatment (max 100 chars and must match pattern)";
 })(FallbackDiscardReason || (FallbackDiscardReason = {}));
-var FallbacksSanitizer = /** @class */ (function () {
-    function FallbacksSanitizer() {
+var TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
+export function isValidFlagName(name) {
+    return name.length <= 100 && !name.includes(' ');
+}
+export function isValidTreatment(t) {
+    var treatment = isObject(t) ? t.treatment : t;
+    if (!isString(treatment) || treatment.length > 100) {
+        return false;
     }
-    FallbacksSanitizer.isValidFlagName = function (name) {
-        return name.length <= 100 && !name.includes(' ');
-    };
-    FallbacksSanitizer.isValidTreatment = function (t) {
-        var treatment = isObject(t) ? t.treatment : t;
-        if (!isString(treatment) || treatment.length > 100) {
-            return false;
+    return TREATMENT_PATTERN.test(treatment);
+}
+function sanitizeGlobal(logger, treatment) {
+    if (treatment === undefined)
+        return undefined;
+    if (!isValidTreatment(treatment)) {
+        logger.error("Fallback treatments - Discarded fallback: " + FallbackDiscardReason.Treatment);
+        return undefined;
+    }
+    return treatment;
+}
+function sanitizeByFlag(logger, byFlagFallbacks) {
+    var sanitizedByFlag = {};
+    if (!isObject(byFlagFallbacks))
+        return sanitizedByFlag;
+    Object.keys(byFlagFallbacks).forEach(function (flag) {
+        var t = byFlagFallbacks[flag];
+        if (!isValidFlagName(flag)) {
+            logger.error("Fallback treatments - Discarded flag '" + flag + "': " + FallbackDiscardReason.FlagName);
+            return;
         }
-        return FallbacksSanitizer.pattern.test(treatment);
-    };
-    FallbacksSanitizer.sanitizeGlobal = function (logger, treatment) {
-        if (!this.isValidTreatment(treatment)) {
-            logger.error("Fallback treatments - Discarded fallback: " + FallbackDiscardReason.Treatment);
-            return undefined;
+        if (!isValidTreatment(t)) {
+            logger.error("Fallback treatments - Discarded treatment for flag '" + flag + "': " + FallbackDiscardReason.Treatment);
+            return;
         }
-        return treatment;
-    };
-    FallbacksSanitizer.sanitizeByFlag = function (logger, byFlagFallbacks) {
-        var _this = this;
-        var sanitizedByFlag = {};
-        var entries = Object.keys(byFlagFallbacks);
-        entries.forEach(function (flag) {
-            var t = byFlagFallbacks[flag];
-            if (!_this.isValidFlagName(flag)) {
-                logger.error("Fallback treatments - Discarded flag '" + flag + "': " + FallbackDiscardReason.FlagName);
-                return;
-            }
-            if (!_this.isValidTreatment(t)) {
-                logger.error("Fallback treatments - Discarded treatment for flag '" + flag + "': " + FallbackDiscardReason.Treatment);
-                return;
-            }
-            sanitizedByFlag[flag] = t;
-        });
-        return sanitizedByFlag;
+        sanitizedByFlag[flag] = t;
+    });
+    return sanitizedByFlag;
+}
+export function sanitizeFallbacks(logger, fallbacks) {
+    if (!isObject(fallbacks)) {
+        logger.error('Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties');
+        return;
+    }
+    return {
+        global: sanitizeGlobal(logger, fallbacks.global),
+        byFlag: sanitizeByFlag(logger, fallbacks.byFlag)
     };
-    FallbacksSanitizer.pattern = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
-    return FallbacksSanitizer;
-}());
-export { FallbacksSanitizer };
+}

package/esm/evaluator/fallbackTreatmentsCalculator/index.js

@@ -1,15 +1,10 @@
-import { FallbacksSanitizer } from './fallbackSanitizer';
 import { CONTROL } from '../../utils/constants';
 import { isString } from '../../utils/lang';
 export var FALLBACK_PREFIX = 'fallback - ';
 var FallbackTreatmentsCalculator = /** @class */ (function () {
-    function FallbackTreatmentsCalculator(logger, fallbacks) {
-        var sanitizedGlobal = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.global) ? FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
-        var sanitizedByFlag = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.byFlag) ? FallbacksSanitizer.sanitizeByFlag(logger, fallbacks.byFlag) : {};
-        this.fallbacks = {
-            global: sanitizedGlobal,
-            byFlag: sanitizedByFlag
-        };
+    function FallbackTreatmentsCalculator(fallbacks) {
+        if (fallbacks === void 0) { fallbacks = {}; }
+        this.fallbacks = fallbacks;
     }
     FallbackTreatmentsCalculator.prototype.resolve = function (flagName, label) {
         var _a;

package/esm/sdkFactory/index.js

@@ -49,7 +49,7 @@ export function sdkFactory(params) {
             readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
         }
     });
-    var fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.log, settings.fallbackTreatments);
+    var fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
         if (storage.splits.getChangeNumber() > -1)

package/esm/utils/settingsValidation/index.js

@@ -6,6 +6,7 @@ import { validImpressionsMode } from './impressionsMode';
 import { validateKey } from '../inputValidation/key';
 import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
 import { validateRolloutPlan } from '../../storages/setRolloutPlan';
+import { sanitizeFallbacks } from '../../evaluator/fallbackTreatmentsCalculator/fallbackSanitizer';
 // Exported for telemetry
 export var base = {
     // Define which kind of object you want to retrieve from SplitFactory
@@ -180,5 +181,7 @@ export function settingsValidation(config, validationParams) {
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
     withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
+    // @ts-ignore, modify readonly prop
+    withDefaults.fallbackTreatments = withDefaults.fallbackTreatments ? sanitizeFallbacks(log, withDefaults.fallbackTreatments) : undefined;
     return withDefaults;
 }

package/package.json

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

package/src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -1,4 +1,4 @@
-import { Treatment, TreatmentWithConfig } from '../../../../types/splitio';
+import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../../types/splitio';
 import { ILogger } from '../../../logger/types';
 import { isObject, isString } from '../../../utils/lang';
 
@@ -7,59 +7,65 @@ enum FallbackDiscardReason {
   Treatment = 'Invalid treatment (max 100 chars and must match pattern)',
 }
 
-export class FallbacksSanitizer {
+const TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
 
-  private static readonly pattern = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
-
-  private static isValidFlagName(name: string): boolean {
-    return name.length <= 100 && !name.includes(' ');
-  }
+export function isValidFlagName(name: string): boolean {
+  return name.length <= 100 && !name.includes(' ');
+}
 
-  private static isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
-    const treatment = isObject(t) ? (t as TreatmentWithConfig).treatment : t;
+export function isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
+  const treatment = isObject(t) ? (t as TreatmentWithConfig).treatment : t;
 
-    if (!isString(treatment) || treatment.length > 100) {
-      return false;
-    }
-    return FallbacksSanitizer.pattern.test(treatment);
+  if (!isString(treatment) || treatment.length > 100) {
+    return false;
   }
+  return TREATMENT_PATTERN.test(treatment);
+}
 
-  static sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
-    if (!this.isValidTreatment(treatment)) {
-      logger.error(
-        `Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`
-      );
-      return undefined;
-    }
-    return treatment;
+function sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
+  if (treatment === undefined) return undefined;
+  if (!isValidTreatment(treatment)) {
+    logger.error(`Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`);
+    return undefined;
   }
+  return treatment;
+}
 
-  static sanitizeByFlag(
-    logger: ILogger,
-    byFlagFallbacks: Record<string, Treatment | TreatmentWithConfig>
-  ): Record<string, Treatment | TreatmentWithConfig> {
-    const sanitizedByFlag: Record<string, Treatment | TreatmentWithConfig> = {};
+function sanitizeByFlag(
+  logger: ILogger,
+  byFlagFallbacks?: Record<string, Treatment | TreatmentWithConfig>
+): Record<string, Treatment | TreatmentWithConfig> {
+  const sanitizedByFlag: Record<string, Treatment | TreatmentWithConfig> = {};
 
-    const entries = Object.keys(byFlagFallbacks);
-    entries.forEach((flag) => {
-      const t = byFlagFallbacks[flag];
-      if (!this.isValidFlagName(flag)) {
-        logger.error(
-          `Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`
-        );
-        return;
-      }
+  if (!isObject(byFlagFallbacks)) return sanitizedByFlag;
 
-      if (!this.isValidTreatment(t)) {
-        logger.error(
-          `Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`
-        );
-        return;
-      }
+  Object.keys(byFlagFallbacks!).forEach((flag) => {
+    const t = byFlagFallbacks![flag];
 
-      sanitizedByFlag[flag] = t;
-    });
+    if (!isValidFlagName(flag)) {
+      logger.error(`Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`);
+      return;
+    }
+
+    if (!isValidTreatment(t)) {
+      logger.error(`Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`);
+      return;
+    }
+
+    sanitizedByFlag[flag] = t;
+  });
 
-    return sanitizedByFlag;
+  return sanitizedByFlag;
+}
+
+export function sanitizeFallbacks(logger: ILogger, fallbacks: FallbackTreatmentConfiguration): FallbackTreatmentConfiguration | undefined {
+  if (!isObject(fallbacks)) {
+    logger.error('Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties');
+    return;
   }
+
+  return {
+    global: sanitizeGlobal(logger, fallbacks.global),
+    byFlag: sanitizeByFlag(logger, fallbacks.byFlag)
+  };
 }

package/src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -1,8 +1,6 @@
 import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../types/splitio';
-import { FallbacksSanitizer } from './fallbackSanitizer';
 import { CONTROL } from '../../utils/constants';
 import { isString } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
 
 export type IFallbackTreatmentsCalculator = {
   resolve(flagName: string, label: string): TreatmentWithConfig & { label: string };
@@ -13,13 +11,8 @@ export const FALLBACK_PREFIX = 'fallback - ';
 export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
   private readonly fallbacks: FallbackTreatmentConfiguration;
 
-  constructor(logger: ILogger, fallbacks?: FallbackTreatmentConfiguration) {
-    const sanitizedGlobal = fallbacks?.global ? FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
-    const sanitizedByFlag = fallbacks?.byFlag ? FallbacksSanitizer.sanitizeByFlag(logger, fallbacks.byFlag) : {};
-    this.fallbacks = {
-      global: sanitizedGlobal,
-      byFlag: sanitizedByFlag
-    };
+  constructor(fallbacks: FallbackTreatmentConfiguration = {}) {
+    this.fallbacks = fallbacks;
   }
 
   resolve(flagName: string, label: string): TreatmentWithConfig & { label: string } {

package/src/sdkFactory/index.ts

@@ -61,7 +61,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     }
   });
 
-  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.log, settings.fallbackTreatments);
+  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
 
   if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));

package/src/utils/settingsValidation/index.ts

@@ -8,6 +8,7 @@ import { ISettings } from '../../types';
 import { validateKey } from '../inputValidation/key';
 import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
 import { validateRolloutPlan } from '../../storages/setRolloutPlan';
+import { sanitizeFallbacks } from '../../evaluator/fallbackTreatmentsCalculator/fallbackSanitizer';
 
 // Exported for telemetry
 export const base = {
@@ -207,5 +208,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
 
+  // @ts-ignore, modify readonly prop
+  withDefaults.fallbackTreatments = withDefaults.fallbackTreatments ? sanitizeFallbacks(log, withDefaults.fallbackTreatments) : undefined;
+
   return withDefaults;
 }

package/types/splitio.d.ts

@@ -96,6 +96,12 @@ interface ISharedSettings {
    * Set together with `debug` option to `true` or a log level string to enable logging.
    */
   logger?: SplitIO.Logger;
+  /**
+   * Fallback treatments to be used when the SDK is not ready or the flag is not found.
+   *
+   * @defaultValue `undefined`
+   */
+  fallbackTreatments?: SplitIO.FallbackTreatmentConfiguration;
 }
 /**
  * Common settings properties for SDKs with synchronous API (standalone and localhost modes).
@@ -713,7 +719,7 @@ declare namespace SplitIO {
     isReadyFromCache: boolean;
 
     /**
-     * `isTimedout` indicates if the client has triggered an `SDK_READY_TIMED_OUT` event and is not ready to evaluate.
+     * `isTimedout` indicates if the client has triggered an `SDK_READY_TIMED_OUT` event and is not ready.
      * In other words, `isTimedout` is equivalent to `hasTimedout && !isReady`.
      */
     isTimedout: boolean;
@@ -1303,7 +1309,13 @@ declare namespace SplitIO {
    * Fallback treatments to be used when the SDK is not ready or the flag is not found.
    */
   type FallbackTreatmentConfiguration = {
+    /**
+     * Fallback treatment for all flags.
+     */
     global?: Treatment | TreatmentWithConfig,
+    /**
+     * Fallback treatments for specific flags. It takes precedence over the global fallback treatment.
+     */
     byFlag?: {
       [featureFlagName: string]: Treatment | TreatmentWithConfig
     }