@singi-labs/sifa-sdk 0.12.71 → 0.12.73

package/dist/query/hooks/index.cjs

@@ -360,70 +360,80 @@ function useUpdateProfileSelf(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => updateProfileSelf(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUpdateProfileOverride(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => updateProfileOverride(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useRefreshPds(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: () => refreshPds(config),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUploadAvatar(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (file) => uploadAvatar(config, file),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDeleteAvatarOverride(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: () => deleteAvatarOverride(config),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -496,6 +506,9 @@ function useCreatePosition(ownerDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => createPosition(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
@@ -503,8 +516,7 @@ function useCreatePosition(ownerDid, options) {
         await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.position.byOwner(ownerDid) });
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 async function invalidatePositionCaches(queryClient, ownerHandleOrDid) {
@@ -519,84 +531,96 @@ function useUpdatePosition(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ rkey, data }) => updatePosition(config, rkey, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidatePositionCaches(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDeletePosition(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => deletePosition(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidatePositionCaches(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useSetPositionPrimary(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => setPositionPrimary(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidatePositionCaches(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUnsetPositionPrimary(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => unsetPositionPrimary(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidatePositionCaches(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useLinkSkillToPosition(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ position, skillRef }) => linkSkillToPosition(config, position, skillRef),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidatePositionCaches(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUnlinkSkillFromPosition(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ position, skillRef }) => unlinkSkillFromPosition(config, position, skillRef),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidatePositionCaches(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -624,42 +648,48 @@ function useCreateEducation(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => createEducation(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile2(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUpdateEducation(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ rkey, data }) => updateEducation(config, rkey, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile2(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDeleteEducation(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => deleteEducation(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile2(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -693,28 +723,32 @@ function useCreateSkill(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => createSkill(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile3(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUpdateSkill(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ rkey, data }) => updateSkill(config, rkey, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile3(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUpdateSkillSubCategories(ownerHandleOrDid, options) {
@@ -739,14 +773,16 @@ function useDeleteSkill(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => deleteSkill(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile3(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -778,42 +814,48 @@ function useCreateRecord(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ collection, data }) => createRecord(config, collection, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile4(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUpdateRecord(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ collection, rkey, data }) => updateRecord(config, collection, rkey, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile4(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDeleteRecord(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ collection, rkey }) => deleteRecord(config, collection, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile4(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -841,42 +883,48 @@ function useCreateProfileLocation(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => createProfileLocation(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile5(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUpdateProfileLocation(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ rkey, data }) => updateProfileLocation(config, rkey, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile5(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDeleteProfileLocation(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => deleteProfileLocation(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile5(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -962,84 +1010,96 @@ function useCreateExternalAccount(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => createExternalAccount(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUpdateExternalAccount(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ rkey, data }) => updateExternalAccount(config, rkey, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDeleteExternalAccount(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => deleteExternalAccount(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useSetExternalAccountPrimary(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => setExternalAccountPrimary(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUnsetExternalAccountPrimary(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => unsetExternalAccountPrimary(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useVerifyExternalAccount(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => verifyExternalAccount(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -1053,6 +1113,9 @@ function useCreateEndorsement(endorsedHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => createEndorsement(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success && endorsedHandleOrDid) {
@@ -1064,8 +1127,7 @@ function useCreateEndorsement(endorsedHandleOrDid, options) {
         });
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -1126,6 +1188,9 @@ function useCreateConfirmation(claimerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => createConfirmation(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
@@ -1142,14 +1207,16 @@ function useCreateConfirmation(claimerHandleOrDid, options) {
         }
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDismissConfirmation(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => dismissConfirmation(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
@@ -1158,14 +1225,16 @@ function useDismissConfirmation(options) {
         });
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useRevokeConfirmation(claimerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (data) => revokeConfirmation(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
@@ -1179,8 +1248,7 @@ function useRevokeConfirmation(claimerHandleOrDid, options) {
         }
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -1212,28 +1280,32 @@ function useHideKeytraceClaim(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => hideKeytraceClaim(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile6(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUnhideKeytraceClaim(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (rkey) => unhideKeytraceClaim(config, rkey),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile6(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -1265,28 +1337,32 @@ function useRevealMarqueDomain(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (domain) => revealMarqueDomain(config, domain),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile7(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUnrevealMarqueDomain(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (domain) => unrevealMarqueDomain(config, domain),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateProfile7(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -1355,14 +1431,16 @@ function makeWriteHook(fetcher) {
     const config = useSifaConfig();
     const queryClient = reactQuery.useQueryClient();
     return reactQuery.useMutation({
+      // Spread first: a consumer-supplied onSuccess would otherwise replace the
+      // handler below and silently drop cache invalidation (#453).
+      ...options,
       mutationFn: (v) => fetcher(config, v),
       onSuccess: async (result, variables, onMutateResult, context) => {
         if (result.success) {
           await invalidateProfile8(queryClient, ownerHandleOrDid);
         }
         await options?.onSuccess?.(result, variables, onMutateResult, context);
-      },
-      ...options
+      }
     });
   };
 }
@@ -1400,8 +1478,7 @@ function useRefreshOrcidPublications(ownerHandleOrDid, options) {
         await invalidateProfile8(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -1811,6 +1888,9 @@ function useFollow(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ handle, note }) => followUser(config, handle, { note }),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
@@ -1821,14 +1901,16 @@ function useFollow(options) {
     onError: async (error, variables, onMutateResult, context) => {
       await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.follow.all() });
       await options?.onError?.(error, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUnfollow(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ handle }) => unfollowUser(config, handle),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
@@ -1839,8 +1921,7 @@ function useUnfollow(options) {
     onError: async (error, variables, onMutateResult, context) => {
       await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.follow.all() });
       await options?.onError?.(error, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useFollowers(handle, opts = {}, options) {
@@ -2381,28 +2462,32 @@ function useCreateReaction(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ targetUri, appId, targetCid }) => createReaction(config, targetUri, appId, targetCid),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.ok) {
         await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.reactions.all() });
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDeleteReaction(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: ({ targetUri, appId }) => deleteReaction(config, targetUri, appId),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.reactions.all() });
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -2493,28 +2578,32 @@ function useCastRoadmapVote(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (key) => castRoadmapVote(config, key),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.ok) {
         await invalidateRoadmap(queryClient);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useRetractRoadmapVote(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (key) => retractRoadmapVote(config, key),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await invalidateRoadmap(queryClient);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -2558,28 +2647,32 @@ function useResetProfile(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (deletePdsData) => resetProfile(config, deletePdsData),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.all() });
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useDeleteAccount(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (deletePdsData) => deleteAccount(config, deletePdsData),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
         queryClient.clear();
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 
@@ -2612,12 +2705,14 @@ function useDeleteRepoRecords(options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied handler would otherwise replace the
+    // one below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (input) => deleteRepoRecords(config, input),
     onSuccess: async (result, variables, onMutateResult, context) => {
       await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.all() });
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 var httpUrlNullable = zod.z.string().refine((s) => /^https?:\/\//i.test(s), { message: "must be an http(s) URL" }).nullable();
@@ -2803,6 +2898,9 @@ function useOrgClaim(handleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (body) => submitOrgClaim(config, body),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success && handleOrDid) {
@@ -2811,14 +2909,16 @@ function useOrgClaim(handleOrDid, options) {
         });
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useUpdateOrgProfile(handleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
+    // Spread first: a consumer-supplied onSuccess would otherwise replace the
+    // handler below and silently drop cache invalidation (#453).
+    ...options,
     mutationFn: (body) => updateOrgProfile(config, body),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success && handleOrDid) {
@@ -2827,8 +2927,7 @@ function useUpdateOrgProfile(handleOrDid, options) {
         });
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
-    },
-    ...options
+    }
   });
 }
 function useOrgDomainChallenge(options) {