perf(groups): identity-preserving mapObjectById and updateObjects walk

Both tree walks always returned new arrays / new group nodes even
when no descendant actually changed. That broke React identity for
the unaffected portions of the tree, defeating any downstream
memoisation. Added the 'changed' flag pattern: the function returns
the original array when nothing in it (or below it) was touched,
otherwise the rebuilt one. Group nodes likewise keep their
reference when their children walk returns by reference.

Picked up four Group.test cases to lock the identity behaviour:
- mapper applied at the matching node
- top-level array preserved when id is missing
- untouched group subtrees preserved by reference
- mapper that returns the same node leaves the array untouched

Author: u8array

src/store/labelStore.ts

@@ -318,19 +318,26 @@ export const useLabelStore = create<LabelState>()(
         set((state) => {
           if (updates.length === 0) return {};
           // Single tree walk that applies every queued change in one
-          // pass. The previous reduce-over-mapObjectById approach was
-          // O(updates × tree) and fired per frame during multi-object
-          // drag; this is O(tree).
+          // pass: O(tree) instead of O(updates × tree). Identity-
+          // preserving — subtrees with no matching id keep their
+          // reference so React memoisation can skip them.
           const updateMap = new Map(updates.map((u) => [u.id, u.changes]));
-          const applyUpdates = (nodes: LabelObject[]): LabelObject[] =>
-            nodes.map((n) => {
+          const applyUpdates = (nodes: LabelObject[]): LabelObject[] => {
+            let changed = false;
+            const next = nodes.map((n) => {
               const changes = updateMap.get(n.id);
-              const updated = changes ? applyObjectChanges(n, changes) : n;
+              let updated = changes ? applyObjectChanges(n, changes) : n;
               if (isGroup(updated)) {
-                return { ...updated, children: applyUpdates(updated.children) };
+                const nextChildren = applyUpdates(updated.children);
+                if (nextChildren !== updated.children) {
+                  updated = { ...updated, children: nextChildren };
+                }
               }
+              if (updated !== n) changed = true;
               return updated;
             });
+            return changed ? next : nodes;
+          };
           return updateCurrentObjects(state, (objs) => applyUpdates(objs));
         }),
 

src/types/Group.test.ts

@@ -10,6 +10,7 @@ import {
   detachObjectById,
   isSelfOrDescendant,
   canGroupSelection,
+  mapObjectById,
   type GroupObject,
 } from './Group';
 import type { LabelObject } from '../registry';
@@ -200,6 +201,38 @@ describe('Group helpers', () => {
     });
   });
 
+  describe('mapObjectById', () => {
+    it('applies the mapper to the matching node', () => {
+      const tree = [leaf('a'), leaf('b')];
+      const next = mapObjectById(tree, 'a', (o) => ({ ...o, x: 99 }));
+      expect(next[0]?.x).toBe(99);
+      expect(next[1]).toBe(tree[1]); // sibling unchanged
+    });
+
+    it('preserves the top-level array reference when no id matches', () => {
+      const tree = [leaf('a'), leaf('b')];
+      const next = mapObjectById(tree, 'missing', (o) => ({ ...o, x: 99 }));
+      expect(next).toBe(tree);
+    });
+
+    it('preserves untouched group subtrees by reference', () => {
+      const inner = leaf('inside');
+      const tree = [group('g1', [inner]), group('g2', [leaf('other')])];
+      const next = mapObjectById(tree, 'inside', (o) => ({ ...o, x: 5 }));
+      // g2 wasn't touched — its node identity stays.
+      expect(next[1]).toBe(tree[1]);
+      // g1 is rebuilt (its children array changed), but the unchanged
+      // sibling inside g1 — there's none — would also keep identity.
+      expect(next[0]).not.toBe(tree[0]);
+    });
+
+    it('preserves the array reference when the mapper returns the same node', () => {
+      const tree = [leaf('a')];
+      const next = mapObjectById(tree, 'a', (o) => o);
+      expect(next).toBe(tree);
+    });
+  });
+
   describe('expandSelection', () => {
     it('passes leaf ids through unchanged', () => {
       expect(expandSelection([leaf('a'), leaf('b')], ['a'])).toEqual(['a']);

src/types/Group.ts

@@ -92,19 +92,35 @@ export function selectionTargetId(objects: LabelObject[], id: string): string {
  * Returns a new tree with the node identified by `id` replaced by
  * `mapper(node)`. Walks recursively into groups so this is the one
  * code path the store needs to mutate either top-level objects or
- * leaves nested inside groups. Unmatched leaves keep their object
- * identity so per-object React memoisation still works.
+ * leaves nested inside groups.
+ *
+ * Identity-preserving: subtrees that don't contain the target id —
+ * and the top-level array itself when no match is found — keep their
+ * original references. That lets React memoisation skip unaffected
+ * branches when a single leaf updates.
  */
 export function mapObjectById(
   objects: LabelObject[],
   id: string,
   mapper: (obj: LabelObject) => LabelObject,
 ): LabelObject[] {
-  return objects.map((o) => {
-    if (o.id === id) return mapper(o);
-    if (isGroup(o)) return { ...o, children: mapObjectById(o.children, id, mapper) };
+  let changed = false;
+  const next = objects.map((o) => {
+    if (o.id === id) {
+      const updated = mapper(o);
+      if (updated !== o) changed = true;
+      return updated;
+    }
+    if (isGroup(o)) {
+      const nextChildren = mapObjectById(o.children, id, mapper);
+      if (nextChildren !== o.children) {
+        changed = true;
+        return { ...o, children: nextChildren };
+      }
+    }
     return o;
   });
+  return changed ? next : objects;
 }
 
 /**