fix(react): defer unmaterializedNodes cleanup during active Suspense (#360)

When a component inside a <Suspense> boundary creates a SelectorInstance
during render and a sibling throws a promise, React discards the entire
subtree — useEffect never runs, so the selector never gets an observer.
A component above the boundary can then commit its useEffect, triggering
unmaterializedNodes cleanup that destroys the orphaned selector. If that
selector was the only observer of a ttl:0 atom, the atom is destroyed
too, causing an infinite Suspense loop.

Track active Suspense promises via a WeakSet and counter. Defer
unmaterializedNodes cleanup while any Suspense promise is pending. When
the promise settles, React re-renders the children, useEffect creates
proper observers, and cleanup runs naturally — by which point selectors
have observers and destroy() respects their ref count.

Uses .then(fn, fn) instead of .finally() to avoid propagating rejections
into unhandled promise rejections (ErrorBoundary handles those).

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: bowheart

packages/react/src/hooks/useAtomInstance.ts

@@ -26,6 +26,13 @@ import { useReactComponentId } from './useReactComponentId'
 const unmaterializedNodes = new Set<ZeduxNode>()
 let isQueued = false
 
+// Track active Suspense promises so we can defer unmaterializedNodes cleanup
+// while any Suspense is pending. Without this, a component above the Suspense
+// boundary can commit its useEffect and destroy orphaned selectors before
+// suspended components get a chance to materialize them.
+const trackedSuspensePromises = new WeakSet<Promise<any>>()
+let activeSuspenseCount = 0
+
 /**
  * Creates an atom instance for the passed atom template based on the passed
  * params. If an instance has already been created for the passed params, reuses
@@ -180,6 +187,12 @@ export const useAtomInstance: {
       isQueued = true
       ecosystem.asyncScheduler.queue(() => {
         isQueued = false
+
+        // Defer cleanup while any Suspense is active — nodes from suspended
+        // renders are not yet abandoned and may still materialize when the
+        // promise settles.
+        if (activeSuspenseCount > 0) return
+
         unmaterializedNodes.forEach(node => node.destroy())
         unmaterializedNodes.clear()
       })
@@ -205,7 +218,24 @@ export const useAtomInstance: {
     const status = (instance as AtomInstance).promiseStatus
 
     if (status === 'loading') {
-      throw (instance as AtomInstance).promise
+      const p = (instance as AtomInstance).promise!
+
+      if (!trackedSuspensePromises.has(p)) {
+        trackedSuspensePromises.add(p)
+        activeSuspenseCount++
+
+        // Use .then(fn, fn) instead of .finally() to avoid creating an
+        // unhandled rejection when the promise rejects (which is expected —
+        // ErrorBoundary handles it, not this tracking chain).
+        const cleanup = () => {
+          trackedSuspensePromises.delete(p)
+          activeSuspenseCount--
+        }
+
+        p.then(cleanup, cleanup)
+      }
+
+      throw p
     } else if (status === 'error') {
       throw (instance as AtomInstance).promiseError
     }