test: add test for subscriptionRef recomputation with derived state

Add a test to verify that subscriptionRef atoms properly recompute when
their dependencies change. This test was added based on a user report
that subscriptionRef atoms don't recompute when dependencies accessed
via get.some() change.

The test verifies that both regular derived atoms and subscriptionRef
atoms correctly recompute when an Option dependency changes value.

Author: mikearnaldi

packages/atom/test/Atom.test.ts

@@ -1446,6 +1446,80 @@ describe("Atom", () => {
 
     unmount2()
   })
+
+  it("subscriptionRef with runtime recomputes when dependencies change", async () => {
+    vitest.useRealTimers()
+
+    // Test that subscriptionRef atoms properly recompute when their dependencies change
+    // This test was added based on a user report that subscriptionRef atoms don't recompute
+    // when dependencies accessed via get.some() change.
+    const chatIdAtom = Atom.make<Option.Option<string>>(Option.none()).pipe(Atom.keepAlive)
+
+    // A regular derived atom using Effect.fnUntraced
+    let derivedRecomputes = 0
+    const derivedStateAtom = counterRuntime.atom(
+      Effect.fnUntraced(function*(get: Atom.Context) {
+        const chatId = yield* get.some(chatIdAtom)
+        derivedRecomputes++
+        return chatId
+      })
+    )
+
+    // A subscriptionRef atom that also depends on chatIdAtom
+    let subRefRecomputes = 0
+    const stateAtom = counterRuntime.subscriptionRef((get) =>
+      Effect.gen(function*() {
+        const chatId = yield* get.some(chatIdAtom)
+        subRefRecomputes++
+        return yield* SubscriptionRef.make(chatId)
+      })
+    )
+
+    const r = Registry.make()
+    const unmountDerived = r.mount(derivedStateAtom)
+    const unmountSubRef = r.mount(stateAtom)
+
+    // Initially, chatIdAtom is None, so both should fail with NoSuchElementException
+    let derivedResult = r.get(derivedStateAtom)
+    let subRefResult = r.get(stateAtom)
+    expect(derivedRecomputes).toEqual(0)
+    expect(subRefRecomputes).toEqual(0)
+
+    // Set chatIdAtom to Some("chat-1")
+    r.set(chatIdAtom, Option.some("chat-1"))
+    await new Promise((resolve) => resolve(null))
+
+    derivedResult = r.get(derivedStateAtom)
+    subRefResult = r.get(stateAtom)
+
+    assert(Result.isSuccess(derivedResult))
+    expect(derivedResult.value).toEqual("chat-1")
+    expect(derivedRecomputes).toEqual(1)
+
+    assert(Result.isSuccess(subRefResult))
+    expect(subRefResult.value).toEqual("chat-1")
+    expect(subRefRecomputes).toEqual(1)
+
+    // Change chatIdAtom to Some("chat-2") - both atoms should recompute
+    r.set(chatIdAtom, Option.some("chat-2"))
+    await new Promise((resolve) => resolve(null))
+
+    derivedResult = r.get(derivedStateAtom)
+    subRefResult = r.get(stateAtom)
+
+    // The derived atom should have recomputed
+    assert(Result.isSuccess(derivedResult))
+    expect(derivedResult.value).toEqual("chat-2")
+    expect(derivedRecomputes).toEqual(2)
+
+    // The subscriptionRef atom should ALSO have recomputed
+    assert(Result.isSuccess(subRefResult))
+    expect(subRefResult.value).toEqual("chat-2")
+    expect(subRefRecomputes).toEqual(2)
+
+    unmountDerived()
+    unmountSubRef()
+  })
 })
 
 interface BuildCounter {