[perf] add batch update method to spatial index - addresses review feedback

Optimizes batch node bounds updates by eliminating redundant cache
invalidations. Previously each update() call invalidated the cache,
causing O(n) cache clears for n nodes. Now batchUpdate() performs
all updates and invalidates once, reducing overhead for large batch
operations like node paste or multi-node resize.

Author: christian-byrne

src/renderer/core/layout/store/layoutStore.ts

@@ -1103,23 +1103,29 @@ class LayoutStoreImpl implements LayoutStore {
     operation: BatchUpdateBoundsOperation,
     change: LayoutChange
   ): void {
+    const spatialUpdates: Array<{ nodeId: NodeId; bounds: Bounds }> = []
+
     for (const nodeId of operation.nodeIds) {
       const data = operation.bounds[nodeId]
       const ynode = this.ynodes.get(nodeId)
       if (!ynode || !data) continue
 
-      this.spatialIndex.update(nodeId, data.bounds)
-
       ynode.set('position', { x: data.bounds.x, y: data.bounds.y })
       ynode.set('size', {
         width: data.bounds.width,
         height: data.bounds.height
       })
       ynode.set('bounds', data.bounds)
 
+      spatialUpdates.push({ nodeId, bounds: data.bounds })
       change.nodeIds.push(nodeId)
     }
 
+    // Batch update spatial index for better performance
+    if (spatialUpdates.length > 0) {
+      this.spatialIndex.batchUpdate(spatialUpdates)
+    }
+
     if (change.nodeIds.length) {
       change.type = 'update'
     }

src/renderer/core/spatial/SpatialIndex.ts

@@ -55,6 +55,17 @@ export class SpatialIndexManager {
     this.invalidateCache()
   }
 
+  /**
+   * Batch update multiple nodes' bounds in the spatial index
+   * More efficient than calling update() multiple times as it only invalidates cache once
+   */
+  batchUpdate(updates: Array<{ nodeId: NodeId; bounds: Bounds }>): void {
+    for (const { nodeId, bounds } of updates) {
+      this.quadTree.update(nodeId, bounds)
+    }
+    this.invalidateCache()
+  }
+
   /**
    * Remove a node from the spatial index
    */

vue-litegraph-integration-plan.md

@@ -0,0 +1,37 @@
+# Vue Nodes & LiteGraph Interaction Initiatives
+
+## Initiative 1: CRDT Layout Sync Reliability
+- **Goal:** Ensure LiteGraph node geometry stays aligned with Vue-managed DOM so ghost hit targets never occur.
+- **Scope:**
+  - Update `layoutStore.batchUpdateNodeBounds` to surface changes through the existing `applyOperation`/`notifyChange` pipeline (or emit an equivalent `LayoutChange`).
+  - Verify downstream listeners (`useLayoutSync`, link/slot sync) respond when DOM-driven measurements land.
+  - Add regression coverage: unit test or integration harness exercising ResizeObserver-driven updates, asserting LiteGraph node.pos keeps pace.
+  - Document behavior in layout store comments to prevent future bypasses.
+- **Deliverables:** Code changes + tests + release notes entry summarizing the fix.
+- **Risks/Mitigations:**
+  - _Risk:_ Double-applying operations if observers already react elsewhere. _Mitigation:_ Audit listeners to ensure they only consume change events once.
+  - _Risk:_ Performance regressions from extra change objects. _Mitigation:_ Benchmark batch updates on large graphs before merge.
+- **Next Steps:**
+  1. Implement the change in a PR branch (e.g. `fix/layout-batch-change`).
+  2. Run `pnpm test:unit` and relevant integration checks.
+  3. Prepare PR with reproduction + resolution notes.
+
+## Initiative 2: LiteGraph Pointer Handling Trim in Vue Mode
+- **Goal:** Let Vue-driven nodes fully own node-level pointer interactions while LiteGraph keeps canvas-wide controls.
+- **Scope:**
+  - Introduce guard(s) in `LGraphCanvas` so node-specific handlers (`processMouseDown`, `#processNodeClick`, link slot targeting) early-exit when `LiteGraph.vueNodesMode` is true unless explicitly forwarded from Vue.
+  - Optionally validate node hits against `layoutStore` before acting, reducing reliance on LiteGraph’s stale geometry.
+  - Ensure link creation, reroute edits, groups, background panning remain intact.
+  - Add targeted tests (unit or e2e) covering Vue mode click/drag behavior on empty canvas, node body, slots.
+  - Update developer docs describing the event division of responsibilities.
+- **Deliverables:** Code adjustments + automated tests + doc updates.
+- **Risks/Mitigations:**
+  - _Risk:_ Breaking legacy fallback when Vue nodes are disabled. _Mitigation:_ Gate new logic strictly on `LiteGraph.vueNodesMode`.
+  - _Risk:_ Missing a pathway (e.g., double-click, middle-click). _Mitigation:_ Audit event map and add assertions/logging for unexpected fall-through.
+- **Next Steps:**
+  1. After Initiative 1 merges, branch (e.g. `feature/vue-node-pointer-guard`).
+  2. Implement guards + tests.
+  3. Validate with manual smoke test in Vue mode and legacy mode.
+
+---
+*Prepared October 6, 2025.*