Watch stops watching when object is replace

I’m having a situation where I have a deep watch a an array of objects coming from an API server, but under certain circumstances the watch stops working
In my code I have this array called allData which is filled with an array of objects during load. In the components I’m using, the data is changed (e.g. changing data in a textbox of some sort). When data is changed, the watch will trigger a function that saves the data (by calling put to API).
In most cases the server responds by sending null back (null basically means everything is okay. Probably should send more advanced response back, but since nobody else than my app has access, this can always be changed later).
There are some situations where the API sends a freshly loaded array of objects back, due to some specific changes in data from user will make the server write other changes into the database. To make the user see these changes, data needs to be reloaded. In my case this happens when the user makes a selection in a specific select box
It is in this situation the watch will stop working, but in a bit weird way. If I make a selection that causes data to be reloaded, then the watch will still work for the next change in data (no matter which field I’m changing), but all changes after that doesn’t get triggered

To make this even weirder: I have two html pages in my site (I’m using UMD as I’m upgrading old website), where both pages are set up in the same way (e.g. same function names, same variable names, just different API calls and 90% different fields for the users to change). One of these pages works fine, the other one not so fine

Here’s the code

watch: {

                // Keeps an eye on changes to all data (at deep level)
                // When something has changed, data will be saved

                allData:
                {
                    deep: true,
                    handler: 'SetSelectedAndSaveData'
                },
            },

methods:
            {
                
                SetSelectedAndSaveData()
                {
                    console.log("SetSelectedAndSaveData");

                    this.SaveData();
                },
                
                SaveData: _.debounce(function ()
                {
                    let data = {};
                    data.statusData = this.localStatusData;
                    data.proposalData = this.localProposalData;                  

                    console.log("Saving data DistrictHeat")
                    
                    let url = window.WriteUrl('DistrictHeat');

                    axios
                        .put(url, data)
                        .then((response) =>
                        {
                            if (response.data)
                            {
                                // Server made changes to data
                                // Updates local data with new updated data

                                this.allData = response.data;
// Data received here is same data as under the load function as it's the same function on API being called in the situations where it needs to reload data
                                console.log("Receive");
                            }
                        })

                }, 500), // Adds a 500 ms delay for saving to wait for more changes
LoadCurrentDistrictHeatData()
                {
// This method is called during load
                    isLoadingData = true;

                    let url = window.WriteUrl('DistrictHeat', this.labelId, this.buildId);

                    axios
                        .get(url)
                        .then((response) =>
                        {
                            this.allData = response.data;
                        })
                },
            },

The log would end up being something like this:
(User changes textfield)
SetSelectedAndSaveData
Saving data DistrictHeat

–I can do this all day–

(User changes selection field)
SetSelectedAndSaveData
Saving data DistrictHeat
Receive

(User changes textfield)
SetSelectedAndSaveData
Saving data DistrictHeat

(User changes textfield)
–this is when the watcher stops triggering–

For some unknown reason it still triggers one more time after receiving data and then abruptly stops. I’m not getting any errors and Vue Dev Tools doesn’t show anything unusual. If I remove setting allData after save it will work perfectly fine

I never found the solution to the problem, but I did end up redoing a lot of code to get around this problem