atomirx 0.0.8 → 0.1.1

package/src/core/derived.test.ts

@@ -1,1215 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { atom } from "./atom";
-import { derived } from "./derived";
-import { SYMBOL_ATOM, SYMBOL_DERIVED } from "./types";
-
-describe("derived", () => {
-  describe("basic functionality", () => {
-    it("should create a derived atom from a source atom", async () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2);
-
-      expect(await doubled$.get()).toBe(10);
-    });
-
-    it("should have SYMBOL_ATOM and SYMBOL_DERIVED markers", () => {
-      const count$ = atom(0);
-      const doubled$ = derived(({ read }) => read(count$) * 2);
-
-      expect(doubled$[SYMBOL_ATOM]).toBe(true);
-      expect(doubled$[SYMBOL_DERIVED]).toBe(true);
-    });
-
-    it("should always return a Promise from .get()", () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2);
-
-      expect(doubled$.get()).toBeInstanceOf(Promise);
-    });
-
-    it("should update when source atom changes", async () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2);
-
-      expect(await doubled$.get()).toBe(10);
-      count$.set(10);
-      expect(await doubled$.get()).toBe(20);
-    });
-
-    it("should derive from multiple atoms", async () => {
-      const a$ = atom(2);
-      const b$ = atom(3);
-      const sum$ = derived(({ read }) => read(a$) + read(b$));
-
-      expect(await sum$.get()).toBe(5);
-      a$.set(10);
-      expect(await sum$.get()).toBe(13);
-      b$.set(7);
-      expect(await sum$.get()).toBe(17);
-    });
-  });
-
-  describe("staleValue", () => {
-    it("should return undefined initially without fallback", async () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2);
-
-      // Before resolution, staleValue is undefined (no fallback)
-      // After resolution, it becomes the resolved value
-      await doubled$.get();
-      expect(doubled$.staleValue).toBe(10);
-    });
-
-    it("should return fallback value initially with fallback for async", async () => {
-      // For sync atoms, computation is immediate so staleValue is already resolved
-      // Test with async dependency to verify fallback behavior
-      const asyncValue$ = atom(new Promise<number>(() => {})); // Never resolves
-      const derived$ = derived(({ read }) => read(asyncValue$) * 2, {
-        fallback: 0,
-      });
-
-      // With async dependency that's loading, state should be loading and staleValue should be fallback
-      expect(derived$.state().status).toBe("loading");
-      expect(derived$.staleValue).toBe(0);
-    });
-
-    it("should return resolved value for sync computation", async () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2, { fallback: 0 });
-
-      // Sync computation resolves immediately
-      await doubled$.get();
-      expect(doubled$.staleValue).toBe(10);
-    });
-
-    it("should update staleValue after resolution", async () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2, { fallback: 0 });
-
-      await doubled$.get();
-      expect(doubled$.staleValue).toBe(10);
-
-      count$.set(20);
-      // After recomputation
-      await doubled$.get();
-      expect(doubled$.staleValue).toBe(40);
-    });
-  });
-
-  describe("state", () => {
-    it("should return loading status during loading", async () => {
-      const asyncValue$ = atom(new Promise<number>(() => {})); // Never resolves
-      const doubled$ = derived(({ read }) => read(asyncValue$) * 2);
-
-      const state = doubled$.state();
-      expect(state.status).toBe("loading");
-    });
-
-    it("should return loading status with fallback during loading", async () => {
-      const asyncValue$ = atom(new Promise<number>(() => {})); // Never resolves
-      const doubled$ = derived(({ read }) => read(asyncValue$) * 2, {
-        fallback: 0,
-      });
-
-      // Has fallback but state is still loading (use staleValue for fallback)
-      const state = doubled$.state();
-      expect(state.status).toBe("loading");
-      expect(doubled$.staleValue).toBe(0);
-    });
-
-    it("should return ready status after resolved", async () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2, { fallback: 0 });
-
-      // Sync computation resolves immediately
-      await doubled$.get();
-
-      const state = doubled$.state();
-      expect(state.status).toBe("ready");
-      if (state.status === "ready") {
-        expect(state.value).toBe(10);
-      }
-    });
-
-    it("should return error status on error", async () => {
-      const error = new Error("Test error");
-      const count$ = atom(5);
-      const willThrow$ = derived(({ read }) => {
-        if (read(count$) > 3) {
-          throw error;
-        }
-        return read(count$);
-      });
-
-      // Wait for computation to complete
-      try {
-        await willThrow$.get();
-      } catch {
-        // Expected to throw
-      }
-
-      const state = willThrow$.state();
-      expect(state.status).toBe("error");
-      if (state.status === "error") {
-        expect(state.error).toBe(error);
-      }
-    });
-
-    it("should transition from loading to ready", async () => {
-      let resolvePromise: (value: number) => void;
-      const asyncValue$ = atom(
-        new Promise<number>((resolve) => {
-          resolvePromise = resolve;
-        })
-      );
-      const doubled$ = derived(({ read }) => read(asyncValue$) * 2, {
-        fallback: 0,
-      });
-
-      // Initially loading
-      expect(doubled$.state().status).toBe("loading");
-      expect(doubled$.staleValue).toBe(0);
-
-      // Resolve the promise
-      resolvePromise!(5);
-      await doubled$.get();
-
-      // Now ready
-      const state = doubled$.state();
-      expect(state.status).toBe("ready");
-      if (state.status === "ready") {
-        expect(state.value).toBe(10);
-      }
-      expect(doubled$.staleValue).toBe(10);
-    });
-  });
-
-  describe("refresh", () => {
-    it("should re-run computation on refresh", async () => {
-      let callCount = 0;
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => {
-        callCount++;
-        return read(count$) * 2;
-      });
-
-      await doubled$.get();
-      expect(callCount).toBeGreaterThanOrEqual(1);
-
-      const countBefore = callCount;
-      doubled$.refresh();
-      await doubled$.get();
-      expect(callCount).toBeGreaterThan(countBefore);
-    });
-  });
-
-  describe("subscriptions", () => {
-    it("should notify subscribers when derived value changes", async () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2);
-      const listener = vi.fn();
-
-      await doubled$.get(); // Initialize
-      doubled$.on(listener);
-
-      count$.set(10);
-      await doubled$.get(); // Wait for recomputation
-
-      expect(listener).toHaveBeenCalled();
-    });
-
-    it("should not notify if derived value is the same", async () => {
-      const count$ = atom(5);
-      const clamped$ = derived(({ read }) => Math.min(read(count$), 10));
-      const listener = vi.fn();
-
-      await clamped$.get();
-      clamped$.on(listener);
-
-      // Value is already clamped to 10
-      count$.set(15); // Still clamps to 10
-      await clamped$.get();
-
-      // Should still notify because we can't detect same output without full tracking
-      // This depends on implementation - adjust expectation as needed
-    });
-
-    it("should allow unsubscribing", async () => {
-      const count$ = atom(5);
-      const doubled$ = derived(({ read }) => read(count$) * 2);
-      const listener = vi.fn();
-
-      await doubled$.get();
-      const unsub = doubled$.on(listener);
-
-      count$.set(10);
-      await doubled$.get();
-      const callCount = listener.mock.calls.length;
-
-      unsub();
-
-      count$.set(20);
-      await doubled$.get();
-
-      // Should not receive more calls after unsubscribe
-      expect(listener.mock.calls.length).toBe(callCount);
-    });
-  });
-
-  describe("conditional dependencies", () => {
-    it("should only subscribe to accessed atoms", async () => {
-      const showDetails$ = atom(false);
-      const summary$ = atom("Brief");
-      const details$ = atom("Detailed");
-
-      const content$ = derived(({ read }) =>
-        read(showDetails$) ? read(details$) : read(summary$)
-      );
-
-      const listener = vi.fn();
-      await content$.get();
-      content$.on(listener);
-
-      // Initially showing summary, so details changes shouldn't trigger
-      // (This depends on implementation - conditional deps may or may not
-      // unsubscribe from unaccessed atoms)
-
-      expect(await content$.get()).toBe("Brief");
-
-      showDetails$.set(true);
-      expect(await content$.get()).toBe("Detailed");
-    });
-  });
-
-  describe("async dependencies", () => {
-    it("should handle atoms storing Promises", async () => {
-      const asyncValue$ = atom(Promise.resolve(42));
-      const doubled$ = derived(({ read }) => {
-        const value = read(asyncValue$);
-        // At this point, read() will throw the Promise if pending
-        // which is handled by derived's internal retry mechanism
-        return value;
-      });
-
-      // The derived computation handles the async dependency
-      // This test verifies the basic wiring works
-      await doubled$.get();
-      // Result depends on how promiseCache tracks the Promise
-      expect(true).toBe(true); // Test passes if no error thrown
-    });
-  });
-
-  describe("error handling", () => {
-    it("should propagate errors from computation", async () => {
-      const count$ = atom(5);
-      const willThrow$ = derived(({ read }) => {
-        if (read(count$) > 10) {
-          throw new Error("Value too high");
-        }
-        return read(count$);
-      });
-
-      expect(await willThrow$.get()).toBe(5);
-
-      count$.set(15);
-      await expect(willThrow$.get()).rejects.toThrow("Value too high");
-    });
-  });
-
-  describe("context utilities", () => {
-    it("should support all() for multiple atoms", async () => {
-      const a$ = atom(1);
-      const b$ = atom(2);
-      const c$ = atom(3);
-
-      const sum$ = derived(({ all }) => {
-        const [a, b, c] = all([a$, b$, c$]);
-        return a + b + c;
-      });
-
-      expect(await sum$.get()).toBe(6);
-    });
-
-    it("should support read() chaining", async () => {
-      const a$ = atom(2);
-      const b$ = atom(3);
-
-      const result$ = derived(({ read }) => {
-        const a = read(a$);
-        const b = read(b$);
-        return a * b;
-      });
-
-      expect(await result$.get()).toBe(6);
-    });
-  });
-
-  describe("equality options", () => {
-    it("should use strict equality by default", async () => {
-      const source$ = atom({ a: 1 });
-      const derived$ = derived(({ read }) => ({ ...read(source$) }));
-      const listener = vi.fn();
-
-      await derived$.get();
-      derived$.on(listener);
-
-      source$.set({ a: 1 }); // Same content, different reference
-      await derived$.get();
-
-      // With strict equality on derived output, listener should be called
-      // because we return a new object each time
-      expect(listener).toHaveBeenCalled();
-    });
-
-    it("should support shallow equality option", async () => {
-      const source$ = atom({ a: 1 });
-      const derived$ = derived(({ read }) => ({ ...read(source$) }), {
-        equals: "shallow",
-      });
-      const listener = vi.fn();
-
-      await derived$.get();
-      derived$.on(listener);
-
-      source$.set({ a: 1 }); // Same content
-      await derived$.get();
-
-      // With shallow equality, same content should not notify
-      // (depends on whether source triggers derived recomputation)
-    });
-  });
-
-  describe("bug fixes", () => {
-    describe("notify on loading state (Bug #1)", () => {
-      it("should notify downstream derived atoms when entering loading state", async () => {
-        // Bug: When a derived atom's dependency starts loading,
-        // it didn't notify subscribers, causing downstream atoms
-        // and useSelector to not suspend properly
-        let resolveFirst: (value: number) => void;
-        const firstPromise = new Promise<number>((r) => {
-          resolveFirst = r;
-        });
-        const base$ = atom(firstPromise);
-
-        // Create a chain: base$ -> derived1$ -> derived2$
-        const derived1$ = derived(({ read }) => read(base$) * 2);
-        const derived2$ = derived(({ read }) => read(derived1$) + 1);
-
-        const listener = vi.fn();
-        derived2$.on(listener);
-
-        // Initially loading
-        expect(derived2$.state().status).toBe("loading");
-
-        // Resolve and trigger recompute
-        resolveFirst!(5);
-        await derived2$.get();
-
-        expect(derived2$.state().status).toBe("ready");
-        // Listener should have been called when state changed
-        expect(listener).toHaveBeenCalled();
-      });
-
-      it("should propagate loading state through derived chain", async () => {
-        let resolvePromise: (value: number) => void;
-        const asyncAtom$ = atom(
-          new Promise<number>((r) => {
-            resolvePromise = r;
-          })
-        );
-
-        const level1$ = derived(({ read }) => read(asyncAtom$) * 2);
-        const level2$ = derived(({ read }) => read(level1$) + 10);
-        const level3$ = derived(({ read }) => read(level2$) * 3);
-
-        // All should be loading
-        expect(level1$.state().status).toBe("loading");
-        expect(level2$.state().status).toBe("loading");
-        expect(level3$.state().status).toBe("loading");
-
-        // Resolve
-        resolvePromise!(5);
-        await level3$.get();
-
-        // All should be ready with correct values
-        expect(level1$.state().status).toBe("ready");
-        expect(level2$.state().status).toBe("ready");
-        expect(level3$.state().status).toBe("ready");
-        expect(await level3$.get()).toBe((5 * 2 + 10) * 3); // 60
-      });
-    });
-
-    describe("no orphaned promises (Bug #2)", () => {
-      it("should not create orphaned promises when already loading", async () => {
-        // Bug: When compute() was called while already loading,
-        // it created a new Promise, orphaning the one React was waiting on
-        let resolvePromise: (value: number) => void;
-        const asyncAtom$ = atom(
-          new Promise<number>((r) => {
-            resolvePromise = r;
-          })
-        );
-
-        const derived$ = derived(({ read }) => read(asyncAtom$) * 2);
-
-        // Get the promise that would be thrown for Suspense
-        const state1 = derived$.state();
-        expect(state1.status).toBe("loading");
-        const promise1 = state1.status === "loading" ? state1.promise : null;
-
-        // Trigger another computation while still loading
-        derived$.refresh();
-
-        // Should return the SAME promise (not orphan the first one)
-        const state2 = derived$.state();
-        expect(state2.status).toBe("loading");
-        const promise2 = state2.status === "loading" ? state2.promise : null;
-
-        expect(promise1).toBe(promise2);
-
-        // Resolve and verify completion
-        resolvePromise!(21);
-        const result = await derived$.get();
-        expect(result).toBe(42);
-      });
-
-      it("should complete properly when dependency changes during loading", async () => {
-        let resolveFirst: (value: number) => void;
-        const firstPromise = new Promise<number>((r) => {
-          resolveFirst = r;
-        });
-
-        const base$ = atom(firstPromise);
-        const derived$ = derived(({ read }) => read(base$) * 2);
-
-        // Start loading
-        expect(derived$.state().status).toBe("loading");
-
-        // Simulate setting a new promise (like refetch)
-        let resolveSecond: (value: number) => void;
-        const secondPromise = new Promise<number>((r) => {
-          resolveSecond = r;
-        });
-        base$.set(secondPromise);
-
-        // The derived atom's existing computation is waiting on firstPromise
-        // When firstPromise resolves, it will retry and pick up secondPromise
-        // So we need to resolve BOTH promises
-
-        // Resolve first to trigger retry
-        resolveFirst!(5);
-
-        // Wait a tick for retry to happen
-        await new Promise((r) => setTimeout(r, 0));
-
-        // Now resolve the second promise
-        resolveSecond!(10);
-
-        // Should eventually resolve with the second value
-        const result = await derived$.get();
-        expect(result).toBe(20);
-      });
-    });
-
-    describe("notify on first resolve even when silent (Bug #3)", () => {
-      it("should notify subscribers when transitioning from loading to ready", async () => {
-        // Bug: When derived atoms were initialized with silent=true,
-        // they never called notify() even after promise resolved
-        let resolvePromise: (value: number) => void;
-        const asyncAtom$ = atom(
-          new Promise<number>((r) => {
-            resolvePromise = r;
-          })
-        );
-
-        const derived$ = derived(({ read }) => read(asyncAtom$) * 2);
-        const listener = vi.fn();
-
-        // Subscribe before resolution
-        derived$.on(listener);
-        expect(derived$.state().status).toBe("loading");
-
-        // Resolve the promise
-        resolvePromise!(5);
-        await derived$.get();
-
-        // Listener MUST be called when transitioning loading → ready
-        expect(listener).toHaveBeenCalled();
-        expect(derived$.state().status).toBe("ready");
-      });
-
-      it("should notify subscribers when transitioning from loading to error", async () => {
-        let rejectPromise: (error: Error) => void;
-        const asyncAtom$ = atom(
-          new Promise<number>((_, reject) => {
-            rejectPromise = reject;
-          })
-        );
-
-        const derived$ = derived(({ read }) => read(asyncAtom$) * 2);
-        const listener = vi.fn();
-
-        // Subscribe before rejection
-        derived$.on(listener);
-        expect(derived$.state().status).toBe("loading");
-
-        // Reject the promise
-        rejectPromise!(new Error("Test error"));
-
-        // Wait for rejection to be processed
-        try {
-          await derived$.get();
-        } catch {
-          // Expected
-        }
-
-        // Listener MUST be called when transitioning loading → error
-        expect(listener).toHaveBeenCalled();
-        expect(derived$.state().status).toBe("error");
-      });
-
-      it("should update state() correctly after async resolution", async () => {
-        // This tests the demo scenario where atoms show "Loading" forever
-        let resolvePromise: (value: number) => void;
-        const asyncAtom$ = atom(
-          new Promise<number>((r) => {
-            resolvePromise = r;
-          })
-        );
-
-        // Wrapper derived (like in the Async Utils demo)
-        const wrapper$ = derived(({ read }) => read(asyncAtom$));
-
-        // Initially loading
-        const initialState = wrapper$.state();
-        expect(initialState.status).toBe("loading");
-
-        // Resolve
-        resolvePromise!(42);
-        await wrapper$.get();
-
-        // State MUST reflect the resolved value
-        const finalState = wrapper$.state();
-        expect(finalState.status).toBe("ready");
-        if (finalState.status === "ready") {
-          expect(finalState.value).toBe(42);
-        }
-      });
-
-      it("should work with multiple wrapper derived atoms", async () => {
-        // Simulates the Async Utils demo with multiple atoms
-        const createAsyncAtom = (delayMs: number, value: number) => {
-          return atom(
-            new Promise<number>((resolve) => {
-              setTimeout(() => resolve(value), delayMs);
-            })
-          );
-        };
-
-        const atom1$ = createAsyncAtom(10, 1);
-        const atom2$ = createAsyncAtom(20, 2);
-        const atom3$ = createAsyncAtom(30, 3);
-
-        const wrapper1$ = derived(({ read }) => read(atom1$));
-        const wrapper2$ = derived(({ read }) => read(atom2$));
-        const wrapper3$ = derived(({ read }) => read(atom3$));
-
-        const listener1 = vi.fn();
-        const listener2 = vi.fn();
-        const listener3 = vi.fn();
-
-        wrapper1$.on(listener1);
-        wrapper2$.on(listener2);
-        wrapper3$.on(listener3);
-
-        // Wait for all to resolve
-        await Promise.all([wrapper1$.get(), wrapper2$.get(), wrapper3$.get()]);
-
-        // All listeners should have been called
-        expect(listener1).toHaveBeenCalled();
-        expect(listener2).toHaveBeenCalled();
-        expect(listener3).toHaveBeenCalled();
-
-        // All states should be ready
-        expect(wrapper1$.state().status).toBe("ready");
-        expect(wrapper2$.state().status).toBe("ready");
-        expect(wrapper3$.state().status).toBe("ready");
-      });
-    });
-  });
-
-  describe("ready() - reactive suspension", () => {
-    describe("basic functionality", () => {
-      it("should return non-null value immediately", async () => {
-        const id$ = atom("article-123");
-        const derived$ = derived(({ ready }) => {
-          const id = ready(id$);
-          return `loaded: ${id}`;
-        });
-
-        expect(await derived$.get()).toBe("loaded: article-123");
-      });
-
-      it("should suspend when value is null", async () => {
-        const id$ = atom<string | null>(null);
-        const derived$ = derived(({ ready }) => {
-          const id = ready(id$);
-          return `loaded: ${id}`;
-        });
-
-        // Should be in loading state (suspended)
-        expect(derived$.state().status).toBe("loading");
-      });
-
-      it("should suspend when value is undefined", async () => {
-        const id$ = atom<string | undefined>(undefined);
-        const derived$ = derived(({ ready }) => {
-          const id = ready(id$);
-          return `loaded: ${id}`;
-        });
-
-        expect(derived$.state().status).toBe("loading");
-      });
-
-      it("should NOT suspend for falsy but valid values (0, false, empty string)", async () => {
-        const zero$ = atom(0);
-        const false$ = atom(false);
-        const empty$ = atom("");
-
-        const zeroResult$ = derived(({ ready }) => ready(zero$));
-        const falseResult$ = derived(({ ready }) => ready(false$));
-        const emptyResult$ = derived(({ ready }) => ready(empty$));
-
-        expect(await zeroResult$.get()).toBe(0);
-        expect(await falseResult$.get()).toBe(false);
-        expect(await emptyResult$.get()).toBe("");
-      });
-    });
-
-    describe("reactive resumption", () => {
-      it("should resume when null value becomes non-null", async () => {
-        const id$ = atom<string | null>(null);
-        const computeCount = vi.fn();
-
-        const derived$ = derived(({ ready }) => {
-          computeCount();
-          const id = ready(id$);
-          return `loaded: ${id}`;
-        });
-
-        // Initially suspended
-        expect(derived$.state().status).toBe("loading");
-
-        // Set non-null value - should trigger recomputation
-        id$.set("article-123");
-
-        // Wait for recomputation
-        const result = await derived$.get();
-
-        expect(result).toBe("loaded: article-123");
-        expect(derived$.state().status).toBe("ready");
-        // Should have computed at least twice (once null, once with value)
-        expect(computeCount).toHaveBeenCalled();
-      });
-
-      it("should resume and compute with new value when dependency changes", async () => {
-        const id$ = atom<string | null>(null);
-        const derived$ = derived(({ ready }) => {
-          const id = ready(id$);
-          return id.toUpperCase();
-        });
-
-        // Set to first value
-        id$.set("hello");
-        expect(await derived$.get()).toBe("HELLO");
-
-        // Change to another value
-        id$.set("world");
-        expect(await derived$.get()).toBe("WORLD");
-
-        // Set back to null - should suspend again
-        id$.set(null);
-        expect(derived$.state().status).toBe("loading");
-
-        // Set to new value - should resume
-        id$.set("test");
-        expect(await derived$.get()).toBe("TEST");
-      });
-    });
-
-    describe("ready() with selector", () => {
-      it("should extract and return non-null property", async () => {
-        const user$ = atom({ id: 1, name: "John" });
-
-        const derived$ = derived(({ ready }) => {
-          const name = ready(user$, (u) => u.name);
-          return `Hello, ${name}!`;
-        });
-
-        expect(await derived$.get()).toBe("Hello, John!");
-      });
-
-      it("should suspend when selector returns null", async () => {
-        const user$ = atom<{ id: number; email: string | null }>({
-          id: 1,
-          email: null,
-        });
-
-        const derived$ = derived(({ ready }) => {
-          const email = ready(user$, (u) => u.email);
-          return `Email: ${email}`;
-        });
-
-        expect(derived$.state().status).toBe("loading");
-      });
-
-      it("should resume when selector result becomes non-null", async () => {
-        const user$ = atom<{ id: number; email: string | null }>({
-          id: 1,
-          email: null,
-        });
-
-        const derived$ = derived(({ ready }) => {
-          const email = ready(user$, (u) => u.email);
-          return `Email: ${email}`;
-        });
-
-        // Initially suspended
-        expect(derived$.state().status).toBe("loading");
-
-        // Update user with email
-        user$.set({ id: 1, email: "john@example.com" });
-
-        expect(await derived$.get()).toBe("Email: john@example.com");
-      });
-
-      it("should suspend when selector returns undefined", async () => {
-        const data$ = atom<{ value?: number }>({});
-
-        const derived$ = derived(({ ready }) => {
-          const value = ready(data$, (d) => d.value);
-          return value * 2;
-        });
-
-        expect(derived$.state().status).toBe("loading");
-
-        // Set the value
-        data$.set({ value: 21 });
-        expect(await derived$.get()).toBe(42);
-      });
-    });
-
-    describe("multiple ready() calls", () => {
-      it("should suspend until all ready() calls have non-null values", async () => {
-        const firstName$ = atom<string | null>(null);
-        const lastName$ = atom<string | null>(null);
-
-        const derived$ = derived(({ ready }) => {
-          const first = ready(firstName$);
-          const last = ready(lastName$);
-          return `${first} ${last}`;
-        });
-
-        // Both null - suspended
-        expect(derived$.state().status).toBe("loading");
-
-        // Set first name only - still suspended (lastName is null)
-        firstName$.set("John");
-        // Need to wait a tick for recomputation
-        await new Promise((r) => setTimeout(r, 0));
-        expect(derived$.state().status).toBe("loading");
-
-        // Set last name - should resolve
-        lastName$.set("Doe");
-        expect(await derived$.get()).toBe("John Doe");
-      });
-
-      it("should track all atoms from ready() calls as dependencies", async () => {
-        const a$ = atom<number | null>(null);
-        const b$ = atom<number | null>(null);
-        const listener = vi.fn();
-
-        const derived$ = derived(({ ready }) => {
-          const a = ready(a$);
-          const b = ready(b$);
-          return a + b;
-        });
-
-        derived$.on(listener);
-
-        // Set both values
-        a$.set(1);
-        b$.set(2);
-        await derived$.get();
-
-        // Should have been notified when resolved
-        expect(listener).toHaveBeenCalled();
-        expect(await derived$.get()).toBe(3);
-
-        // Clear listener calls
-        listener.mockClear();
-
-        // Change one value - should trigger recomputation
-        a$.set(10);
-        await derived$.get();
-        expect(listener).toHaveBeenCalled();
-        expect(await derived$.get()).toBe(12);
-      });
-    });
-
-    describe("combining ready() with read()", () => {
-      it("should allow mixing ready() and read() in same derived", async () => {
-        const requiredId$ = atom<string | null>(null);
-        const optionalName$ = atom("default");
-
-        const derived$ = derived(({ ready, read }) => {
-          const id = ready(requiredId$);
-          const name = read(optionalName$);
-          return { id, name };
-        });
-
-        // Suspended because requiredId is null
-        expect(derived$.state().status).toBe("loading");
-
-        // Set required value
-        requiredId$.set("123");
-        expect(await derived$.get()).toEqual({ id: "123", name: "default" });
-
-        // Change optional value
-        optionalName$.set("custom");
-        expect(await derived$.get()).toEqual({ id: "123", name: "custom" });
-      });
-
-      it("should suspend on ready() even if read() would succeed", async () => {
-        const readValue$ = atom(42);
-        const readyValue$ = atom<number | null>(null);
-
-        const derived$ = derived(({ ready, read }) => {
-          const readResult = read(readValue$);
-          const readyResult = ready(readyValue$);
-          return readResult + readyResult;
-        });
-
-        expect(derived$.state().status).toBe("loading");
-
-        readyValue$.set(8);
-        expect(await derived$.get()).toBe(50);
-      });
-    });
-
-    describe("real-world use case: current entity loading", () => {
-      it("should handle route-based entity loading pattern", async () => {
-        // Simulates /article/:id route pattern
-        const currentArticleId$ = atom<string | null>(null);
-
-        // Article cache
-        const articleCache$ = atom<Record<string, { title: string }>>({});
-
-        // Current article derived - waits for ID to be set
-        const currentArticle$ = derived(({ ready, read }) => {
-          const id = ready(currentArticleId$);
-          const cache = read(articleCache$);
-          return cache[id] ?? { title: "Not found" };
-        });
-
-        // Initially suspended (no article selected)
-        expect(currentArticle$.state().status).toBe("loading");
-
-        // User navigates to /article/123
-        currentArticleId$.set("123");
-        articleCache$.set({ "123": { title: "Hello World" } });
-
-        expect(await currentArticle$.get()).toEqual({ title: "Hello World" });
-
-        // User navigates away (deselects article)
-        currentArticleId$.set(null);
-        await new Promise((r) => setTimeout(r, 0));
-        expect(currentArticle$.state().status).toBe("loading");
-
-        // User navigates to /article/456
-        articleCache$.set({
-          "123": { title: "Hello World" },
-          "456": { title: "Another Article" },
-        });
-        currentArticleId$.set("456");
-
-        expect(await currentArticle$.get()).toEqual({
-          title: "Another Article",
-        });
-      });
-
-      it("should handle authentication-gated content", async () => {
-        const currentUser$ = atom<{ id: string; name: string } | null>(null);
-
-        const userDashboard$ = derived(({ ready }) => {
-          const user = ready(currentUser$);
-          return {
-            greeting: `Welcome back, ${user.name}!`,
-            userId: user.id,
-          };
-        });
-
-        // Not logged in - suspended
-        expect(userDashboard$.state().status).toBe("loading");
-
-        // User logs in
-        currentUser$.set({ id: "u1", name: "Alice" });
-
-        expect(await userDashboard$.get()).toEqual({
-          greeting: "Welcome back, Alice!",
-          userId: "u1",
-        });
-
-        // User logs out
-        currentUser$.set(null);
-        await new Promise((r) => setTimeout(r, 0));
-        expect(userDashboard$.state().status).toBe("loading");
-      });
-    });
-
-    describe("error handling", () => {
-      it("should propagate errors thrown after ready() succeeds", async () => {
-        const value$ = atom<number | null>(10);
-
-        const derived$ = derived(({ ready }) => {
-          const value = ready(value$);
-          if (value > 5) {
-            throw new Error("Value too high");
-          }
-          return value;
-        });
-
-        await expect(derived$.get()).rejects.toThrow("Value too high");
-        expect(derived$.state().status).toBe("error");
-      });
-
-      it("should recover from error when value changes to valid", async () => {
-        const value$ = atom<number | null>(10);
-
-        const derived$ = derived(({ ready }) => {
-          const value = ready(value$);
-          if (value > 5) {
-            throw new Error("Value too high");
-          }
-          return value * 2;
-        });
-
-        // First: error
-        await expect(derived$.get()).rejects.toThrow();
-
-        // Change to valid value
-        value$.set(3);
-        expect(await derived$.get()).toBe(6);
-      });
-    });
-
-    describe("with async dependencies", () => {
-      it("should wait for async atom AND ready() condition", async () => {
-        let resolveAsync: (value: number) => void;
-        const asyncValue$ = atom(
-          new Promise<number>((r) => {
-            resolveAsync = r;
-          })
-        );
-        const readyValue$ = atom<string | null>(null);
-
-        const derived$ = derived(({ read, ready }) => {
-          const asyncVal = read(asyncValue$);
-          const readyVal = ready(readyValue$);
-          return `${asyncVal}-${readyVal}`;
-        });
-
-        // Both loading/null - suspended
-        expect(derived$.state().status).toBe("loading");
-
-        // Resolve async - still suspended (ready is null)
-        resolveAsync!(42);
-        await new Promise((r) => setTimeout(r, 0));
-        expect(derived$.state().status).toBe("loading");
-
-        // Set ready value - should resolve
-        readyValue$.set("test");
-        expect(await derived$.get()).toBe("42-test");
-      });
-    });
-  });
-
-  describe("onError callback", () => {
-    it("should call onError when computation throws synchronously", async () => {
-      const onError = vi.fn();
-      const source$ = atom(0);
-
-      const derived$ = derived(
-        ({ read }) => {
-          const val = read(source$);
-          if (val > 0) {
-            throw new Error("Value too high");
-          }
-          return val;
-        },
-        { onError }
-      );
-
-      // Initial value - no error
-      await derived$.get();
-      expect(onError).not.toHaveBeenCalled();
-
-      // Trigger error - catch the rejection to avoid unhandled rejection warning
-      source$.set(5);
-      derived$.get().catch(() => {}); // Catch expected rejection
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(onError).toHaveBeenCalledTimes(1);
-      expect(onError).toHaveBeenCalledWith(expect.any(Error));
-      expect((onError.mock.calls[0][0] as Error).message).toBe("Value too high");
-    });
-
-    it("should call onError when async atom dependency rejects", async () => {
-      const onError = vi.fn();
-
-      // Create an atom with a rejecting Promise
-      const asyncSource$ = atom(Promise.reject(new Error("Async error")));
-
-      const derived$ = derived(
-        ({ read }) => {
-          return read(asyncSource$);
-        },
-        { onError }
-      );
-
-      // Access to trigger computation
-      derived$.get().catch(() => {}); // Catch to avoid unhandled rejection
-
-      await new Promise((r) => setTimeout(r, 20));
-
-      expect(onError).toHaveBeenCalledTimes(1);
-      expect((onError.mock.calls[0][0] as Error).message).toBe("Async error");
-    });
-
-    it("should call onError on each recomputation that throws", async () => {
-      const onError = vi.fn();
-      const source$ = atom(0);
-
-      const derived$ = derived(
-        ({ read }) => {
-          const val = read(source$);
-          if (val > 0) {
-            throw new Error(`Error for ${val}`);
-          }
-          return val;
-        },
-        { onError }
-      );
-
-      await derived$.get();
-      expect(onError).not.toHaveBeenCalled();
-
-      // First error - catch to avoid unhandled rejection
-      source$.set(1);
-      derived$.get().catch(() => {});
-      await new Promise((r) => setTimeout(r, 0));
-      expect(onError).toHaveBeenCalledTimes(1);
-
-      // Second error - catch to avoid unhandled rejection
-      source$.set(2);
-      derived$.get().catch(() => {});
-      await new Promise((r) => setTimeout(r, 0));
-      expect(onError).toHaveBeenCalledTimes(2);
-      expect((onError.mock.calls[1][0] as Error).message).toBe("Error for 2");
-    });
-
-    it("should not call onError when computation succeeds", async () => {
-      const onError = vi.fn();
-      const source$ = atom(5);
-
-      const derived$ = derived(({ read }) => read(source$) * 2, { onError });
-
-      await derived$.get();
-      source$.set(10);
-      await derived$.get();
-      source$.set(15);
-      await derived$.get();
-
-      expect(onError).not.toHaveBeenCalled();
-    });
-
-    it("should not call onError for Promise throws (Suspense)", async () => {
-      const onError = vi.fn();
-      let resolvePromise: (value: number) => void;
-      const asyncSource$ = atom(
-        new Promise<number>((resolve) => {
-          resolvePromise = resolve;
-        })
-      );
-
-      const derived$ = derived(({ read }) => read(asyncSource$) * 2, {
-        onError,
-      });
-
-      // Still loading - onError should NOT be called
-      await new Promise((r) => setTimeout(r, 10));
-      expect(onError).not.toHaveBeenCalled();
-
-      // Resolve successfully
-      resolvePromise!(5);
-      expect(await derived$.get()).toBe(10);
-      expect(onError).not.toHaveBeenCalled();
-    });
-
-    it("should work without onError callback", async () => {
-      const source$ = atom(0);
-
-      const derived$ = derived(({ read }) => {
-        const val = read(source$);
-        if (val > 0) {
-          throw new Error("Error");
-        }
-        return val;
-      });
-
-      // Should not throw even without onError
-      await derived$.get();
-      source$.set(5);
-      derived$.get().catch(() => {}); // Catch expected rejection
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(derived$.state().status).toBe("error");
-    });
-
-    it("should allow error recovery and call onError again on subsequent errors", async () => {
-      const onError = vi.fn();
-      const source$ = atom(0);
-
-      const derived$ = derived(
-        ({ read }) => {
-          const val = read(source$);
-          if (val === 1) {
-            throw new Error("First error");
-          }
-          if (val === 3) {
-            throw new Error("Second error");
-          }
-          return val * 2;
-        },
-        { onError }
-      );
-
-      await derived$.get(); // 0 -> success
-      expect(onError).not.toHaveBeenCalled();
-
-      source$.set(1); // error
-      derived$.get().catch(() => {}); // Catch expected rejection
-      await new Promise((r) => setTimeout(r, 0));
-      expect(onError).toHaveBeenCalledTimes(1);
-
-      source$.set(2); // recover
-      expect(await derived$.get()).toBe(4);
-      expect(onError).toHaveBeenCalledTimes(1); // still 1
-
-      source$.set(3); // error again
-      derived$.get().catch(() => {}); // Catch expected rejection
-      await new Promise((r) => setTimeout(r, 0));
-      expect(onError).toHaveBeenCalledTimes(2);
-    });
-  });
-});