@mostly-good-metrics/javascript 0.6.1 → 0.8.0

package/src/client.ts

@@ -1,11 +1,12 @@
 import { logger, setDebugLogging } from './logger';
 import { createDefaultNetworkClient } from './network';
-import { createDefaultStorage, persistence } from './storage';
+import { createDefaultExperimentStorage, createDefaultStorage, persistence } from './storage';
 import {
+  CachedExperimentVariants,
   EventProperties,
-  Experiment,
   ExperimentsResponse,
   IEventStorage,
+  IExperimentStorage,
   INetworkClient,
   MGMConfiguration,
   MGMEvent,
@@ -32,6 +33,11 @@ import {
 } from './utils';
 
 const FLUSH_DELAY_MS = 100; // Delay between batch sends
+const EXPERIMENTS_CACHE_KEY = 'mgm_experiment_variants';
+const EXPERIMENT_EXPOSURES_KEY = 'mgm_experiment_exposures';
+const EXPERIMENTS_REFETCH_INTERVAL_MS = 60 * 60 * 1000; // Background revalidation at most hourly
+const EXPERIMENTS_FETCH_TIMEOUT_MS = 60 * 1000; // Abort hung experiments fetches so they always settle
+const READY_DEFAULT_TIMEOUT_MS = 5000; // Default ready() timeout, unified across all MGM SDKs
 
 /**
  * Main client for MostlyGoodMetrics.
@@ -50,10 +56,12 @@ export class MostlyGoodMetrics {
   private lifecycleSetup = false;
 
   // A/B testing state
-  private experiments: Map<string, Experiment> = new Map();
+  private assignedVariants: Record<string, string> = {}; // Server-assigned variants
+  private experimentStorage: IExperimentStorage;
   private experimentsLoaded = false;
   private experimentsReadyResolve: (() => void) | null = null;
   private experimentsReadyPromise: Promise<void>;
+  private trackedExposures = new Set<string>(); // (user, experiment, variant) exposure dedup
 
   /**
    * Private constructor - use `configure` to create an instance.
@@ -78,6 +86,9 @@ export class MostlyGoodMetrics {
     // Initialize network client
     this.networkClient = this.config.networkClient ?? createDefaultNetworkClient();
 
+    // Initialize experiment storage (pluggable for React Native AsyncStorage etc.)
+    this.experimentStorage = this.config.experimentStorage ?? createDefaultExperimentStorage();
+
     // Initialize experiments ready promise
     this.experimentsReadyPromise = new Promise((resolve) => {
       this.experimentsReadyResolve = resolve;
@@ -93,8 +104,11 @@ export class MostlyGoodMetrics {
       this.setupLifecycleTracking();
     }
 
-    // Fetch experiments in background
-    void this.fetchExperiments();
+    // Hydrate the experiments cache and revalidate in the background
+    void this.initializeExperiments().catch((e) => {
+      logger.warn('Failed to initialize experiments', e);
+      this.markExperimentsReady();
+    });
   }
 
   /**
@@ -231,18 +245,23 @@ export class MostlyGoodMetrics {
 
   /**
    * Get the variant for an experiment.
-   * Returns the assigned variant ('a', 'b', etc.) or null if experiment not found.
+   * Returns the assigned variant ('a', 'b', etc.), or `fallback` (default null)
+   * if the experiment is unknown or experiments have not loaded yet.
    */
-  static getVariant(experimentName: string): string | null {
-    return MostlyGoodMetrics.instance?.getVariant(experimentName) ?? null;
+  static getVariant(experimentName: string, fallback: string | null = null): string | null {
+    const instance = MostlyGoodMetrics.instance;
+    return instance ? instance.getVariant(experimentName, fallback) : fallback;
   }
 
   /**
-   * Returns a promise that resolves when experiments have been loaded.
-   * Useful for waiting before calling getVariant() to ensure server-side experiments are available.
+   * Returns a promise that resolves when experiments have been loaded, or
+   * after `timeoutMs` (default 5000) elapses - whichever comes first.
+   * Never rejects. Useful for waiting before calling getVariant() to ensure
+   * server-side experiments are available without blocking app startup on a
+   * hanging network.
    */
-  static ready(): Promise<void> {
-    return MostlyGoodMetrics.instance?.ready() ?? Promise.resolve();
+  static ready(timeoutMs: number = READY_DEFAULT_TIMEOUT_MS): Promise<void> {
+    return MostlyGoodMetrics.instance?.ready(timeoutMs) ?? Promise.resolve();
   }
 
   // =====================================================
@@ -345,6 +364,9 @@ export class MostlyGoodMetrics {
    * Profile data is sent to the backend via the $identify event.
    * Debouncing: only sends $identify if payload changed or >24h since last send.
    *
+   * This also invalidates the experiment variants cache and refetches experiments
+   * with the new user ID to handle the "identified wins" aliasing strategy.
+   *
    * @param userId The user's unique identifier
    * @param profile Optional profile data (email, name)
    */
@@ -354,6 +376,7 @@ export class MostlyGoodMetrics {
       return;
     }
 
+    const previousUserId = this.userId ?? this.anonymousIdValue;
     logger.debug(`Identifying user: ${userId}`);
     persistence.setUserId(userId);
 
@@ -362,6 +385,17 @@ export class MostlyGoodMetrics {
     if (profile && (profile.email || profile.name)) {
       this.sendIdentifyEventIfNeeded(userId, profile);
     }
+
+    // If user ID changed, refetch experiments immediately for the new user.
+    // Current in-memory variants keep being served until the response arrives,
+    // then they are swapped atomically - never cleared to null mid-session.
+    // The refetch includes anonymous_id so the server can honor the
+    // "identified wins" aliasing strategy.
+    if (previousUserId !== userId) {
+      logger.debug('User identity changed, refetching experiments');
+      this.resetExperimentsReadyPromise();
+      void this.fetchExperiments();
+    }
   }
 
   /**
@@ -513,59 +547,67 @@ export class MostlyGoodMetrics {
 
   /**
    * Get the variant for an experiment.
-   * Returns the assigned variant ('a', 'b', etc.) or null if experiment not found.
+   * Returns the assigned variant ('a', 'b', etc.), or `fallback` (default null)
+   * if the experiment is unknown or experiments have not loaded yet.
    *
-   * Assignment is deterministic based on userId + experimentName, so the same
-   * user always gets the same variant for the same experiment.
+   * Variants are assigned server-side and cached locally (forever, per user,
+   * with stale-while-revalidate background refreshes). The server ensures the
+   * same user always gets the same variant for the same experiment.
    *
-   * The variant is automatically stored as a super property (experiment_{name}: 'variant')
-   * so it's attached to all subsequent events.
+   * On a hit, the variant is stored as a super property
+   * ($experiment_{name}: 'variant') so it's attached to all subsequent events,
+   * and a $experiment_exposure event is tracked once per
+   * (user, experiment, variant).
    */
-  getVariant(experimentName: string): string | null {
+  getVariant(experimentName: string, fallback: string | null = null): string | null {
     if (!experimentName) {
       logger.warn('getVariant called with empty experimentName');
-      return null;
+      return fallback;
     }
 
-    // Check if we have this experiment cached
-    const experiment = this.experiments.get(experimentName);
-
-    if (!experiment) {
-      if (this.experimentsLoaded) {
-        // Experiments loaded but this one doesn't exist
-        logger.debug(`Experiment not found: ${experimentName}`);
-        return null;
-      }
-      // Experiments not loaded yet - can't assign variant without knowing variants
-      logger.debug(`Experiments not loaded yet, cannot assign variant for: ${experimentName}`);
-      return null;
-    }
+    // Check if we have a server-assigned variant for this experiment
+    const variant = this.assignedVariants[experimentName];
 
-    if (!experiment.variants || experiment.variants.length === 0) {
-      logger.warn(`Experiment ${experimentName} has no variants`);
-      return null;
-    }
+    if (variant) {
+      // Store as super property so it's attached to all events
+      const propertyName = `$experiment_${this.toSnakeCase(experimentName)}`;
+      this.setSuperProperty(propertyName, variant);
 
-    // Get the user ID for deterministic assignment
-    const userId = this.userId ?? this.anonymousIdValue;
+      // Track exposure once per (user, experiment, variant)
+      this.trackExposureIfNeeded(experimentName, variant);
 
-    // Compute deterministic variant assignment
-    const variant = this.computeVariant(userId, experimentName, experiment.variants);
+      logger.debug(`Using server-assigned variant '${variant}' for experiment '${experimentName}'`);
+      return variant;
+    }
 
-    // Store as super property so it's attached to all events
-    const propertyName = `experiment_${this.toSnakeCase(experimentName)}`;
-    this.setSuperProperty(propertyName, variant);
+    // No assigned variant - check if experiments have been loaded
+    if (!this.experimentsLoaded) {
+      logger.debug(`Experiments not loaded yet, cannot get variant for: ${experimentName}`);
+      return fallback;
+    }
 
-    logger.debug(`Assigned variant '${variant}' for experiment '${experimentName}'`);
-    return variant;
+    // Experiments loaded but no assignment for this experiment
+    logger.debug(`No variant assigned for experiment: ${experimentName}`);
+    return fallback;
   }
 
   /**
-   * Returns a promise that resolves when experiments have been loaded.
-   * Useful for waiting before calling getVariant() to ensure server-side experiments are available.
+   * Returns a promise that resolves when experiments have been loaded, or
+   * after `timeoutMs` (default 5000) elapses - whichever comes first.
+   * Never rejects.
+   *
+   * If the timeout fires first, getVariant() keeps returning fallbacks until
+   * the in-flight fetch settles; a late response is still applied atomically,
+   * so variants become available to subsequent calls.
    */
-  ready(): Promise<void> {
-    return this.experimentsReadyPromise;
+  ready(timeoutMs: number = READY_DEFAULT_TIMEOUT_MS): Promise<void> {
+    return new Promise((resolve) => {
+      const timer = setTimeout(resolve, timeoutMs);
+      void this.experimentsReadyPromise.then(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
   }
 
   /**
@@ -787,11 +829,70 @@ export class MostlyGoodMetrics {
   // =====================================================
 
   /**
-   * Fetch experiments from the server.
-   * Called automatically during initialization.
+   * Initialize experiments on startup.
+   *
+   * Flow (stale-while-revalidate, no TTL):
+   * 1. Hydrate exposure dedup flags and the variants cache from the
+   *    (possibly async) experiment storage adapter.
+   * 2. If cached variants exist for the current user, serve them immediately
+   *    (ready() resolves) and revalidate in the background - but only if the
+   *    last fetch was more than an hour ago.
+   * 3. If there is no usable cache, fetch from the server (ready() resolves
+   *    when the fetch settles, even on failure).
+   */
+  private async initializeExperiments(): Promise<void> {
+    const currentUserId = this.userId ?? this.anonymousIdValue;
+
+    // Hydrate exposure flags first so exposure dedup survives restarts
+    await this.hydrateExposures();
+
+    const cached = await this.loadExperimentsCache();
+    if (cached && cached.userId === currentUserId) {
+      const cacheAge = Date.now() - cached.fetchedAt;
+      logger.debug(
+        `Using cached experiment variants (age: ${Math.round(cacheAge / 1000 / 60)}min)`
+      );
+
+      // Serve cached variants immediately - they never expire
+      this.assignedVariants = cached.variants;
+      this.markExperimentsReady();
+
+      // Revalidate in the background, throttled to at most once per hour
+      if (cacheAge >= EXPERIMENTS_REFETCH_INTERVAL_MS) {
+        logger.debug('Cached experiment variants are stale, revalidating in background');
+        void this.fetchExperiments();
+      }
+      return;
+    }
+
+    // No usable cache - fetch from the server
+    await this.fetchExperiments();
+  }
+
+  /**
+   * Fetch experiments from the server and atomically swap in the response.
+   * Called on initialization (when no fresh cache exists) and after identify().
+   * On failure, previously loaded variants keep being served.
+   *
+   * The request is aborted after EXPERIMENTS_FETCH_TIMEOUT_MS so it is
+   * guaranteed to settle. A response that arrives after a ready() timeout is
+   * still applied atomically - late variants are better than none.
    */
   private async fetchExperiments(): Promise<void> {
-    const url = `${this.config.baseURL}/v1/experiments`;
+    const currentUserId = this.userId ?? this.anonymousIdValue;
+
+    // Build URL with user_id for server-side variant assignment.
+    // When the user is identified, also pass the stored anonymous_id so the
+    // server can alias pre-identify assignments ("identified wins", MGM-28).
+    let url = `${this.config.baseURL}/v1/experiments?user_id=${encodeURIComponent(currentUserId)}`;
+    if (currentUserId !== this.anonymousIdValue) {
+      url += `&anonymous_id=${encodeURIComponent(this.anonymousIdValue)}`;
+    }
+
+    // Abort the request if it hangs so this promise is guaranteed to settle
+    // (and markExperimentsReady() is guaranteed to run).
+    const abortController = new AbortController();
+    const abortTimer = setTimeout(() => abortController.abort(), EXPERIMENTS_FETCH_TIMEOUT_MS);
 
     try {
       logger.debug('Fetching experiments...');
@@ -802,26 +903,27 @@ export class MostlyGoodMetrics {
           Authorization: `Bearer ${this.config.apiKey}`,
           'Content-Type': 'application/json',
         },
+        signal: abortController.signal,
       });
 
       if (!response.ok) {
         logger.warn(`Failed to fetch experiments: ${response.status}`);
-        this.markExperimentsReady();
         return;
       }
 
       const data = (await response.json()) as ExperimentsResponse;
 
-      // Cache experiments by ID
-      this.experiments.clear();
-      for (const experiment of data.experiments || []) {
-        this.experiments.set(experiment.id, experiment);
-      }
+      // Atomically swap in the server-assigned variants
+      this.assignedVariants = data.assigned_variants ?? {};
 
-      logger.debug(`Loaded ${this.experiments.size} experiments`);
+      // Persist to the experiment storage adapter (with last-fetch timestamp)
+      await this.saveExperimentsCache(currentUserId, this.assignedVariants);
+
+      logger.debug(`Loaded ${Object.keys(this.assignedVariants).length} assigned variants`);
     } catch (e) {
       logger.warn('Failed to fetch experiments', e);
     } finally {
+      clearTimeout(abortTimer);
       this.markExperimentsReady();
     }
   }
@@ -838,19 +940,108 @@ export class MostlyGoodMetrics {
   }
 
   /**
-   * Compute a deterministic variant assignment based on userId and experimentName.
-   * Same user + same experiment = same variant (consistent assignment).
+   * Arm a new ready() promise for an in-flight refetch (e.g. after identify).
+   * No-op if the current promise is still pending - it will be resolved by
+   * whichever fetch settles first.
    */
-  private computeVariant(userId: string, experimentName: string, variants: string[]): string {
-    // Create a deterministic hash from userId + experimentName
-    const hashInput = `${userId}:${experimentName}`;
-    const hash = this.simpleHash(hashInput);
+  private resetExperimentsReadyPromise(): void {
+    if (this.experimentsReadyResolve !== null) {
+      return;
+    }
+    this.experimentsReadyPromise = new Promise((resolve) => {
+      this.experimentsReadyResolve = resolve;
+    });
+  }
+
+  /**
+   * Track a $experiment_exposure event the first time a (user, experiment,
+   * variant) combination is returned by getVariant(). Dedup flags are
+   * persisted via the experiment storage adapter so exposures are not
+   * re-tracked across restarts.
+   */
+  private trackExposureIfNeeded(experimentName: string, variant: string): void {
+    const currentUserId = this.userId ?? this.anonymousIdValue;
+    const exposureKey = `${currentUserId}::${experimentName}::${variant}`;
+
+    if (this.trackedExposures.has(exposureKey)) {
+      return;
+    }
+    this.trackedExposures.add(exposureKey);
+
+    this.track(SystemEvents.EXPERIMENT_EXPOSURE, {
+      [SystemProperties.EXPERIMENT_NAME]: experimentName,
+      [SystemProperties.VARIANT]: variant,
+    });
+
+    void this.persistExposures();
+  }
 
-    // Convert hash to a positive number and mod by variant count
-    const hashNum = Math.abs(parseInt(hash, 16));
-    const variantIndex = hashNum % variants.length;
+  /**
+   * Hydrate persisted exposure dedup flags from the experiment storage adapter.
+   */
+  private async hydrateExposures(): Promise<void> {
+    try {
+      const raw = await this.experimentStorage.getItem(EXPERIMENT_EXPOSURES_KEY);
+      if (raw) {
+        const parsed = JSON.parse(raw) as unknown;
+        if (Array.isArray(parsed)) {
+          this.trackedExposures = new Set(parsed.filter((k): k is string => typeof k === 'string'));
+        }
+      }
+    } catch (e) {
+      logger.debug('Failed to load experiment exposures', e);
+    }
+  }
 
-    return variants[variantIndex];
+  /**
+   * Persist exposure dedup flags via the experiment storage adapter.
+   */
+  private async persistExposures(): Promise<void> {
+    try {
+      await this.experimentStorage.setItem(
+        EXPERIMENT_EXPOSURES_KEY,
+        JSON.stringify([...this.trackedExposures])
+      );
+    } catch (e) {
+      logger.debug('Failed to persist experiment exposures', e);
+    }
+  }
+
+  /**
+   * Load experiment variants from the experiment storage adapter.
+   */
+  private async loadExperimentsCache(): Promise<CachedExperimentVariants | null> {
+    try {
+      const cached = await this.experimentStorage.getItem(EXPERIMENTS_CACHE_KEY);
+      if (!cached) {
+        return null;
+      }
+      return JSON.parse(cached) as CachedExperimentVariants;
+    } catch (e) {
+      logger.debug('Failed to load experiments cache', e);
+      return null;
+    }
+  }
+
+  /**
+   * Save experiment variants via the experiment storage adapter.
+   * `fetchedAt` doubles as the last-fetch timestamp used to throttle
+   * background revalidation - the cache itself never expires.
+   */
+  private async saveExperimentsCache(
+    userId: string,
+    variants: Record<string, string>
+  ): Promise<void> {
+    try {
+      const cached: CachedExperimentVariants = {
+        userId,
+        variants,
+        fetchedAt: Date.now(),
+      };
+      await this.experimentStorage.setItem(EXPERIMENTS_CACHE_KEY, JSON.stringify(cached));
+    } catch (e) {
+      logger.debug('Failed to save experiments cache', e);
+    }
   }
 
   /**

package/src/index.ts

@@ -45,6 +45,7 @@ export type {
   MGMErrorType,
   SendResult,
   IEventStorage,
+  IExperimentStorage,
   INetworkClient,
   UserProfile,
   Experiment,
@@ -64,7 +65,14 @@ export {
 } from './types';
 
 // Storage implementations (for custom storage adapters)
-export { InMemoryEventStorage, LocalStorageEventStorage, createDefaultStorage } from './storage';
+export {
+  InMemoryEventStorage,
+  LocalStorageEventStorage,
+  createDefaultStorage,
+  InMemoryExperimentStorage,
+  LocalStorageExperimentStorage,
+  createDefaultExperimentStorage,
+} from './storage';
 
 // Network client (for custom network implementations)
 export { FetchNetworkClient, createDefaultNetworkClient } from './network';

package/src/storage.ts

@@ -1,5 +1,12 @@
 import { logger } from './logger';
-import { Constraints, EventProperties, IEventStorage, MGMError, MGMEvent } from './types';
+import {
+  Constraints,
+  EventProperties,
+  IEventStorage,
+  IExperimentStorage,
+  MGMError,
+  MGMEvent,
+} from './types';
 
 const STORAGE_KEY = 'mostlygoodmetrics_events';
 const USER_ID_KEY = 'mostlygoodmetrics_user_id';
@@ -227,6 +234,56 @@ export function createDefaultStorage(maxEvents: number): IEventStorage {
   return new InMemoryEventStorage(maxEvents);
 }
 
+/**
+ * localStorage-backed experiment storage adapter (default in browsers).
+ */
+export class LocalStorageExperimentStorage implements IExperimentStorage {
+  getItem(key: string): string | null {
+    try {
+      return localStorage.getItem(key);
+    } catch (e) {
+      logger.debug(`Failed to read '${key}' from localStorage`, e);
+      return null;
+    }
+  }
+
+  setItem(key: string, value: string): void {
+    try {
+      localStorage.setItem(key, value);
+    } catch (e) {
+      logger.debug(`Failed to write '${key}' to localStorage`, e);
+    }
+  }
+}
+
+/**
+ * In-memory experiment storage adapter.
+ * Used as a fallback when localStorage is not available, or for testing.
+ */
+export class InMemoryExperimentStorage implements IExperimentStorage {
+  private values = new Map<string, string>();
+
+  getItem(key: string): string | null {
+    return this.values.get(key) ?? null;
+  }
+
+  setItem(key: string, value: string): void {
+    this.values.set(key, value);
+  }
+}
+
+/**
+ * Create the appropriate experiment storage implementation for the environment.
+ * React Native apps should inject an AsyncStorage-backed adapter via the
+ * `experimentStorage` configuration option instead.
+ */
+export function createDefaultExperimentStorage(): IExperimentStorage {
+  if (isLocalStorageAvailable()) {
+    return new LocalStorageExperimentStorage();
+  }
+  return new InMemoryExperimentStorage();
+}
+
 /**
  * Persistence helpers for user ID and app version.
  * Uses cookies first (for cross-subdomain support), then localStorage as fallback.

package/src/types.ts

@@ -124,6 +124,15 @@ export interface MGMConfiguration {
    */
   networkClient?: INetworkClient;
 
+  /**
+   * Custom key-value storage adapter used for the experiments variant cache
+   * and exposure-event deduplication flags.
+   * The adapter may be asynchronous (e.g. React Native's AsyncStorage).
+   * If not provided, uses localStorage in browsers or in-memory storage
+   * in non-browser environments.
+   */
+  experimentStorage?: IExperimentStorage;
+
   /**
    * Callback invoked when a network error occurs.
    * Useful for reporting errors to external services like Sentry.
@@ -138,11 +147,18 @@ export interface MGMConfiguration {
 export interface ResolvedConfiguration extends Required<
   Omit<
     MGMConfiguration,
-    'storage' | 'networkClient' | 'onError' | 'anonymousId' | 'cookieDomain' | 'disableCookies'
+    | 'storage'
+    | 'networkClient'
+    | 'experimentStorage'
+    | 'onError'
+    | 'anonymousId'
+    | 'cookieDomain'
+    | 'disableCookies'
   >
 > {
   storage?: IEventStorage;
   networkClient?: INetworkClient;
+  experimentStorage?: IExperimentStorage;
   onError?: (error: MGMError) => void;
 }
 
@@ -335,6 +351,25 @@ export interface IEventStorage {
   clear(): Promise<void>;
 }
 
+/**
+ * Minimal key-value storage interface used for the experiments cache and
+ * exposure-event deduplication flags.
+ *
+ * Implementations may be synchronous (e.g. localStorage) or asynchronous
+ * (e.g. React Native's AsyncStorage) - the SDK awaits both forms.
+ */
+export interface IExperimentStorage {
+  /**
+   * Get a value by key. Returns null (or resolves to null) if not present.
+   */
+  getItem(key: string): string | null | Promise<string | null>;
+
+  /**
+   * Set a value for a key.
+   */
+  setItem(key: string, value: string): void | Promise<void>;
+}
+
 /**
  * Interface for network client implementations.
  */
@@ -390,6 +425,7 @@ export const SystemEvents = {
   APP_OPENED: '$app_opened',
   APP_BACKGROUNDED: '$app_backgrounded',
   IDENTIFY: '$identify',
+  EXPERIMENT_EXPOSURE: '$experiment_exposure',
 } as const;
 
 /**
@@ -423,10 +459,35 @@ export interface Experiment {
 }
 
 /**
- * Response from the experiments API endpoint.
+ * Response from the experiments API endpoint when user_id is provided.
+ * Contains only the assigned variants for the user.
  */
 export interface ExperimentsResponse {
-  experiments: Experiment[];
+  /**
+   * Server-assigned variants for the user.
+   * Maps experiment ID to the assigned variant (e.g., {"button-color": "a"}).
+   */
+  assigned_variants: Record<string, string>;
+}
+
+/**
+ * Cached experiment variants stored in localStorage.
+ */
+export interface CachedExperimentVariants {
+  /**
+   * The user ID these variants are assigned to.
+   */
+  userId: string;
+
+  /**
+   * Map of experiment ID to assigned variant.
+   */
+  variants: Record<string, string>;
+
+  /**
+   * Timestamp when the cache was created (ms since epoch).
+   */
+  fetchedAt: number;
 }
 
 /**
@@ -438,6 +499,8 @@ export const SystemProperties = {
   VERSION: '$version',
   PREVIOUS_VERSION: '$previous_version',
   SDK: '$sdk',
+  EXPERIMENT_NAME: '$experiment_name',
+  VARIANT: '$variant',
 } as const;
 
 /**

package/src/utils.ts

@@ -212,6 +212,7 @@ export function resolveConfiguration(config: MGMConfiguration): ResolvedConfigur
     sdkVersion: config.sdkVersion ?? '',
     storage: config.storage,
     networkClient: config.networkClient,
+    experimentStorage: config.experimentStorage,
     onError: config.onError,
   };
 }