fix the diffing (tldraw#7108)

doing fine grained diffs on the tip tap documents was no bueno

### Change type

- [x] `other`


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Treat `props` and `meta` as nested patches, while defaulting
non-string/non-array object fields to full `put` when changed; update
diffing internals accordingly.
> 
> - **Diffing behavior**:
> - Treat `props` and `meta` as nested keys for patching via
`diffObject`.
> - For other object fields, emit `put` when changed unless values are
arrays or strings (which still diff/append).
> - Maintain fine-grained handling for arrays (`diffArray`) and strings
(append optimization).
> - **API/Internal changes**:
> - `diffRecord` now calls `diffObject(prev, next, new
Set(['props','meta']), legacyAppendMode)`.
> - `diffObject` signature includes `nestedKeys` and uses shallow
equality to choose between nested `diffValue` vs `put`.
> - Recursive calls to `diffObject` pass `undefined` for `nestedKeys` to
limit deep nesting.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
8329710. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: ds300

packages/sync-core/src/lib/diff.ts

@@ -187,10 +187,15 @@ export function diffRecord(
 	next: object,
 	legacyAppendMode = false
 ): ObjectDiff | null {
-	return diffObject(prev, next, legacyAppendMode)
+	return diffObject(prev, next, new Set(['props', 'meta']), legacyAppendMode)
 }
 
-function diffObject(prev: object, next: object, legacyAppendMode: boolean): ObjectDiff | null {
+function diffObject(
+	prev: object,
+	next: object,
+	nestedKeys: Set<string> | undefined,
+	legacyAppendMode: boolean
+): ObjectDiff | null {
 	if (prev === next) {
 		return null
 	}
@@ -202,11 +207,22 @@ function diffObject(prev: object, next: object, legacyAppendMode: boolean): Obje
 			result[key] = [ValueOpType.Delete]
 			continue
 		}
-		// if key is in both places, then compare values
-		const diff = diffValue((prev as any)[key], (next as any)[key], legacyAppendMode)
-		if (diff) {
+		const prevValue = (prev as any)[key]
+		const nextValue = (next as any)[key]
+		if (
+			nestedKeys?.has(key) ||
+			(Array.isArray(prevValue) && Array.isArray(nextValue)) ||
+			(typeof prevValue === 'string' && typeof nextValue === 'string')
+		) {
+			// if key is in both places, then compare values
+			const diff = diffValue(prevValue, nextValue, legacyAppendMode)
+			if (diff) {
+				if (!result) result = {}
+				result[key] = diff
+			}
+		} else if (!isEqual(prevValue, nextValue)) {
 			if (!result) result = {}
-			result[key] = diff
+			result[key] = [ValueOpType.Put, nextValue]
 		}
 	}
 	for (const key of Object.keys(next)) {
@@ -232,7 +248,7 @@ function diffValue(valueA: unknown, valueB: unknown, legacyAppendMode: boolean):
 	} else if (!valueA || !valueB || typeof valueA !== 'object' || typeof valueB !== 'object') {
 		return isEqual(valueA, valueB) ? null : [ValueOpType.Put, valueB]
 	} else {
-		const diff = diffObject(valueA, valueB, legacyAppendMode)
+		const diff = diffObject(valueA, valueB, undefined, legacyAppendMode)
 		return diff ? [ValueOpType.Patch, diff] : null
 	}
 }