Thanks for a quick response! I can actually see the patches diff here:

const[nextState,patches]=create(prevState,callback)

patches contains a serialized array of changes performed in a draft! Would that be safe to use? It does seem to work for my use case from what I can see (still exploring).

I'm not sure about the specific scenario for your check, but generally, using it to check for changing may not be rigorous.

First, it should be noted that in theenablePatches option, whenenablePatches: true is set,arrayLengthAssignment defaults totrue. For details, you can refer tohttps://mutative.js.org/docs/api-reference/create.

If you really need to use this solution, I suggest it should be set tofalse, like this:

{  enablePatches: {    arrayLengthAssignment: false,  },}

This ensures that every detailed modification to the array will have a detailed patch generated, instead of being replaced by a length modification.

Additionally, comparing possible values could also be an issue. For example,

const[state,patches,inversePatches]=create({arr:[0,1,2,undefined],a:undefined,},(draft)=>{deletedraft.a;draft.arr.length=3;},{enablePatches:{arrayLengthAssignment:false,},});console.log('mutative patches:',patches);// mutative patches: [//   { op: 'remove', path: [ 'arr', 3 ] },//   { op: 'remove', path: [ 'a' ] }// ]

In this example, although the patches indicate that the corresponding value was modified, the actual value may not have really been changed.

Good point. Sodraft.array.length = 3 gets interpreted as "the element by third index has been removed", right? And if there are ten elements after that index, will that produce 10 patch objects?

So draft.array.length = 3 gets interpreted as "the element by third index has been removed", right?

To be precise, if the array exceeds 3 elements, the extra ones are trimmed. If it has fewer than 3, it is filled withundefined to meet the length of 3.

And if there are ten elements after that index, will that produce 10 patch objects?

Yes.