test: add tests for subscriptionRef recomputation with derived state

Add tests to verify subscriptionRef atom behavior:

1. Test that subscriptionRef atoms properly recompute when their dependencies
   change (using get.some() to access Option atoms).

2. Test demonstrating that using multiple registries (i.e., not wrapping the
   app with RegistryProvider) causes atoms to not see each other's updates.
   This explains the user-reported issue where subscriptionRef atoms don't
   recompute - if there's no shared registry context, different parts of
   the app may use different registry instances.

Author: mikearnaldi

packages/atom/test/Atom.test.ts

@@ -1446,6 +1446,136 @@ 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()
+  })
+
+  it("subscriptionRef fails with multiple registries (no shared context)", async () => {
+    vitest.useRealTimers()
+
+    // This test simulates what happens when there's no RegistryProvider wrapping the app.
+    // Different parts of the app might end up using different registries, which could
+    // cause atoms to not see each other's updates.
+    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)
+      })
+    )
+
+    // Simulate the problematic scenario: using different registries
+    // This is what happens when there's no RegistryProvider - each useAtom call
+    // might get a different registry instance
+    const r1 = Registry.make() // Registry for chatIdAtom updates
+    const r2 = Registry.make() // Registry for derivedStateAtom
+    const r3 = Registry.make() // Registry for stateAtom
+
+    // Mount atoms in their respective registries
+    const unmountDerived = r2.mount(derivedStateAtom)
+    const unmountSubRef = r3.mount(stateAtom)
+
+    // Set chatIdAtom in r1 - this update won't propagate to r2 and r3!
+    r1.set(chatIdAtom, Option.some("chat-1"))
+    await new Promise((resolve) => resolve(null))
+
+    // The atoms in r2 and r3 won't see the update because they're using different registries
+    // This demonstrates why RegistryProvider is important
+    r2.get(derivedStateAtom)
+    r3.get(stateAtom)
+
+    // Both atoms should still be in their initial state because they didn't see the update
+    expect(derivedRecomputes).toEqual(0)
+    expect(subRefRecomputes).toEqual(0)
+
+    unmountDerived()
+    unmountSubRef()
+  })
 })
 
 interface BuildCounter {