@umituz/react-native-subscription 2.37.38 → 2.37.40

package/src/domains/subscription/application/initializer/BackgroundInitializer.ts

@@ -20,6 +20,14 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
   };
 
   const attemptInitWithRetry = async (revenueCatUserId?: string, attempt = 0): Promise<void> => {
+    // Abort if user changed since retry was scheduled
+    if (attempt > 0 && lastUserId !== revenueCatUserId) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log('[BackgroundInitializer] Aborting retry - user changed');
+      }
+      return;
+    }
+
     try {
       await initializeInBackground(revenueCatUserId);
       lastUserId = revenueCatUserId;
@@ -49,7 +57,6 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
   };
 
   const debouncedInitialize = (revenueCatUserId?: string): void => {
-    // Clear any pending initialization or retry
     if (debounceTimer) {
       clearTimeout(debounceTimer);
     }
@@ -58,7 +65,6 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
       retryTimer = null;
     }
 
-    // If userId hasn't changed AND last init succeeded, skip
     if (lastUserId === revenueCatUserId && lastInitSucceeded) {
       if (typeof __DEV__ !== 'undefined' && __DEV__) {
         console.log('[BackgroundInitializer] UserId unchanged and init succeeded, skipping');
@@ -70,6 +76,13 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
       if (typeof __DEV__ !== 'undefined' && __DEV__) {
         console.log('[BackgroundInitializer] Auth state listener triggered, reinitializing with userId:', revenueCatUserId || '(undefined - anonymous)');
       }
+
+      // Reset subscription state on logout to prevent stale cache
+      if (!revenueCatUserId && lastUserId) {
+        await SubscriptionManager.reset();
+        lastInitSucceeded = false;
+      }
+
       void attemptInitWithRetry(revenueCatUserId);
     }, AUTH_STATE_DEBOUNCE_MS);
   };

package/src/domains/subscription/application/initializer/ServiceConfigurator.ts

@@ -5,6 +5,7 @@ import { SubscriptionSyncService } from "../SubscriptionSyncService";
 import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
 import type { CustomerInfo } from "react-native-purchases";
 import type { PackageType } from "../../../revenuecat/core/types/RevenueCatTypes";
+import { PURCHASE_SOURCE, PERIOD_TYPE, type PurchaseSource, type PeriodType } from "../../core/SubscriptionConstants";
 
 export function configureServices(config: SubscriptionInitConfig, apiKey: string): SubscriptionSyncService {
   const { entitlementId, credits, creditPackages, getFirebaseAuth, showAuthModal, onCreditsUpdated, getAnonymousUserId } = config;
@@ -31,7 +32,10 @@ export function configureServices(config: SubscriptionInitConfig, apiKey: string
         c: CustomerInfo,
         s?: string,
         pkgType?: PackageType | null
-      ) => syncService.handlePurchase(u, p, c, s as any, pkgType),
+      ) => {
+        const validSource = s && Object.values(PURCHASE_SOURCE).includes(s as PurchaseSource) ? s as PurchaseSource : undefined;
+        return syncService.handlePurchase(u, p, c, validSource, pkgType);
+      },
       onRenewalDetected: (
         u: string,
         p: string,
@@ -45,7 +49,10 @@ export function configureServices(config: SubscriptionInitConfig, apiKey: string
         exp?: string,
         willR?: boolean,
         pt?: string
-      ) => syncService.handlePremiumStatusChanged(u, isP, pId, exp, willR, pt as any),
+      ) => {
+        const validPeriodType = pt && Object.values(PERIOD_TYPE).includes(pt as PeriodType) ? pt as PeriodType : undefined;
+        return syncService.handlePremiumStatusChanged(u, isP, pId, exp, willR, validPeriodType);
+      },
       onCreditsUpdated,
     },
     apiKey,

package/src/domains/subscription/application/statusChangeHandlers.ts

@@ -1,9 +1,6 @@
-import type { RevenueCatData } from "../../revenuecat/core/types";
 import type { PeriodType } from "../core/SubscriptionConstants";
-import { PURCHASE_SOURCE, PURCHASE_TYPE } from "../core/SubscriptionConstants";
 import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
 import { emitCreditsUpdated } from "./syncEventEmitter";
-import { generateStatusSyncId } from "./syncIdGenerators";
 
 export const handleExpiredSubscription = async (userId: string): Promise<void> => {
   await getCreditsRepository().syncExpiredStatus(userId);
@@ -16,32 +13,22 @@ export const handlePremiumStatusSync = async (
   productId: string,
   expiresAt: string | null,
   willRenew: boolean,
-  periodType: PeriodType | null
+  periodType: PeriodType | null,
+  unsubscribeDetectedAt?: string | null,
+  billingIssueDetectedAt?: string | null,
+  store?: string | null,
+  ownershipType?: string | null
 ): Promise<void> => {
-
-  const revenueCatData: RevenueCatData = {
-    expirationDate: expiresAt,
-    willRenew,
+  await getCreditsRepository().syncPremiumMetadata(userId, {
     isPremium,
-    periodType,
-    packageType: null,
-    originalTransactionId: null,
-    unsubscribeDetectedAt: null,
-    billingIssueDetectedAt: null,
-    store: null,
-    ownershipType: null
-  };
-
-  const statusSyncId = generateStatusSyncId(userId, isPremium);
-
-  await getCreditsRepository().initializeCredits(
-    userId,
-    statusSyncId,
+    willRenew,
+    expirationDate: expiresAt,
     productId,
-    PURCHASE_SOURCE.SETTINGS,
-    revenueCatData,
-    PURCHASE_TYPE.INITIAL
-  );
-
+    periodType,
+    unsubscribeDetectedAt: unsubscribeDetectedAt ?? null,
+    billingIssueDetectedAt: billingIssueDetectedAt ?? null,
+    store: store ?? null,
+    ownershipType: ownershipType ?? null,
+  });
   emitCreditsUpdated(userId);
 };

package/src/domains/subscription/application/syncIdGenerators.ts

@@ -9,7 +9,3 @@ export const generateRenewalId = (originalTransactionId: string | null, productI
     ? `renewal_${originalTransactionId}_${expirationDate}`
     : `renewal_${productId}_${Date.now()}`;
 };
-
-export const generateStatusSyncId = (userId: string, isPremium: boolean): string => {
-  return `status_sync_${userId}_${isPremium ? 'premium' : 'free'}`;
-};

package/src/domains/subscription/constants/thresholds.ts

@@ -1,10 +1 @@
-/**
- * Subscription Threshold Constants
- * Centralized threshold values for subscription UI logic
- */
-
-/**
- * Number of days before expiration to show warnings
- * Used across subscription UI components for consistency
- */
 export const EXPIRATION_WARNING_THRESHOLD_DAYS = 7;

package/src/domains/subscription/core/SubscriptionConstants.ts

@@ -6,8 +6,6 @@ export const USER_TIER = {
 
 export type UserTierType = (typeof USER_TIER)[keyof typeof USER_TIER];
 
-export const DEFAULT_ENTITLEMENT_ID = 'premium';
-
 export const SUBSCRIPTION_STATUS = {
   ACTIVE: 'active',
   TRIAL: 'trial',
@@ -63,5 +61,3 @@ export const PURCHASE_TYPE = {
 } as const;
 
 export type PurchaseType = (typeof PURCHASE_TYPE)[keyof typeof PURCHASE_TYPE];
-
-

package/src/domains/subscription/core/SubscriptionStatus.ts

@@ -1,21 +1,15 @@
 import { timezoneService } from "@umituz/react-native-design-system";
-import { 
-  SUBSCRIPTION_STATUS, 
-  PERIOD_TYPE, 
-  type PeriodType, 
-  type SubscriptionStatusType 
+import {
+  SUBSCRIPTION_STATUS,
+  type SubscriptionStatusType
 } from "./SubscriptionConstants";
-import { 
-  InactiveStatusHandler, 
-  TrialStatusHandler, 
-  ActiveStatusHandler 
+import {
+  InactiveStatusHandler,
+  TrialStatusHandler,
+  ActiveStatusHandler
 } from "./SubscriptionStatusHandlers";
 
-export {
-  PERIOD_TYPE,
-  type PeriodType,
-  type SubscriptionStatusType
-};
+export type { SubscriptionStatusType };
 
 export interface SubscriptionStatus {
     isPremium: boolean;
@@ -25,7 +19,7 @@ export interface SubscriptionStatus {
     customerId?: string | null;
     syncedAt?: string | null;
     status?: SubscriptionStatusType;
-    periodType?: string; // Raw value from RevenueCat SDK (NORMAL, INTRO, TRIAL)
+    periodType?: string;
     isTrialing?: boolean;
 }
 
@@ -41,7 +35,7 @@ export const createDefaultSubscriptionStatus = (): SubscriptionStatus => ({
 
 export const isSubscriptionValid = (status: SubscriptionStatus | null): boolean => {
     if (!status || !status.isPremium) return false;
-    if (!status.expiresAt) return true; // Lifetime
+    if (!status.expiresAt) return true;
     return timezoneService.isFuture(new Date(status.expiresAt));
 };
 
@@ -49,18 +43,14 @@ export interface StatusResolverInput {
     isPremium: boolean;
     willRenew?: boolean;
     isExpired?: boolean;
-    periodType?: string; // Raw value from RevenueCat SDK (NORMAL, INTRO, TRIAL)
+    periodType?: string;
 }
 
-// Singleton Chain Instance
 const inactiveHandler = new InactiveStatusHandler();
 inactiveHandler
     .setNext(new TrialStatusHandler())
     .setNext(new ActiveStatusHandler());
 
-/**
- * Resolves subscription status using Chain of Responsibility Pattern.
- */
 export const resolveSubscriptionStatus = (input: StatusResolverInput): SubscriptionStatusType => {
     return inactiveHandler.handle(input);
 };

package/src/domains/subscription/core/SubscriptionStatusHandlers.ts

@@ -1,7 +1,7 @@
-import { 
-  SUBSCRIPTION_STATUS, 
-  PERIOD_TYPE, 
-  type SubscriptionStatusType 
+import {
+  SUBSCRIPTION_STATUS,
+  PERIOD_TYPE,
+  type SubscriptionStatusType
 } from "./SubscriptionConstants";
 import type { StatusResolverInput } from "./SubscriptionStatus";
 
@@ -20,7 +20,6 @@ abstract class BaseStatusHandler {
     }
 }
 
-/** Handles Expired or No-Premium cases */
 export class InactiveStatusHandler extends BaseStatusHandler {
     handle(input: StatusResolverInput): SubscriptionStatusType {
         const isExpired = input.isExpired === true;
@@ -32,7 +31,6 @@ export class InactiveStatusHandler extends BaseStatusHandler {
     }
 }
 
-/** Handles Trial-related states */
 export class TrialStatusHandler extends BaseStatusHandler {
     handle(input: StatusResolverInput): SubscriptionStatusType {
         if (input.periodType === PERIOD_TYPE.TRIAL) {
@@ -42,7 +40,6 @@ export class TrialStatusHandler extends BaseStatusHandler {
     }
 }
 
-/** Handles Canceled-Active states */
 export class ActiveStatusHandler extends BaseStatusHandler {
     handle(input: StatusResolverInput): SubscriptionStatusType {
         if (input.willRenew === false) {

package/src/domains/subscription/infrastructure/handlers/PurchaseStatusResolver.ts

@@ -38,7 +38,7 @@ export class PurchaseStatusResolver {
         isSandbox: entitlement.isSandbox ?? false,
         periodType: entitlement.periodType ?? null,
         packageType: detectedPackageType,
-        store: null,
+        store: entitlement.store ?? null,
         gracePeriodExpiresDate: null,
         unsubscribeDetectedAt: toDate(entitlement.unsubscribeDetectedAt),
       };

package/src/domains/subscription/infrastructure/hooks/subscriptionQueryKeys.ts

@@ -1,19 +1,6 @@
-/**
- * Subscription Query Keys
- * TanStack Query keys and constants for subscription state
- */
-
-/** Query cache time constants */
-
-
-/**
- * Query keys for TanStack Query
- */
 export const SUBSCRIPTION_QUERY_KEYS = {
   packages: ["subscription", "packages"] as const,
   initialized: (userId: string) =>
     ["subscription", "initialized", userId] as const,
   customerInfo: ["subscription", "customerInfo"] as const,
 } as const;
-
-

package/src/domains/subscription/infrastructure/hooks/usePurchasePackage.ts

@@ -1,10 +1,3 @@
-/**
- * Purchase Package Hook
- * TanStack mutation for purchasing subscription packages
- * Credits are initialized by CustomerInfoListener (not here to avoid duplicates)
- * Auth info automatically read from @umituz/react-native-auth
- */
-
 import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
 import type { PurchasesPackage } from "react-native-purchases";
 import { useAlert } from "@umituz/react-native-design-system";
@@ -19,17 +12,11 @@ import { subscriptionStatusQueryKeys } from "../../presentation/useSubscriptionS
 import { creditsQueryKeys } from "../../../credits/presentation/creditsQueryKeys";
 import { getErrorMessage } from "../../../revenuecat/core/errors";
 
-/** Purchase mutation result - simplified for presentation layer */
 interface PurchaseMutationResult {
   success: boolean;
   productId: string;
 }
 
-/**
- * Purchase a subscription package
- * Credits are initialized by CustomerInfoListener when entitlement becomes active
- * Auth info automatically read from auth store
- */
 export const usePurchasePackage = () => {
   const userId = useAuthStore(selectUserId);
   const isAnonymous = useAuthStore(selectIsAnonymous);
@@ -51,13 +38,11 @@ export const usePurchasePackage = () => {
         console.log(`[Purchase] Initializing and purchasing. User: ${userId}`);
       }
 
-      await SubscriptionManager.initialize(userId);
       const success = await SubscriptionManager.purchasePackage(pkg, userId);
 
       return { success, productId };
     },
     onSuccess: (result) => {
-
       if (result.success) {
         showSuccess("Purchase Successful", "Your subscription is now active!");
         queryClient.invalidateQueries({
@@ -76,11 +61,8 @@ export const usePurchasePackage = () => {
       }
     },
     onError: (error) => {
-
-      // Use map-based lookup - O(1) complexity
       const errorInfo = getErrorMessage(error);
 
-      // Don't show alert for user cancellation
       if (!errorInfo.shouldShowAlert) {
         return;
       }

package/src/domains/subscription/infrastructure/hooks/useRestorePurchase.ts

@@ -1,15 +1,9 @@
-/**
- * Restore Purchase Hook
- * TanStack mutation for restoring previous purchases
- * Credits are initialized by CustomerInfoListener (not here to avoid duplicates)
- * Auth info automatically read from @umituz/react-native-auth
- */
-
 import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
 import { useAlert } from "@umituz/react-native-design-system";
 import {
   useAuthStore,
   selectUserId,
+  selectIsAnonymous,
 } from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionManager";
 import { SUBSCRIPTION_QUERY_KEYS } from "./subscriptionQueryKeys";
@@ -22,29 +16,23 @@ interface RestoreResult {
   productId: string | null;
 }
 
-/**
- * Restore previous purchases
- * Credits are initialized by CustomerInfoListener when entitlement becomes active
- * Auth info automatically read from auth store
- */
 export const useRestorePurchase = () => {
   const userId = useAuthStore(selectUserId);
+  const isAnonymous = useAuthStore(selectIsAnonymous);
   const queryClient = useQueryClient();
   const { showSuccess, showInfo, showError } = useAlert();
 
   return useMutation({
     mutationFn: async (): Promise<RestoreResult> => {
-      if (!userId) {
+      if (!userId || isAnonymous) {
         throw new Error("User not authenticated");
       }
 
-      await SubscriptionManager.initialize(userId);
       const result = await SubscriptionManager.restore(userId);
       return result;
     },
     onSuccess: (result) => {
       if (result.success) {
-        // Invalidate queries to refresh data
         queryClient.invalidateQueries({
           queryKey: SUBSCRIPTION_QUERY_KEYS.packages,
         });
@@ -57,7 +45,6 @@ export const useRestorePurchase = () => {
           });
         }
 
-        // Show user feedback
         if (result.productId) {
           showSuccess("Restore Successful", "Your subscription has been restored!");
         } else {
@@ -66,7 +53,6 @@ export const useRestorePurchase = () => {
       }
     },
     onError: (error) => {
-      // Use map-based lookup - O(1) complexity
       const errorInfo = getErrorMessage(error);
       showError(errorInfo.title, errorInfo.message);
     },

package/src/domains/subscription/infrastructure/hooks/useRevenueCatTrialEligibility.ts

@@ -1,9 +1,3 @@
-/**
- * useRevenueCatTrialEligibility Hook
- * Checks if user is eligible for introductory offers via RevenueCat
- * Uses Apple's native mechanism for trial eligibility
- */
-
 import { useState, useEffect, useCallback, useRef } from "react";
 import { getRevenueCatService } from "../services/RevenueCatService";
 import {
@@ -14,24 +8,14 @@ import {
   type TrialEligibilityMap,
 } from "../utils/trialEligibilityUtils";
 
-
 interface UseRevenueCatTrialEligibilityResult {
-  /** Map of product IDs to their trial eligibility */
   eligibilityMap: TrialEligibilityMap;
-  /** Whether eligibility check is in progress */
   isLoading: boolean;
-  /** Whether any product has an eligible trial */
   hasEligibleTrial: boolean;
-  /** Check eligibility for specific product IDs */
   checkEligibility: (productIds: string[]) => Promise<void>;
-  /** Get eligibility for a specific product */
   getProductEligibility: (productId: string) => ProductTrialEligibility | null;
 }
 
-/**
- * Hook to check trial eligibility via RevenueCat
- * Uses Apple's introductory offer eligibility system
- */
 export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityResult {
   const [eligibilityMap, setEligibilityMap] = useState<TrialEligibilityMap>({});
   const [isLoading, setIsLoading] = useState(false);
@@ -95,4 +79,3 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
     getProductEligibility,
   };
 }
-

package/src/domains/subscription/infrastructure/hooks/useSubscriptionPackages.ts

@@ -1,13 +1,3 @@
-/**
- * Subscription Packages Hook
- * TanStack query for fetching available packages (offerings)
- * Auth info automatically read from @umituz/react-native-auth
- *
- * IMPORTANT: Packages (offerings) are NOT user-specific - they're the same
- * for all users. We only need RevenueCat to be initialized, not necessarily
- * for a specific user. User-specific checks belong in useSubscriptionStatus.
- */
-
 import { useQuery, useQueryClient } from "@umituz/react-native-design-system";
 import { useEffect, useRef, useSyncExternalStore } from "react";
 import {
@@ -20,27 +10,18 @@ import {
   SUBSCRIPTION_QUERY_KEYS,
 } from "./subscriptionQueryKeys";
 
-/**
- * Fetch available subscription packages
- * Works for both authenticated and anonymous users
- * Auth info automatically read from auth store
- */
 export const useSubscriptionPackages = () => {
   const userId = useAuthStore(selectUserId);
   const isConfigured = SubscriptionManager.isConfigured();
   const queryClient = useQueryClient();
   const prevUserIdRef = useRef(userId);
 
-  // Reactive initialization state - triggers re-render when BackgroundInitializer completes
   const initState = useSyncExternalStore(
     initializationState.subscribe,
     initializationState.getSnapshot,
     initializationState.getSnapshot,
   );
 
-  // Packages (offerings) are NOT user-specific - same for all users.
-  // We only need RevenueCat to be initialized at all.
-  // Use reactive state OR direct manager check for backwards compatibility.
   const isInitialized = initState.initialized || SubscriptionManager.isInitialized();
 
   const query = useQuery({

package/src/domains/subscription/infrastructure/hooks/useSubscriptionQueries.ts

@@ -1,9 +1,3 @@
-/**
- * Subscription TanStack Query Hooks
- * Server state management for RevenueCat subscriptions
- * Generic hooks for 100+ apps
- */
-
 export { useSubscriptionPackages } from "./useSubscriptionPackages";
 export { usePurchasePackage } from "./usePurchasePackage";
 export { useRestorePurchase } from "./useRestorePurchase";

package/src/domains/subscription/infrastructure/managers/subscriptionManagerUtils.ts

@@ -1,25 +1,14 @@
-/**
- * Subscription Manager Utilities
- * Validation and helper functions for SubscriptionManager
- */
-
 import type { SubscriptionManagerConfig } from "./SubscriptionManager.types";
 
 import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
 import { SubscriptionInternalState } from "./SubscriptionInternalState";
 
-/**
- * Validate that manager is configured
- */
 export function ensureConfigured(config: SubscriptionManagerConfig | null): void {
     if (!config) {
         throw new Error("SubscriptionManager not configured");
     }
 }
 
-/**
- * Get current user ID or throw
- */
 export function getCurrentUserIdOrThrow(state: SubscriptionInternalState): string {
     const userId = state.initCache.getCurrentUserId();
     if (userId === null || userId === undefined) {
@@ -28,9 +17,6 @@ export function getCurrentUserIdOrThrow(state: SubscriptionInternalState): strin
     return userId;
 }
 
-/**
- * Get service instance or initialize
- */
 export function getOrCreateService(
     currentInstance: IRevenueCatService | null
 ): IRevenueCatService {
@@ -48,9 +34,6 @@ export function getOrCreateService(
     return serviceInstance;
 }
 
-/**
- * Validate service is available
- */
 export function ensureServiceAvailable(service: IRevenueCatService | null): void {
     if (!service) {
         throw new Error("Service instance not available");

package/src/domains/subscription/infrastructure/state/initializationState.ts

@@ -1,17 +1,3 @@
-/**
- * Reactive Initialization State
- * Uses useSyncExternalStore pattern to make SubscriptionManager
- * initialization state reactive for React components.
- *
- * Problem: SubscriptionManager.isInitializedForUser() is a plain method call.
- * When BackgroundInitializer completes (500ms+ after auth), React components
- * don't re-render because there's no reactive state change.
- *
- * Solution: This module provides a subscribe/getSnapshot interface that
- * React's useSyncExternalStore can use to trigger re-renders when
- * initialization completes.
- */
-
 type Listener = () => void;
 
 interface InitState {
@@ -34,27 +20,16 @@ export const initializationState = {
 
   getSnapshot: (): InitState => state,
 
-  /**
-   * Called by SubscriptionManager after successful initialization.
-   * Triggers re-render in all subscribed React components.
-   */
   markInitialized: (userId: string | null): void => {
     state = { initialized: true, userId };
     notifyListeners();
   },
 
-  /**
-   * Called when initialization starts for a new user (e.g., user switch).
-   * Resets the state so queries know they need to wait.
-   */
   markPending: (): void => {
     state = { initialized: false, userId: null };
     notifyListeners();
   },
 
-  /**
-   * Check if initialized for a specific user.
-   */
   isInitializedForUser: (userId: string | null): boolean => {
     return state.initialized && state.userId === userId;
   },

package/src/domains/subscription/infrastructure/utils/InitializationCache.ts

@@ -1,31 +1,16 @@
-/**
- * Initialization Cache
- * Manages promise caching and user state for initialization
- * Thread-safe: Uses atomic promise-based locking pattern
- */
-
 export class InitializationCache {
     private initPromise: Promise<boolean> | null = null;
     private currentUserId: string | null = null;
-    // Track which userId the promise is for
     private promiseUserId: string | null = null;
-    // Track promise completion state
     private promiseCompleted = true;
-    // Pending initialization queue
     private pendingQueue: Map<string, Promise<boolean>> = new Map();
 
-    /**
-     * Atomically check if reinitialization is needed AND reserve the slot
-     * Returns: { shouldInit: boolean, existingPromise: Promise | null }
-     */
     tryAcquireInitialization(userId: string): { shouldInit: boolean; existingPromise: Promise<boolean> | null } {
-        // Check if there's already a pending promise for this user in the queue
         const queuedPromise = this.pendingQueue.get(userId);
         if (queuedPromise) {
             return { shouldInit: false, existingPromise: queuedPromise };
         }
 
-        // If already initialized for this user and promise completed successfully
         if (
             this.initPromise &&
             this.currentUserId === userId &&
@@ -35,7 +20,6 @@ export class InitializationCache {
             return { shouldInit: false, existingPromise: this.initPromise };
         }
 
-        // Different user or not initialized - need to initialize
         return { shouldInit: true, existingPromise: null };
     }
 
@@ -45,9 +29,6 @@ export class InitializationCache {
 
         const targetUserId = userId;
 
-        // Build the handled chain that ALWAYS resolves (never rejects).
-        // This is critical: pendingQueue must store a non-rejectable promise so that
-        // callers who receive it via tryAcquireInitialization never get an unhandled rejection.
         const chain: Promise<boolean> = promise
             .then((result) => {
                 if (result && this.promiseUserId === targetUserId) {
@@ -67,11 +48,9 @@ export class InitializationCache {
                 return false as boolean;
             })
             .finally(() => {
-                // Remove from queue when complete
                 this.pendingQueue.delete(targetUserId);
             });
 
-        // Store the chain (not the original promise) so callers never receive a rejection
         this.initPromise = chain;
         this.pendingQueue.set(userId, chain);
     }