@oxyhq/services 6.9.11 → 6.9.13

package/src/ui/hooks/useFollow.ts

@@ -1,114 +1,150 @@
 import { useCallback, useMemo, useEffect } from 'react';
 import { useFollowStore } from '../stores/followStore';
 import { useOxy } from '../context/OxyContext';
+import type { OxyServices } from '@oxyhq/core';
+import { useShallow } from 'zustand/react/shallow';
 
+/**
+ * useFollow — Hook for follow state management.
+ *
+ * Performance fixes:
+ * 1. Uses granular Zustand selectors instead of subscribing to the entire store.
+ *    The old `useFollowStore()` caused every component using this hook to re-render
+ *    on ANY store change (any user's follow status, loading state, error, or count).
+ * 2. Callbacks depend on primitive values (userId, isFollowing) not object references,
+ *    so they remain stable across renders.
+ * 3. Store action methods are accessed via getState() in callbacks to avoid
+ *    subscribing to the action functions themselves (they never change but including
+ *    them in selectors would cause unnecessary selector recalculations).
+ */
 export const useFollow = (userId?: string | string[]) => {
   const { oxyServices } = useOxy();
   const userIds = useMemo(() => (Array.isArray(userId) ? userId : userId ? [userId] : []), [userId]);
   const isSingleUser = typeof userId === 'string';
 
-  // Zustand selectors
-  const followState = useFollowStore();
+  // Granular Zustand selectors — only re-render when THIS user's data changes
+  const isFollowing = useFollowStore(
+    useCallback((s) => (isSingleUser && userId ? s.followingUsers[userId] ?? false : false), [isSingleUser, userId])
+  );
+  const isLoading = useFollowStore(
+    useCallback((s) => (isSingleUser && userId ? s.loadingUsers[userId] ?? false : false), [isSingleUser, userId])
+  );
+  const error = useFollowStore(
+    useCallback((s) => (isSingleUser && userId ? s.errors[userId] ?? null : null), [isSingleUser, userId])
+  );
+  const followerCount = useFollowStore(
+    useCallback((s) => (isSingleUser && userId ? s.followerCounts[userId] ?? null : null), [isSingleUser, userId])
+  );
+  const followingCount = useFollowStore(
+    useCallback((s) => (isSingleUser && userId ? s.followingCounts[userId] ?? null : null), [isSingleUser, userId])
+  );
+  const isLoadingCounts = useFollowStore(
+    useCallback((s) => (isSingleUser && userId ? s.loadingCounts[userId] ?? false : false), [isSingleUser, userId])
+  );
 
-  // Single user helpers
-  const isFollowing = isSingleUser && userId ? followState.followingUsers[userId] ?? false : false;
-  const isLoading = isSingleUser && userId ? followState.loadingUsers[userId] ?? false : false;
-  const error = isSingleUser && userId ? followState.errors[userId] ?? null : null;
-  
-  // Follower count helpers
-  const followerCount = isSingleUser && userId ? followState.followerCounts[userId] ?? null : null;
-  const followingCount = isSingleUser && userId ? followState.followingCounts[userId] ?? null : null;
-  const isLoadingCounts = isSingleUser && userId ? followState.loadingCounts[userId] ?? false : false;
+  // For multi-user mode, use shallow comparison to avoid re-renders when unrelated users change
+  const followData = useFollowStore(
+    useShallow((s) => {
+      if (isSingleUser) return {};
+      const data: Record<string, { isFollowing: boolean; isLoading: boolean; error: string | null }> = {};
+      for (const uid of userIds) {
+        data[uid] = {
+          isFollowing: s.followingUsers[uid] ?? false,
+          isLoading: s.loadingUsers[uid] ?? false,
+          error: s.errors[uid] ?? null,
+        };
+      }
+      return data;
+    })
+  );
 
+  // Multi-user aggregate selectors
+  const multiUserLoadingState = useFollowStore(
+    useShallow((s) => {
+      if (isSingleUser) return { isAnyLoading: false, hasAnyError: false, allFollowing: true, allNotFollowing: true };
+      return {
+        isAnyLoading: userIds.some(uid => s.loadingUsers[uid]),
+        hasAnyError: userIds.some(uid => !!s.errors[uid]),
+        allFollowing: userIds.every(uid => s.followingUsers[uid]),
+        allNotFollowing: userIds.every(uid => !s.followingUsers[uid]),
+      };
+    })
+  );
+
+  // Stable callbacks that depend on primitives, not object references.
+  // Store actions are accessed via getState() to avoid subscribing to them.
   const toggleFollow = useCallback(async () => {
     if (!isSingleUser || !userId) throw new Error('toggleFollow is only available for single user mode');
-    await followState.toggleFollowUser(userId, oxyServices, isFollowing);
-  }, [isSingleUser, userId, followState, oxyServices, isFollowing]);
+    const currentlyFollowing = useFollowStore.getState().followingUsers[userId] ?? false;
+    await useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
+  }, [isSingleUser, userId, oxyServices]);
 
   const setFollowStatus = useCallback((following: boolean) => {
     if (!isSingleUser || !userId) throw new Error('setFollowStatus is only available for single user mode');
-    followState.setFollowingStatus(userId, following);
-  }, [isSingleUser, userId, followState]);
+    useFollowStore.getState().setFollowingStatus(userId, following);
+  }, [isSingleUser, userId]);
 
   const fetchStatus = useCallback(async () => {
     if (!isSingleUser || !userId) throw new Error('fetchStatus is only available for single user mode');
-    await followState.fetchFollowStatus(userId, oxyServices);
-  }, [isSingleUser, userId, followState, oxyServices]);
+    await useFollowStore.getState().fetchFollowStatus(userId, oxyServices);
+  }, [isSingleUser, userId, oxyServices]);
 
   const clearError = useCallback(() => {
     if (!isSingleUser || !userId) throw new Error('clearError is only available for single user mode');
-    followState.clearFollowError(userId);
-  }, [isSingleUser, userId, followState]);
+    useFollowStore.getState().clearFollowError(userId);
+  }, [isSingleUser, userId]);
 
   const fetchUserCounts = useCallback(async () => {
     if (!isSingleUser || !userId) throw new Error('fetchUserCounts is only available for single user mode');
-    await followState.fetchUserCounts(userId, oxyServices);
-  }, [isSingleUser, userId, followState, oxyServices]);
+    await useFollowStore.getState().fetchUserCounts(userId, oxyServices);
+  }, [isSingleUser, userId, oxyServices]);
 
   const setFollowerCount = useCallback((count: number) => {
     if (!isSingleUser || !userId) throw new Error('setFollowerCount is only available for single user mode');
-    followState.setFollowerCount(userId, count);
-  }, [isSingleUser, userId, followState]);
+    useFollowStore.getState().setFollowerCount(userId, count);
+  }, [isSingleUser, userId]);
 
   const setFollowingCount = useCallback((count: number) => {
     if (!isSingleUser || !userId) throw new Error('setFollowingCount is only available for single user mode');
-    followState.setFollowingCount(userId, count);
-  }, [isSingleUser, userId, followState]);
+    useFollowStore.getState().setFollowingCount(userId, count);
+  }, [isSingleUser, userId]);
 
   // Auto-fetch counts when hook is used for a single user and counts are missing.
   useEffect(() => {
     if (!isSingleUser || !userId) return;
 
-    // If either count is not set and we're not already loading counts, trigger a fetch.
     if ((followerCount === null || followingCount === null) && !isLoadingCounts) {
       fetchUserCounts().catch((err: unknown) => console.warn('useFollow: fetchUserCounts failed', err));
     }
   }, [isSingleUser, userId, followerCount, followingCount, isLoadingCounts, fetchUserCounts]);
 
-  // Multiple user helpers
-  const followData = useMemo(() => {
-    const data: Record<string, { isFollowing: boolean; isLoading: boolean; error: string | null }> = {};
-    userIds.forEach(uid => {
-      data[uid] = {
-        isFollowing: followState.followingUsers[uid] ?? false,
-        isLoading: followState.loadingUsers[uid] ?? false,
-        error: followState.errors[uid] ?? null,
-      };
-    });
-    return data;
-  }, [userIds, followState.followingUsers, followState.loadingUsers, followState.errors]);
-
+  // Multi-user callbacks
   const toggleFollowForUser = useCallback(async (targetUserId: string) => {
-    const currentState = followState.followingUsers[targetUserId] ?? false;
-    await followState.toggleFollowUser(targetUserId, oxyServices, currentState);
-  }, [followState, oxyServices]);
+    const currentState = useFollowStore.getState().followingUsers[targetUserId] ?? false;
+    await useFollowStore.getState().toggleFollowUser(targetUserId, oxyServices, currentState);
+  }, [oxyServices]);
 
   const setFollowStatusForUser = useCallback((targetUserId: string, following: boolean) => {
-    followState.setFollowingStatus(targetUserId, following);
-  }, [followState]);
+    useFollowStore.getState().setFollowingStatus(targetUserId, following);
+  }, []);
 
   const fetchStatusForUser = useCallback(async (targetUserId: string) => {
-    await followState.fetchFollowStatus(targetUserId, oxyServices);
-  }, [followState, oxyServices]);
+    await useFollowStore.getState().fetchFollowStatus(targetUserId, oxyServices);
+  }, [oxyServices]);
 
   const fetchAllStatuses = useCallback(async () => {
-    await Promise.all(userIds.map(uid => followState.fetchFollowStatus(uid, oxyServices)));
-  }, [userIds, followState, oxyServices]);
+    const store = useFollowStore.getState();
+    await Promise.all(userIds.map(uid => store.fetchFollowStatus(uid, oxyServices)));
+  }, [userIds, oxyServices]);
 
   const clearErrorForUser = useCallback((targetUserId: string) => {
-    followState.clearFollowError(targetUserId);
-  }, [followState]);
+    useFollowStore.getState().clearFollowError(targetUserId);
+  }, []);
 
   const updateCountsFromFollowAction = useCallback((targetUserId: string, action: 'follow' | 'unfollow', counts: { followers: number; following: number }) => {
     const currentUserId = oxyServices.getCurrentUserId() || undefined;
-    followState.updateCountsFromFollowAction(targetUserId, action, counts, currentUserId);
-  }, [followState, oxyServices]);
-
-  // Aggregate helpers for multiple users
-  const isAnyLoading = userIds.some(uid => followState.loadingUsers[uid]);
-  const hasAnyError = userIds.some(uid => !!followState.errors[uid]);
-  const allFollowing = userIds.every(uid => followState.followingUsers[uid]);
-  const allNotFollowing = userIds.every(uid => !followState.followingUsers[uid]);
+    useFollowStore.getState().updateCountsFromFollowAction(targetUserId, action, counts, currentUserId);
+  }, [oxyServices]);
 
   if (isSingleUser && userId) {
     return {
@@ -119,7 +155,6 @@ export const useFollow = (userId?: string | string[]) => {
       setFollowStatus,
       fetchStatus,
       clearError,
-      // Follower count methods
       followerCount,
       followingCount,
       isLoadingCounts,
@@ -136,33 +171,85 @@ export const useFollow = (userId?: string | string[]) => {
     fetchStatusForUser,
     fetchAllStatuses,
     clearErrorForUser,
-    isAnyLoading,
-    hasAnyError,
-    allFollowing,
-    allNotFollowing,
+    isAnyLoading: multiUserLoadingState.isAnyLoading,
+    hasAnyError: multiUserLoadingState.hasAnyError,
+    allFollowing: multiUserLoadingState.allFollowing,
+    allNotFollowing: multiUserLoadingState.allNotFollowing,
+  };
+};
+
+/**
+ * useFollowForButton — Lightweight follow hook for FollowButton in list contexts.
+ *
+ * Unlike useFollow, this hook:
+ * - Accepts oxyServices directly (no useOxy() context subscription)
+ * - Only subscribes to the specific user's follow and loading state
+ * - Returns only what FollowButton needs (no counts, no multi-user)
+ */
+export const useFollowForButton = (userId: string, oxyServices: OxyServices) => {
+  const isFollowing = useFollowStore(
+    useCallback((s) => s.followingUsers[userId] ?? false, [userId])
+  );
+  const isLoading = useFollowStore(
+    useCallback((s) => s.loadingUsers[userId] ?? false, [userId])
+  );
+  const error = useFollowStore(
+    useCallback((s) => s.errors[userId] ?? null, [userId])
+  );
+
+  const toggleFollow = useCallback(async () => {
+    const currentlyFollowing = useFollowStore.getState().followingUsers[userId] ?? false;
+    await useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
+  }, [userId, oxyServices]);
+
+  const fetchStatus = useCallback(async () => {
+    await useFollowStore.getState().fetchFollowStatus(userId, oxyServices);
+  }, [userId, oxyServices]);
+
+  const setFollowStatus = useCallback((following: boolean) => {
+    useFollowStore.getState().setFollowingStatus(userId, following);
+  }, [userId]);
+
+  const clearError = useCallback(() => {
+    useFollowStore.getState().clearFollowError(userId);
+  }, [userId]);
+
+  return {
+    isFollowing,
+    isLoading,
+    error,
+    toggleFollow,
+    fetchStatus,
+    setFollowStatus,
+    clearError,
   };
 };
 
 // Convenience hook for just follower counts
 export const useFollowerCounts = (userId: string) => {
   const { oxyServices } = useOxy();
-  const followState = useFollowStore();
 
-  const followerCount = followState.followerCounts[userId] ?? null;
-  const followingCount = followState.followingCounts[userId] ?? null;
-  const isLoadingCounts = followState.loadingCounts[userId] ?? false;
+  const followerCount = useFollowStore(
+    useCallback((s) => s.followerCounts[userId] ?? null, [userId])
+  );
+  const followingCount = useFollowStore(
+    useCallback((s) => s.followingCounts[userId] ?? null, [userId])
+  );
+  const isLoadingCounts = useFollowStore(
+    useCallback((s) => s.loadingCounts[userId] ?? false, [userId])
+  );
 
   const fetchUserCounts = useCallback(async () => {
-    await followState.fetchUserCounts(userId, oxyServices);
-  }, [userId, followState, oxyServices]);
+    await useFollowStore.getState().fetchUserCounts(userId, oxyServices);
+  }, [userId, oxyServices]);
 
   const setFollowerCount = useCallback((count: number) => {
-    followState.setFollowerCount(userId, count);
-  }, [userId, followState]);
+    useFollowStore.getState().setFollowerCount(userId, count);
+  }, [userId]);
 
   const setFollowingCount = useCallback((count: number) => {
-    followState.setFollowingCount(userId, count);
-  }, [userId, followState]);
+    useFollowStore.getState().setFollowingCount(userId, count);
+  }, [userId]);
 
   return {
     followerCount,
@@ -172,4 +259,4 @@ export const useFollowerCounts = (userId: string) => {
     setFollowerCount,
     setFollowingCount,
   };
-}; 
+};

package/src/ui/hooks/useWebSSO.ts

@@ -84,7 +84,7 @@ export function useWebSSO({
   const hasCheckedRef = useRef(false);
 
   // Check FedCM support once
-  const fedCMSupported = isWebBrowser() && (oxyServices as any).isFedCMSupported?.();
+  const fedCMSupported = isWebBrowser() && oxyServices.isFedCMSupported?.();
 
   const checkSSO = useCallback(async (): Promise<SessionLoginResponse | null> => {
     if (!isWebBrowser() || isCheckingRef.current) {
@@ -106,7 +106,7 @@ export function useWebSSO({
     isCheckingRef.current = true;
 
     try {
-      const session = await (oxyServices as any).silentSignInWithFedCM?.();
+      const session = await oxyServices.silentSignInWithFedCM?.();
 
       if (session) {
         await onSessionFound(session);
@@ -142,7 +142,7 @@ export function useWebSSO({
     isCheckingRef.current = true;
 
     try {
-      const session = await (oxyServices as any).signInWithFedCM?.();
+      const session = await oxyServices.signInWithFedCM?.();
 
       if (session) {
         await onSessionFound(session);

package/src/ui/screens/EditProfileFieldScreen.tsx

@@ -255,31 +255,30 @@ const EditProfileFieldScreen: React.FC<EditProfileFieldScreenProps> = ({
     useEffect(() => {
         if (!user) return;
 
-        // Cast user to any to access dynamic properties
-        const userData = user as any;
+        const userData = user;
 
         if (fieldConfig.isList) {
             if (fieldType === 'locations') {
-                const locations = Array.isArray(userData.locations) ? userData.locations : [];
-                setListItems(locations.map((loc: any, i: number) => ({
-                    id: loc.id || `location-${i}`,
-                    name: loc.name || '',
+                const locations = Array.isArray(userData.locations) ? userData.locations as Array<Record<string, unknown>> : [];
+                setListItems(locations.map((loc, i) => ({
+                    id: String(loc.id || `location-${i}`),
+                    name: String(loc.name || ''),
                     ...loc,
                 })));
             } else if (fieldType === 'links') {
-                const linksMetadata = Array.isArray(userData.linksMetadata) ? userData.linksMetadata : [];
+                const linksMetadata = Array.isArray(userData.linksMetadata) ? userData.linksMetadata as Array<Record<string, unknown>> : [];
                 const links = Array.isArray(userData.links) ? userData.links : [];
                 // Use linksMetadata if available, otherwise convert links array
                 if (linksMetadata.length > 0) {
-                    setListItems(linksMetadata.map((link: any, i: number) => ({
-                        id: link.id || `link-${i}`,
-                        url: link.url || link.link || '',
-                        title: link.title || '',
+                    setListItems(linksMetadata.map((link, i) => ({
+                        id: String(link.id || `link-${i}`),
+                        url: String(link.url || link.link || ''),
+                        title: String(link.title || ''),
                         ...link,
                     })));
                 } else {
-                    setListItems(links.map((item: any, i: number) => {
-                        const url = typeof item === 'string' ? item : (item.link || item.url || '');
+                    setListItems(links.map((item, i) => {
+                        const url = typeof item === 'string' ? item : (item.link || '');
                         return {
                             id: `link-${i}`,
                             url,
@@ -365,11 +364,24 @@ const EditProfileFieldScreen: React.FC<EditProfileFieldScreenProps> = ({
         if (fieldConfig.isList) {
             let success = false;
             if (fieldType === 'locations') {
-                success = await saveProfile({ locations: listItems as any });
+                success = await saveProfile({
+                    locations: listItems.map(item => ({
+                        id: item.id,
+                        name: String(item.name || ''),
+                        ...(item.label !== undefined && { label: String(item.label) }),
+                        ...(item.coordinates !== undefined && { coordinates: item.coordinates as { lat: number; lon: number } }),
+                    })),
+                });
             } else if (fieldType === 'links') {
                 success = await saveProfile({
-                    linksMetadata: listItems as any,
-                    links: listItems.map((item: any) => item.url),
+                    linksMetadata: listItems.map(item => ({
+                        id: item.id,
+                        url: String(item.url || ''),
+                        ...(item.title !== undefined && { title: String(item.title) }),
+                        ...(item.description !== undefined && { description: String(item.description) }),
+                        ...(item.image !== undefined && { image: String(item.image) }),
+                    })),
+                    links: listItems.map(item => String(item.url || '')),
                 });
             }
             if (success) {

package/src/ui/screens/FAQScreen.tsx

@@ -263,7 +263,8 @@ const createStyles = (themeStyles: any) => StyleSheet.create({
         flex: 1,
         fontSize: 16,
         ...Platform.select({
-            web: { outlineStyle: 'none' as any },
+            // outlineStyle: 'none' is a valid web CSS property not in React Native's TextStyle definition
+            web: { outlineStyle: 'none' as unknown as import('react-native').TextStyle['outlineStyle'] },
         }),
     },
     categoriesContainer: {

package/src/ui/screens/FeedbackScreen.tsx

@@ -50,7 +50,7 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
     const fadeAnim = useRef(new Animated.Value(1)).current;
     const slideAnim = useRef(new Animated.Value(0)).current;
 
-    const styles = useMemo(() => createFeedbackStyles(colors as any), [colors]);
+    const styles = useMemo(() => createFeedbackStyles(colors), [colors]);
 
     const animateTransition = useCallback((nextStep: number) => {
         Animated.timing(fadeAnim, {
@@ -149,7 +149,7 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
         iconColor: type.color,
         title: type.label,
         subtitle: type.description,
-        onPress: () => { updateField('type', type.id as any); updateField('category', ''); },
+        onPress: () => { updateField('type', type.id); updateField('category', ''); },
         selected: feedbackData.type === type.id,
         showChevron: false,
         multiRow: true,
@@ -172,7 +172,7 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
         icon: p.icon,
         iconColor: p.color,
         title: p.label,
-        onPress: () => updateField('priority', p.id as any),
+        onPress: () => updateField('priority', p.id),
         selected: feedbackData.priority === p.id,
         showChevron: false,
         dense: true,
@@ -246,7 +246,7 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
                 onChangeText={(text) => { updateField('title', text); setErrorMessage(''); }}
                 placeholder={t('feedback.fields.title.placeholder') || 'Brief summary of your feedback'}
                 testID="feedback-title-input"
-                colors={colors as any}
+                colors={colors}
                 styles={styles}
                 accessibilityLabel="Feedback title"
                 accessibilityHint="Enter a brief summary of your feedback"
@@ -261,7 +261,7 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
                 multiline={true}
                 numberOfLines={6}
                 testID="feedback-description-input"
-                colors={colors as any}
+                colors={colors}
                 styles={styles}
                 accessibilityLabel="Feedback description"
                 accessibilityHint="Provide detailed information about your feedback"
@@ -319,7 +319,7 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
                 onChangeText={(text) => { updateField('contactEmail', text); setErrorMessage(''); }}
                 placeholder={user?.email || (t('feedback.fields.email.placeholder') || 'Enter your email address')}
                 testID="feedback-email-input"
-                colors={colors as any}
+                colors={colors}
                 styles={styles}
                 accessibilityLabel="Email address"
                 accessibilityHint="Enter your email so we can respond"
@@ -494,7 +494,7 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
                 keyboardShouldPersistTaps="handled"
             >
                 {feedbackState.status !== 'success' && (
-                    <ProgressIndicator currentStep={currentStep} totalSteps={4} colors={colors as any} styles={styles} />
+                    <ProgressIndicator currentStep={currentStep} totalSteps={4} colors={colors} styles={styles} />
                 )}
                 {renderCurrentStep()}
             </ScrollView>

package/src/ui/screens/FileManagementScreen.tsx

@@ -1506,8 +1506,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                         {file.metadata.description}
                     </Text>
                 ) : undefined,
-            // biome-ignore lint/suspicious/noExplicitAny: GroupedSectionItem has dynamic properties
-            } as any;
+            };
         });
     }, [filteredFiles, theme, themeStyles, deleting, handleFileDownload, handleFileDelete, handleFileOpen, getSafeDownloadUrlCallback, selectMode, selectedIds]);
 

package/src/ui/screens/HistoryViewScreen.tsx

@@ -41,7 +41,11 @@ const HistoryViewScreen: React.FC<BaseScreenProps> = ({
         if (isReactNative) {
             try {
                 const asyncStorageModule = await import('@react-native-async-storage/async-storage');
-                const storage = (asyncStorageModule.default as unknown) as any;
+                const storage = asyncStorageModule.default as unknown as {
+                    getItem: (key: string) => Promise<string | null>;
+                    setItem: (key: string, value: string) => Promise<void>;
+                    removeItem: (key: string) => Promise<void>;
+                };
                 return {
                     getItem: storage.getItem.bind(storage),
                     setItem: storage.setItem.bind(storage),

package/src/ui/screens/PremiumSubscriptionScreen.tsx

@@ -915,7 +915,7 @@ const PremiumSubscriptionScreen: React.FC<BaseScreenProps> = ({
                 <View style={styles.featureHeader}>
                     <View style={styles.featureIconContainer}>
                         <Ionicons
-                            name={getCategoryIcon(feature.category) as any}
+                            name={getCategoryIcon(feature.category) as React.ComponentProps<typeof Ionicons>['name']}
                             size={24}
                             color={getCategoryColor(feature.category)}
                         />

package/src/ui/screens/karma/KarmaRewardsScreen.tsx

@@ -292,7 +292,7 @@ const KarmaRewardsScreen: React.FC<BaseScreenProps> = ({ goBack, theme }) => {
                             {isLocked ? (
                                 <Ionicons name="lock-closed" size={40} color="#8E8E93" />
                             ) : (
-                                <Ionicons name={achievement.icon as any} size={40} color="#FFFFFF" />
+                                <Ionicons name={achievement.icon as React.ComponentProps<typeof Ionicons>['name']} size={40} color="#FFFFFF" />
                             )}
                         </View>
 

package/src/ui/stores/fileStore.ts

@@ -5,12 +5,12 @@ import type { FileMetadata } from '@oxyhq/core';
 function shallowEqualFile(a: FileMetadata, b: FileMetadata): boolean {
   if (a === b) return true;
   if (!a || !b) return false;
-  const aKeys = Object.keys(a) as Array<keyof FileMetadata>;
-  const bKeys = Object.keys(b) as Array<keyof FileMetadata>;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
   if (aKeys.length !== bKeys.length) return false;
   for (const k of aKeys) {
     // treat metadata/variants shallowly by reference
-    if ((a as any)[k] !== (b as any)[k]) return false;
+    if (a[k as keyof FileMetadata] !== b[k as keyof FileMetadata]) return false;
   }
   return true;
 }
@@ -60,7 +60,7 @@ export const useFileStore = create<FileState>((set, get) => ({
       if (sameOrder) {
         sameFiles = order.every(id => state.files[id] && shallowEqualFile(state.files[id], map[id] as FileMetadata));
       }
-      if (sameOrder && sameFiles) return {} as any;
+      if (sameOrder && sameFiles) return state;
       return { files: map, order };
     }
     const newFiles = { ...state.files };
@@ -72,13 +72,13 @@ export const useFileStore = create<FileState>((set, get) => ({
       if (!prev || !shallowEqualFile(prev, merged)) { newFiles[f.id] = merged; changed = true; }
       if (!newOrder.includes(f.id)) { newOrder.unshift(f.id); changed = true; }
     });
-    if (!changed) return {} as any;
+    if (!changed) return state;
     return { files: newFiles, order: newOrder };
   }),
   addFile: (file, opts) => set(state => {
     const prepend = opts?.prepend !== false; // default true
     if (state.files[file.id]) {
-      if (shallowEqualFile(state.files[file.id], file)) return {} as any;
+      if (shallowEqualFile(state.files[file.id], file)) return state;
       return { files: { ...state.files, [file.id]: file } };
     }
     return {
@@ -88,13 +88,13 @@ export const useFileStore = create<FileState>((set, get) => ({
   }),
   updateFile: (id, patch) => set(state => {
     const existing = state.files[id];
-    if (!existing) return {} as any;
+    if (!existing) return state;
     const updated = { ...existing, ...patch } as FileMetadata;
-    if (shallowEqualFile(existing, updated)) return {} as any;
+    if (shallowEqualFile(existing, updated)) return state;
     return { files: { ...state.files, [id]: updated } };
   }),
   removeFile: (id) => set(state => {
-    if (!state.files[id]) return {} as any;
+    if (!state.files[id]) return state;
     const { [id]: _removed, ...rest } = state.files;
     const newOrder = state.order.filter(fid => fid !== id);
     return { files: rest, order: newOrder };