@ersbeth/picoflow 1.1.2 → 2.0.0

package/test/reactivity/nodes/async/flowDerivationAsync.test.ts

@@ -0,0 +1,1716 @@
+import { describe, expect, it, vi } from "vitest";
+import type { FlowTracker } from "~";
+import { derivationAsync, signal, stateAsync, subscribe } from "~";
+import { EffectNode } from "~/nodes";
+
+describe("flowDerivationAsync", () => {
+    describe("unit", () => {
+        describe("initialization", () => {
+            it("should not call compute function on creation", () => {
+                const computeFn = vi.fn(async () => 42);
+                derivationAsync(computeFn);
+
+                expect(computeFn).not.toHaveBeenCalled();
+            });
+
+            it("should call compute function on first access", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn((t: FlowTracker) => $state.get(t) * 2);
+
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    return computeFn(t);
+                });
+
+                expect(computeFn).not.toHaveBeenCalled();
+
+                const value = await $derivation.pick();
+
+                expect(value).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should call compute function again when dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => {
+                    await Promise.resolve();
+                    return $state.get(t) * 2;
+                });
+                const $derivation = derivationAsync(computeFn);
+
+                const result1 = await $derivation.pick();
+                expect(result1).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $state.set(Promise.resolve(2));
+                const result2 = await $derivation.pick();
+                expect(result2).toBe(4);
+                expect(computeFn).toHaveBeenCalledTimes(4);
+            });
+
+            it("should support self-derivation function without previous value", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const compute = async (t: FlowTracker) => {
+                    await Promise.resolve();
+                    return $state.get(t) * 2;
+                };
+                const $derivation = derivationAsync(compute);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                $derivation.subscribe(onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(0));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                const result = await $derivation.pick();
+                expect(result).toBe(2);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+            });
+
+            it("should support self-derivation function with previous value", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const compute = async (t: FlowTracker, previous?: number) => {
+                    await Promise.resolve();
+                    const current = $state.get(t);
+                    return previous !== undefined ? previous + current : current;
+                };
+                const $derivation = derivationAsync(compute);
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+                $derivation.subscribe(onData, onError);
+
+                expect(await $derivation.pick()).toBe(1);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $state.set(Promise.resolve(2));
+                expect(await $derivation.pick()).toBe(3);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(3);
+            });
+        });
+
+        describe("reactive dependencies", () => {
+            it("should recompute when state dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+
+                expect(await $derivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $state.set(Promise.resolve(2));
+                expect(await $derivation.pick()).toBe(4);
+                expect(computeFn).toHaveBeenCalledTimes(4);
+            });
+
+            it("should recompute when signal dependency is triggered", async () => {
+                const $signal = signal();
+                const $state = stateAsync(Promise.resolve(0));
+                const computeFn = vi.fn(async (t) => {
+                    await Promise.resolve();
+                    $signal.watch(t);
+                    return $state.get(t);
+                });
+                const $derivation = derivationAsync(computeFn);
+
+                expect(await $derivation.pick()).toBe(0);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $state.set(Promise.resolve(1));
+                $signal.trigger();
+                expect(await $derivation.pick()).toBe(1);
+                expect(computeFn).toHaveBeenCalledTimes(4);
+            });
+
+            it("should recompute when another derivation dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                derivationAsync(async (t) => $derivation1.get(t) * 2);
+                const computeFn = vi.fn(async (t) => $derivation1.get(t) * 2);
+                const $derivation2 = derivationAsync(computeFn);
+
+                expect(await $derivation2.pick()).toBe(4);
+                expect(computeFn).toHaveBeenCalledTimes(3);
+
+                $state.set(Promise.resolve(2));
+                expect(await $derivation2.pick()).toBe(8);
+                expect(computeFn).toHaveBeenCalledTimes(6);
+            });
+
+            it("should mark as dirty when dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $state.set(Promise.resolve(2));
+                // Should be dirty but not recomputed yet
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                // Next access triggers recomputation
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(4);
+            });
+
+            it("should recompute if value is identical after dependency change", async () => {
+                const $state = stateAsync(Promise.resolve(2));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 0);
+                const $derivation = derivationAsync(computeFn);
+                const onData = vi.fn();
+
+                $derivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(0);
+
+                $state.set(Promise.resolve(5));
+                // Value is still 0 (2*0 = 0, 5*0 = 0), but derivation is marked dirty
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(0);
+            });
+
+            it("should recompute only on next access when dirty", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                // Multiple dependency changes
+                $state.set(Promise.resolve(2));
+                $state.set(Promise.resolve(3));
+                $state.set(Promise.resolve(4));
+
+                // Still only called once more (lazy recomputation)
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(4);
+            });
+        });
+
+        describe("pick", () => {
+            it("should return computed value without tracking", async () => {
+                const $state = stateAsync(Promise.resolve(15));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const value = await $derivation.pick();
+                expect(value).toBe(30);
+            });
+
+            it("should compute lazy value on first pick call", async () => {
+                const computeFn = vi.fn(async (t) => {
+                    await Promise.resolve();
+                    return $state.get(t) * 2;
+                });
+
+                const $state = stateAsync(Promise.resolve(25));
+                const $derivation = derivationAsync(computeFn);
+
+                expect(computeFn).not.toHaveBeenCalled();
+                const value = await $derivation.pick();
+                expect(value).toBe(50);
+
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should recompute when dependency changes without tracking", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+
+                expect(await $derivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $state.set(Promise.resolve(2));
+                expect(await $derivation.pick()).toBe(4);
+                expect(computeFn).toHaveBeenCalledTimes(4);
+            });
+        });
+
+        describe("refresh", () => {
+            it("should force recomputation even if not dirty", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                let factor = 2;
+                const computeFn = vi.fn(async (t) => $state.get(t) * factor);
+                const $derivation = derivationAsync(computeFn);
+
+                const result1 = await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(2);
+                expect(result1).toBe(2);
+
+                factor = 3;
+                $derivation.refresh();
+                const result2 = await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(3);
+                expect(result2).toBe(3);
+            });
+
+            it("should notify only if value changes after refresh", async () => {
+                let multiplier = 2;
+                const $state = stateAsync(Promise.resolve(5));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * multiplier);
+                const onData = vi.fn();
+
+                $derivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                multiplier = 3;
+                $derivation.refresh();
+                // Refresh triggers notification asynchronously
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2), {
+                    timeout: 2000,
+                });
+                expect(onData).toHaveBeenLastCalledWith(15);
+            });
+
+            it("should not notify if value is identical after refresh", async () => {
+                const $state = stateAsync(Promise.resolve(5));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $derivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $derivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+
+            it("should force recomputation even if dependencies have not changed", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $derivation.refresh();
+                expect(computeFn).toHaveBeenCalledTimes(3);
+            });
+        });
+
+        describe("subscribe", () => {
+            it("should return an effect", () => {
+                const $state = stateAsync(Promise.resolve(50));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                const effect = $derivation.subscribe(onData);
+
+                expect(effect).toBeInstanceOf(EffectNode);
+            });
+
+            it("should call onData immediately with computed value", async () => {
+                const $state = stateAsync(Promise.resolve(55));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $derivation.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(110);
+            });
+
+            it("should call onData when value changes", async () => {
+                const $state = stateAsync(Promise.resolve(60));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $derivation.subscribe((value) => onData(value));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(120);
+
+                $state.set(Promise.resolve(70));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(140);
+            });
+
+            it("should not call onData when value does not change", async () => {
+                const $state = stateAsync(Promise.resolve(75));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $derivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(150);
+
+                $state.set(Promise.resolve(75));
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+                expect(onData).toHaveBeenLastCalledWith(150);
+            });
+
+            it("should support multiple subscriptions", async () => {
+                const $state = stateAsync(Promise.resolve(80));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData1 = vi.fn();
+                const onData2 = vi.fn();
+                const onData3 = vi.fn();
+
+                $derivation.subscribe(onData1);
+                $derivation.subscribe(onData2);
+                $derivation.subscribe(onData3);
+
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(1);
+                    expect(onData3).toHaveBeenCalledTimes(1);
+                });
+
+                expect(onData1).toHaveBeenLastCalledWith(160);
+                expect(onData2).toHaveBeenLastCalledWith(160);
+                expect(onData3).toHaveBeenLastCalledWith(160);
+            });
+
+            it("should dispose effect when disposer is called", async () => {
+                const $state = stateAsync(Promise.resolve(85));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                const effect = $derivation.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(170);
+
+                $state.set(Promise.resolve(90));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(180);
+
+                effect.dispose();
+
+                $state.set(Promise.resolve(95));
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+                expect(onData).toHaveBeenLastCalledWith(180);
+            });
+
+            it("should recompute when dependency changes with tracking via subscribe", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+                const onData = vi.fn();
+
+                $derivation.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+            });
+
+            it("should register dependencies automatically via tracker in subscribe", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(2));
+                const computeFn = vi.fn(async (t) => {
+                    await Promise.resolve();
+                    return $state1.get(t) + $state2.get(t);
+                });
+                const $derivation = derivationAsync(computeFn);
+                const onData = vi.fn();
+
+                $derivation.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(3);
+
+                $state1.set(Promise.resolve(3));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(5);
+
+                $state2.set(Promise.resolve(4));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(7);
+            });
+        });
+
+        describe("trigger", () => {
+            it("should return a Promise", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                $derivation.subscribe((value) => {
+                    onData(value);
+                });
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $derivation.trigger();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+            });
+
+            it("should allow multiple triggers", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                $derivation.subscribe((value) => {
+                    onData(value);
+                });
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $derivation.trigger();
+                $derivation.trigger();
+                $derivation.trigger();
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(2);
+            });
+        });
+
+        describe("dynamic dependencies", () => {
+            it("should handle dependencies that change between computations", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(10));
+                const $cond = stateAsync(Promise.resolve(true));
+                const $derivation = derivationAsync(async (t) => {
+                    if (await $cond.get(t)) {
+                        return (await $state1.get(t)) * 2;
+                    }
+                    return (await $state2.get(t)) * 2;
+                });
+
+                // Initially depends on state1
+                expect(await $derivation.pick()).toBe(2);
+
+                // Change state1 - should recompute
+                $state1.set(Promise.resolve(2));
+                expect(await $derivation.pick()).toBe(4);
+
+                // Switch to state2 dependency
+                $cond.set(Promise.resolve(false));
+                expect(await $derivation.pick()).toBe(20);
+
+                // Change state2 - should recompute
+                $state2.set(Promise.resolve(20));
+                expect(await $derivation.pick()).toBe(40);
+
+                // Change state1 - should NOT recompute (no longer a dependency)
+                $state1.set(Promise.resolve(100));
+                expect(await $derivation.pick()).toBe(40);
+            });
+
+            it("should unregister dependencies that are no longer used", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(10));
+                const $cond = stateAsync(Promise.resolve(true));
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    if ($cond.get(t)) {
+                        return $state1.get(t);
+                    }
+                    return $state2.get(t);
+                });
+                const onData = vi.fn();
+
+                $derivation.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $cond.set(Promise.resolve(false));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $state1.set(Promise.resolve(100));
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+
+            it("should handle dependencies that appear and disappear", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(2));
+                const $useState1 = stateAsync(Promise.resolve(true));
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    if ($useState1.get(t)) {
+                        return $state1.get(t);
+                    }
+                    return $state2.get(t);
+                });
+
+                const onData = vi.fn();
+                $derivation.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $useState1.set(Promise.resolve(false));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $useState1.set(Promise.resolve(true));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(1);
+            });
+        });
+
+        describe("nested derivations", () => {
+            it("should handle derivation depending on another derivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivation2 = derivationAsync(async (t) => $derivation1.get(t) * 2);
+
+                expect(await $derivation2.pick()).toBe(4);
+
+                $state.set(Promise.resolve(2));
+                expect(await $derivation2.pick()).toBe(8);
+            });
+
+            it("should handle chain of derivations", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivationA = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivationB = derivationAsync(async (t) => $derivationA.get(t) * 2);
+                const $derivationC = derivationAsync(async (t) => $derivationB.get(t) * 2);
+
+                expect(await $derivationC.pick()).toBe(8);
+
+                $state.set(Promise.resolve(2));
+                expect(await $derivationC.pick()).toBe(16);
+            });
+
+            it("should handle nested derivations", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivation2 = derivationAsync(async (t) => $derivation1.get(t) * 2);
+
+                expect(await $derivation2.pick()).toBe(4);
+
+                $state.set(Promise.resolve(2));
+                expect(await $derivation2.pick()).toBe(8);
+            });
+
+            it("should recompute in cascade when dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFnA = vi.fn(async (t) => $state.get(t) * 2);
+                const computeFnB = vi.fn(async (t) => {
+                    await Promise.resolve();
+                    return $derivationA.get(t) * 2;
+                });
+                const $derivationA = derivationAsync(computeFnA);
+                const $derivationB = derivationAsync(computeFnB);
+
+                await $derivationB.pick();
+                expect(computeFnA).toHaveBeenCalled();
+                expect(computeFnB).toHaveBeenCalled();
+
+                $state.set(Promise.resolve(2));
+                await $derivationB.pick();
+                expect(computeFnA).toHaveBeenCalledTimes(4);
+                expect(computeFnB).toHaveBeenCalledTimes(6);
+            });
+        });
+
+        describe("error handling", () => {
+            it("should propagate errors in compute function with dependencies", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const error = new Error("Compute error");
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const value = $state.get(t);
+                    if (value > 1) {
+                        throw error;
+                    }
+                    return value;
+                });
+
+                expect(await $derivation.pick()).toBe(1);
+
+                $state.set(Promise.resolve(2));
+                await expect($derivation.pick()).rejects.toThrow(error);
+            });
+
+            it("should propagate error when pick is called with throwing compute", async () => {
+                const error = new Error("Compute pick error");
+                const $derivation = derivationAsync(async () => {
+                    await Promise.resolve();
+                    throw error;
+                });
+
+                await expect($derivation.pick()).rejects.toThrow("Compute pick error");
+            });
+
+            it("should propagate error when pick throws on subsequent compute", async () => {
+                let throwNow = false;
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    if (throwNow) {
+                        throw new Error("Compute pick error");
+                    }
+                    return $state.get(t);
+                });
+
+                expect(await $derivation.pick()).toBe(1);
+
+                throwNow = true;
+                $state.set(Promise.resolve(2));
+                await expect($derivation.pick()).rejects.toThrow("Compute pick error");
+            });
+
+            it("should throw error when pick is called after disposal", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+
+                await $derivation.pick();
+                $derivation.dispose();
+
+                await expect($derivation.pick()).rejects.toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw error when refresh is called after disposal", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+
+                $derivation.dispose();
+
+                await expect(() => $derivation.refresh()).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw error when subscribe is called after disposal", () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $derivation.dispose();
+
+                expect(() => $derivation.subscribe(onData)).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should throw error when trigger is called after disposal", async () => {
+                await Promise.resolve();
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                $derivation.dispose();
+                expect(() => $derivation.trigger()).toThrow("[PicoFlow] Primitive is disposed");
+            });
+        });
+
+        describe("disposal", () => {
+            it("should have disposed property set to false initially", () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                expect($derivation.disposed).toBe(false);
+            });
+
+            it("should have disposed property set to true after disposal", () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => (await $state.get(t)) * 2);
+                $derivation.dispose();
+                expect($derivation.disposed).toBe(true);
+            });
+
+            it("should throw error when disposed twice", () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => (await $state.get(t)) * 2);
+                $derivation.dispose();
+                expect(() => $derivation.dispose()).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should accept self option without throwing", () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => (await $state.get(t)) * 2);
+                expect(() => $derivation.dispose()).not.toThrow();
+                expect($derivation.disposed).toBe(true);
+            });
+
+            it("should accept default options without throwing", () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => (await $state.get(t)) * 2);
+                expect(() => $derivation.dispose()).not.toThrow();
+                expect($derivation.disposed).toBe(true);
+            });
+        });
+
+        describe("special cases", () => {
+            it("should handle compute function that returns undefined", async () => {
+                const $state = stateAsync(Promise.resolve(true));
+                const $derivation = derivationAsync(async (t) => ((await $state.get(t)) ? undefined : "defined"));
+                expect(await $derivation.pick()).toBeUndefined();
+            });
+
+            it("should handle compute function that throws error", async () => {
+                const error = new Error("Compute error");
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => {
+                    if ((await $state.get(t)) === 1) {
+                        throw error;
+                    }
+                    return (await $state.get(t)) * 2;
+                });
+
+                await expect($derivation.pick()).rejects.toThrow("Compute error");
+            });
+        });
+    });
+
+    describe("with effect", () => {
+        describe("get", () => {
+            it("should create reactive dependency when get is used in effect", async () => {
+                const $state = stateAsync(Promise.resolve(100));
+                const $derivation = derivationAsync(async (t) => (await $state.get(t)) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+            });
+
+            it("should call effect with initial computed value", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => (await $state.get(t)) * 2);
+                const onData = vi.fn();
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+            });
+
+            it("should call effect when dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+            });
+
+            it("should not call effect when value does not change", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(Promise.resolve(1));
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+
+            it("should not call effect after effect is disposed", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                const $effect = subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $effect.dispose();
+
+                $state.set(Promise.resolve(3));
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+
+            it("should support multiple effects depending on same derivation", async () => {
+                const $state = stateAsync(Promise.resolve(200));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData1 = vi.fn();
+                const onData2 = vi.fn();
+                const onData3 = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData1);
+
+                subscribe((t) => $derivation.get(t), onData2);
+
+                subscribe((t) => $derivation.get(t), onData3);
+
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(1);
+                    expect(onData3).toHaveBeenCalledTimes(1);
+                });
+
+                $state.set(Promise.resolve(300));
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(2);
+                    expect(onData2).toHaveBeenCalledTimes(2);
+                    expect(onData3).toHaveBeenCalledTimes(2);
+                });
+            });
+
+            it("should support effect depending on multiple derivations", async () => {
+                const $stateA = stateAsync(Promise.resolve(5));
+                const $stateB = stateAsync(Promise.resolve(10));
+                const $derivationA = derivationAsync(async (t) => (await $stateA.get(t)) * 2);
+                const $derivationB = derivationAsync(async (t) => (await $stateB.get(t)) * 2);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => ({
+                        a: $derivationA.get(t),
+                        b: $derivationB.get(t),
+                    }),
+                    (data) => onData(data.a, data.b),
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10, 20);
+
+                $stateA.set(Promise.resolve(6));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(12, 20);
+
+                $stateB.set(Promise.resolve(11));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(12, 22);
+            });
+
+            it("should recompute when dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+            });
+
+            it("should register dependencies automatically", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(2));
+                const computeFn = vi.fn(async (t) => {
+                    await Promise.resolve();
+                    return $state1.get(t) + $state2.get(t);
+                });
+                const $derivation = derivationAsync(computeFn);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(3);
+
+                $state1.set(Promise.resolve(3));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(5);
+
+                $state2.set(Promise.resolve(4));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(7);
+            });
+
+            it("should propagate errors in compute function with dependencies", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const error = new Error("Compute error");
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const value = $state.get(t);
+                    if (value > 1) {
+                        throw error;
+                    }
+                    return value;
+                });
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                expect(onError).toHaveBeenLastCalledWith(error);
+            });
+
+            it("should propagate error when lazy compute throws in effect", async () => {
+                const error = new Error("Effect compute error");
+                const $derivation = derivationAsync(async () => {
+                    await Promise.resolve();
+                    throw error;
+                });
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                expect(onError).toHaveBeenLastCalledWith(error);
+            });
+
+            it("should propagate error when lazy compute throws on subsequent effect run", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const error = new Error("Effect compute error");
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const value = $state.get(t);
+                    if (value > 1) {
+                        throw error;
+                    }
+                    return value;
+                });
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                expect(onError).toHaveBeenLastCalledWith(error);
+            });
+
+            it("should throw error when creating an effect with a disposed derivation", async () => {
+                const $derivation = derivationAsync(async (t) => (await stateAsync(Promise.resolve(1)).get(t)) * 2);
+
+                $derivation.dispose();
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                expect(onError).toHaveBeenLastCalledWith(expect.any(Error));
+            });
+        });
+
+        describe("watch", () => {
+            it("should register dependency when watch is used in effect", async () => {
+                const $state = stateAsync(Promise.resolve(400));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.watch(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+            });
+
+            it("should trigger re-runs when derivation changes after watch", async () => {
+                const $state = stateAsync(Promise.resolve(500));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.watch(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(Promise.resolve(600));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+            });
+        });
+
+        describe("reactive dependencies", () => {
+            it("should re-execute effect when derivation dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+            });
+
+            it("should re-execute effect if derivation value is identical", async () => {
+                const $state = stateAsync(Promise.resolve(2));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 0);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(Promise.resolve(5));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+            });
+
+            it("should work with derivation depending on state", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => (await $state.get(t)) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+            });
+
+            it("should work with derivation depending on signal", async () => {
+                const $signal = signal();
+                const $state = stateAsync(Promise.resolve(0));
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    $signal.watch(t);
+                    return $state.get(t);
+                });
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(0);
+
+                $state.set(Promise.resolve(1));
+                $signal.trigger();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(1);
+            });
+
+            it("should work with derivation depending on another derivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivation2 = derivationAsync(async (t) => $derivation1.get(t) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation2.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(8);
+            });
+        });
+
+        describe("multiple dependencies", () => {
+            it("should work with derivation depending on multiple states", async () => {
+                const $stateA = stateAsync(Promise.resolve(5));
+                const $stateB = stateAsync(Promise.resolve(10));
+                const $derivation = derivationAsync(async (t) => $stateA.get(t) + $stateB.get(t));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(15);
+
+                $stateA.set(Promise.resolve(6));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(16);
+
+                $stateB.set(Promise.resolve(11));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(17);
+            });
+
+            it("should work with derivation depending on multiple signals", async () => {
+                const $signal1 = signal();
+                const $signal2 = signal();
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    $signal1.watch(t);
+                    $signal2.watch(t);
+                    return 42;
+                });
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.watch(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $signal1.trigger();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+
+                $signal2.trigger();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+            });
+
+            it("should work with derivation depending on state and signal", async () => {
+                const $signal = signal();
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    $signal.watch(t);
+                    return $state.get(t) * 2;
+                });
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $signal.trigger();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(4);
+            });
+
+            it("should work with derivation depending on state and another derivation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivation2 = derivationAsync(async (t) => $state.get(t) + $derivation1.get(t));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation2.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(3);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(6);
+            });
+
+            it("should handle multiple dependants", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivation2 = derivationAsync(async (t) => $state.get(t) * 3);
+                const onData1 = vi.fn();
+                const onData2 = vi.fn();
+                const onError1 = vi.fn();
+                const onError2 = vi.fn();
+
+                subscribe((t) => $derivation1.get(t), onData1, onError1);
+                subscribe((t) => $derivation2.get(t), onData2, onError2);
+
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(1);
+                });
+                expect(onData1).toHaveBeenLastCalledWith(2);
+                expect(onData2).toHaveBeenLastCalledWith(3);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(2);
+                    expect(onData2).toHaveBeenCalledTimes(2);
+                });
+                expect(onData1).toHaveBeenLastCalledWith(4);
+                expect(onData2).toHaveBeenLastCalledWith(6);
+            });
+        });
+
+        describe("nested derivations", () => {
+            it("should work with chained derivations", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivation2 = derivationAsync(async (t) => $derivation1.get(t) * 2);
+                const $derivation3 = derivationAsync(async (t) => $derivation2.get(t) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation3.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(8);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(16);
+            });
+
+            it("should re-execute effect when distant dependency changes", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivation2 = derivationAsync(async (t) => $derivation1.get(t) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation2.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(8);
+            });
+
+            it("should propagate changes correctly through the chain", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation1 = derivationAsync(async (t) => $state.get(t) * 2);
+                const $derivation2 = derivationAsync(async (t) => $derivation1.get(t) * 2);
+                const onData1 = vi.fn();
+                const onData2 = vi.fn();
+                const onError1 = vi.fn();
+                const onError2 = vi.fn();
+
+                subscribe((t) => $derivation1.get(t), onData1, onError1);
+                subscribe((t) => $derivation2.get(t), onData2, onError2);
+
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(1);
+                });
+                expect(onData1).toHaveBeenLastCalledWith(2);
+                expect(onData2).toHaveBeenLastCalledWith(4);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(2);
+                    expect(onData2).toHaveBeenCalledTimes(2);
+                });
+                expect(onData1).toHaveBeenLastCalledWith(4);
+                expect(onData2).toHaveBeenLastCalledWith(8);
+            });
+        });
+
+        describe("dynamic dependencies", () => {
+            it("should work with derivation with conditional dependencies", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(10));
+                const $cond = stateAsync(Promise.resolve(true));
+                const $derivation = derivationAsync(async (t) => {
+                    if (await $cond.get(t)) {
+                        return (await $state1.get(t)) * 2;
+                    }
+                    return (await $state2.get(t)) * 2;
+                });
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state1.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $cond.set(Promise.resolve(false));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(20);
+
+                $state2.set(Promise.resolve(20));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(40);
+            });
+
+            it("should re-execute effect when dependencies change dynamically", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(2));
+                const $useState1 = stateAsync(Promise.resolve(true));
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    if ($useState1.get(t)) {
+                        return $state1.get(t);
+                    }
+                    return $state2.get(t);
+                });
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $useState1.set(Promise.resolve(false));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state1.set(Promise.resolve(10));
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+
+                $state2.set(Promise.resolve(20));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(20);
+            });
+
+            it("should unregister old dependencies correctly", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(10));
+                const $cond = stateAsync(Promise.resolve(true));
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    if ($cond.get(t)) {
+                        return $state1.get(t);
+                    }
+                    return $state2.get(t);
+                });
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $cond.set(Promise.resolve(false));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+
+                $state1.set(Promise.resolve(100));
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+
+            it("should handle derivation with dynamic dependencies", async () => {
+                const $state1 = stateAsync(Promise.resolve(1));
+                const $state2 = stateAsync(Promise.resolve(10));
+                const $cond = stateAsync(Promise.resolve(true));
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    if ($cond.get(t)) {
+                        return $state1.get(t) * 2;
+                    }
+                    return $state2.get(t) * 2;
+                });
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state1.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $cond.set(Promise.resolve(false));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(20);
+
+                $state2.set(Promise.resolve(20));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(40);
+            });
+        });
+
+        describe("complex patterns", () => {
+            it("should handle diamond pattern", async () => {
+                const $stateA = stateAsync(Promise.resolve(1));
+                const $aMult3 = derivationAsync(async (t) => $stateA.get(t) * 3);
+                const $aMult2 = derivationAsync(async (t) => $stateA.get(t) * 2);
+                const $addAmult3Amult2 = derivationAsync(async (t) => $aMult3.get(t) + $aMult2.get(t));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $addAmult3Amult2.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(5);
+
+                $stateA.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $stateA.set(Promise.resolve(3));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(15);
+            });
+
+            it("should handle multi-diamond pattern", async () => {
+                const $stateA = stateAsync(Promise.resolve(1));
+                const $stateB = stateAsync(Promise.resolve(2));
+                const $addAB = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const a = $stateA.get(t);
+                    const b = $stateB.get(t);
+                    return a + b;
+                });
+
+                const $multiplyAB = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const a = $stateA.get(t);
+                    const b = $stateB.get(t);
+                    return a * b;
+                });
+
+                const $addAndMultiply = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const add = $addAB.get(t);
+                    const multiply = $multiplyAB.get(t);
+                    return add * multiply;
+                });
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+                subscribe((t) => $addAndMultiply.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(6);
+
+                $stateA.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(16);
+
+                $stateB.set(Promise.resolve(3));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(30);
+            });
+
+            it("should handle nested states in derivation", async () => {
+                const obj1 = {
+                    cond: stateAsync(Promise.resolve(false)),
+                    num: stateAsync(Promise.resolve(2)),
+                    dispose: () => {
+                        obj1.cond.dispose();
+                        obj1.num.dispose();
+                    },
+                };
+                const obj2 = {
+                    cond: stateAsync(Promise.resolve(false)),
+                    num: stateAsync(Promise.resolve(4)),
+                    dispose: () => {
+                        obj2.cond.dispose();
+                        obj2.num.dispose();
+                    },
+                };
+                const $state = stateAsync(Promise.resolve(obj1));
+                const $derivationCond = derivationAsync(async (t) => $state.get(t).cond.get(t));
+                const $derivationNum = derivationAsync(async (t) => $state.get(t).num.get(t) * 2);
+                const onCond = vi.fn();
+                const onNum = vi.fn();
+
+                subscribe((t) => $derivationCond.get(t), onCond);
+                subscribe((t) => $derivationNum.get(t), onNum);
+
+                await vi.waitFor(() => expect(onCond).toHaveBeenCalledTimes(1));
+                expect(onCond).toHaveBeenLastCalledWith(false);
+                await vi.waitFor(() => expect(onNum).toHaveBeenCalledTimes(1));
+                expect(onNum).toHaveBeenLastCalledWith(4);
+
+                (await $state.pick()).num.set(Promise.resolve(3));
+                await vi.waitFor(() => expect(onCond).toHaveBeenCalledTimes(1));
+                expect(onCond).toHaveBeenLastCalledWith(false);
+                await vi.waitFor(() => expect(onNum).toHaveBeenCalledTimes(2));
+                expect(onNum).toHaveBeenLastCalledWith(6);
+
+                (await $state.pick()).cond.set(Promise.resolve(true));
+                await vi.waitFor(() => expect(onCond).toHaveBeenCalledTimes(2));
+                expect(onCond).toHaveBeenLastCalledWith(true);
+                await vi.waitFor(() => expect(onNum).toHaveBeenCalledTimes(2));
+                expect(onNum).toHaveBeenLastCalledWith(6);
+
+                $state.set(Promise.resolve(obj2));
+                await vi.waitFor(() => expect(onCond).toHaveBeenCalledTimes(3));
+                expect(onCond).toHaveBeenLastCalledWith(false);
+                await vi.waitFor(() => expect(onNum).toHaveBeenCalledTimes(3));
+                expect(onNum).toHaveBeenLastCalledWith(8);
+
+                (await $state.pick()).cond.set(Promise.resolve(true));
+                await vi.waitFor(() => expect(onCond).toHaveBeenCalledTimes(4));
+                expect(onCond).toHaveBeenLastCalledWith(true);
+                await vi.waitFor(() => expect(onNum).toHaveBeenCalledTimes(3));
+                expect(onNum).toHaveBeenLastCalledWith(8);
+
+                (await $state.pick()).num.set(Promise.resolve(5));
+                await vi.waitFor(() => expect(onCond).toHaveBeenCalledTimes(4));
+                expect(onCond).toHaveBeenLastCalledWith(true);
+                await vi.waitFor(() => expect(onNum).toHaveBeenCalledTimes(4));
+                expect(onNum).toHaveBeenLastCalledWith(10);
+            });
+        });
+
+        describe("with refresh", () => {
+            it("should force recomputation in effect", async () => {
+                let multiplier = 2;
+                const $state = stateAsync(Promise.resolve(5));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * multiplier);
+                const onData = vi.fn();
+                const onError = vi.fn();
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                multiplier = 3;
+                $derivation.refresh();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(15);
+            });
+
+            it("shouldn't trigger effects even if dependencies have not changed", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+                const onData = vi.fn();
+                const onError = vi.fn();
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                // Refresh forces recomputation even though state hasn't changed
+                $derivation.refresh();
+                await vi.waitFor(() => expect(computeFn).toHaveBeenCalledTimes(3));
+                // Effect should not be called again because value hasn't changed
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+                expect(onData).toHaveBeenLastCalledWith(2);
+            });
+
+            it("should re-execute effect when refresh forces recomputation", async () => {
+                let multiplier = 2;
+                const $state = stateAsync(Promise.resolve(5));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * multiplier);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                multiplier = 3;
+                $derivation.refresh();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(15);
+            });
+
+            it("should not re-execute effect if refresh returns same value", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenCalledTimes(1);
+
+                $derivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+                expect(computeFn).toHaveBeenCalledTimes(3);
+                expect(onData).toHaveBeenLastCalledWith(2);
+            });
+
+            it("should force recomputation even if dependencies have not changed", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const computeFn = vi.fn(async (t) => $state.get(t) * 2);
+                const $derivation = derivationAsync(computeFn);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $derivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(computeFn).toHaveBeenCalledTimes(3);
+            });
+        });
+
+        describe("error handling", () => {
+            it("should propagate errors in compute function with dependencies in effect", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const error = new Error("Effect compute error");
+                const $derivation = derivationAsync(async (t) => {
+                    await Promise.resolve();
+                    const value = $state.get(t);
+                    if (value > 1) {
+                        throw error;
+                    }
+                    return value;
+                });
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $state.set(Promise.resolve(2));
+                await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                expect(onError).toHaveBeenLastCalledWith(error);
+            });
+
+            it("should handle errors when dependency is disposed during computation", async () => {
+                const $state = stateAsync(Promise.resolve(1));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData, onError);
+
+                $state.dispose();
+
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(0);
+            });
+        });
+
+        describe("disposal", () => {
+            it("should not dispose effects when derivation is disposed", async () => {
+                const $state = stateAsync(Promise.resolve(1400));
+                const $derivation = derivationAsync(async (t) => $state.get(t) * 2);
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                const $effect = subscribe((t) => $derivation.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect($effect.disposed).toBe(false);
+
+                $derivation.dispose();
+
+                expect($effect.disposed).toBe(false);
+                expect($derivation.disposed).toBe(true);
+            });
+
+            it("should unregister effects when derivation is disposed", async () => {
+                const $state = stateAsync(Promise.resolve(1500));
+                const $derivation = derivationAsync(async (t) => (await $state.get(t)) * 2);
+                const onData1 = vi.fn();
+                const $effect = subscribe((t) => $derivation.get(t), onData1);
+
+                await vi.waitFor(() => expect(onData1).toHaveBeenCalledTimes(1));
+
+                $derivation.dispose();
+
+                // Effect should still be active but not notified
+                expect($effect.disposed).toBe(false);
+
+                // But derivation is disposed so operations should fail
+                const onError2 = vi.fn();
+                const onData2 = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData2, onError2);
+                await vi.waitFor(() => expect(onError2).toHaveBeenCalledTimes(1));
+            });
+        });
+    });
+});