@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/reactivity/nodes/sync/flowDerivation.test.ts

@@ -0,0 +1,896 @@
+import { describe, expect, it, vi } from "vitest";
+import type { FlowTracker } from "~";
+import { derivation, signal, state, subscribe } from "~";
+
+describe("flowDerivation", () => {
+    describe("unit", () => {
+        describe("initialization", () => {
+            it("should support self-derivation function without previous value", async () => {
+                const $state = state(1);
+                const compute = (t: FlowTracker) => {
+                    return 2 * $state.get(t);
+                };
+                const $derivation = derivation(compute);
+                const onData = vi.fn();
+                $derivation.subscribe(onData);
+
+                expect(await $derivation.pick()).toBe(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(2);
+                expect(await $derivation.pick()).toBe(4);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+            });
+
+            it("should support self-derivation function with previous value", async () => {
+                const $state = state(1);
+                const compute = (t: FlowTracker, previous?: number) => {
+                    const current = $state.get(t);
+                    return previous !== undefined ? previous + current : current;
+                };
+                const $derivation = derivation(compute);
+                const onData = vi.fn();
+                $derivation.subscribe(onData);
+
+                expect(await $derivation.pick()).toBe(1);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $state.set(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 = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+
+                expect(await $derivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(2);
+                expect(await $derivation.pick()).toBe(4);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should recompute when signal dependency is triggered", async () => {
+                const $signal = signal();
+                const $state = state(0);
+                const computeFn = vi.fn((t) => {
+                    $signal.watch(t);
+                    return $state.get(t);
+                });
+                const $derivation = derivation(computeFn);
+
+                expect(await $derivation.pick()).toBe(0);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(1);
+                $signal.trigger();
+                expect(await $derivation.pick()).toBe(1);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should recompute when another derivation dependency changes", async () => {
+                const $state = state(1);
+                const $derivation1 = derivation((t) => $state.get(t) * 2);
+                derivation((t) => $derivation1.get(t) * 2);
+                const computeFn = vi.fn((t) => $derivation1.get(t) * 2);
+                const $derivation2Spy = derivation(computeFn);
+
+                expect(await $derivation2Spy.pick()).toBe(4);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(2);
+                expect(await $derivation2Spy.pick()).toBe(8);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should mark as dirty when dependency changes", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(2);
+                // Should be dirty but not recomputed yet
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                // Next access triggers recomputation
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should recompute if value is identical after dependency change", async () => {
+                const $state = state(2);
+                const computeFn = vi.fn((t) => $state.get(t) * 0);
+                const $derivation = derivation(computeFn);
+                const onData = vi.fn();
+
+                $derivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(0);
+
+                $state.set(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);
+            });
+        });
+
+        describe("get", () => {
+            it("should recompute when dependency changes with tracking via subscribe", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+                const onData = vi.fn();
+
+                $derivation.subscribe((value) => {
+                    onData(value);
+                });
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should register dependencies automatically via tracker in subscribe", async () => {
+                const $state1 = state(1);
+                const $state2 = state(2);
+                const computeFn = vi.fn((t) => {
+                    return $state1.get(t) + $state2.get(t);
+                });
+                const $derivation = derivation(computeFn);
+                const onData = vi.fn();
+
+                $derivation.subscribe((value) => {
+                    onData(value);
+                });
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(3);
+
+                $state1.set(3);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(5);
+
+                $state2.set(4);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(7);
+            });
+
+            it("should propagate errors in compute function with dependencies", async () => {
+                const $state = state(1);
+                const error = new Error("Compute error");
+                const $derivation = derivation((t) => {
+                    const value = $state.get(t);
+                    if (value > 1) {
+                        throw error;
+                    }
+                    return value;
+                });
+
+                await $derivation.pick();
+
+                $state.set(2);
+                await expect($derivation.pick()).rejects.toThrow(error);
+            });
+        });
+
+        describe("watch", () => {
+            it("should register dependency when watch is called in effect context", async () => {
+                const $state = state(1);
+                const $derivation = derivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.watch(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+            });
+
+            it("should recompute when dependency changes after watch", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.watch(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe("pick", () => {
+            it("should recompute when dependency changes without tracking", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+
+                expect(await $derivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state.set(2);
+                expect(await $derivation.pick()).toBe(4);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe("refresh", () => {
+            it("should force recomputation even if not dirty", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $derivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should notify only if value changes after refresh", async () => {
+                let multiplier = 2;
+                const $state = state(5);
+                const $derivation = derivation((t) => $state.get(t) * multiplier);
+                const onData = vi.fn();
+
+                $derivation.subscribe(onData);
+                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 = state(5);
+                const $derivation = derivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                $derivation.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $derivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+            });
+
+            it("should force recomputation even if dependencies have not changed", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+
+                await $derivation.pick();
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $derivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe("dynamic dependencies", () => {
+            it("should handle dependencies that change between computations", async () => {
+                const $state1 = state(1);
+                const $state2 = state(10);
+                const $cond = state(true);
+                const computeFn = vi.fn((t) => {
+                    if ($cond.get(t)) {
+                        return $state1.get(t) * 2;
+                    }
+                    return $state2.get(t) * 2;
+                });
+                const $derivation = derivation(computeFn);
+
+                expect(await $derivation.pick()).toBe(2);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $state1.set(2);
+                expect(await $derivation.pick()).toBe(4);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+
+                $cond.set(false);
+                expect(await $derivation.pick()).toBe(20);
+                expect(computeFn).toHaveBeenCalledTimes(3);
+
+                $state2.set(20);
+                expect(await $derivation.pick()).toBe(40);
+                expect(computeFn).toHaveBeenCalledTimes(4);
+
+                $state1.set(100);
+                expect(await $derivation.pick()).toBe(40);
+                expect(computeFn).toHaveBeenCalledTimes(4);
+            });
+
+            it("should unregister dependencies that are no longer used", async () => {
+                const $state1 = state(1);
+                const $state2 = state(10);
+                const $cond = state(true);
+                const $derivation = derivation((t) => {
+                    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));
+
+                $cond.set(false);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+
+                $state1.set(100);
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+
+            it("should handle dependencies that appear and disappear", async () => {
+                const $state1 = state(1);
+                const $state2 = state(2);
+                const $useState1 = state(true);
+                const $derivation = derivation((t) => {
+                    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(false);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $useState1.set(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 = state(1);
+                const $derivation1 = derivation((t) => $state.get(t) * 2);
+                const $derivation2 = derivation((t) => $derivation1.get(t) * 2);
+
+                expect(await $derivation2.pick()).toBe(4);
+
+                $state.set(2);
+                expect(await $derivation2.pick()).toBe(8);
+            });
+
+            it("should handle chain of derivations", async () => {
+                const $state = state(1);
+                const $derivationA = derivation((t) => $state.get(t) * 2);
+                const $derivationB = derivation((t) => $derivationA.get(t) * 2);
+                const $derivationC = derivation((t) => $derivationB.get(t) * 2);
+
+                expect(await $derivationC.pick()).toBe(8);
+
+                $state.set(2);
+                expect(await $derivationC.pick()).toBe(16);
+            });
+
+            it("should recompute in cascade when dependency changes", async () => {
+                const $state = state(1);
+                const computeFnA = vi.fn((t) => $state.get(t) * 2);
+                const computeFnB = vi.fn((t) => {
+                    const $a = derivation(computeFnA);
+                    return $a.get(t) * 2;
+                });
+                derivation(computeFnA);
+                const $derivationB = derivation(computeFnB);
+
+                await $derivationB.pick();
+                expect(computeFnA).toHaveBeenCalled();
+                expect(computeFnB).toHaveBeenCalled();
+
+                $state.set(2);
+                await $derivationB.pick();
+                expect(computeFnA).toHaveBeenCalledTimes(2);
+                expect(computeFnB).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe("error handling", () => {
+            it("should propagate errors in compute function with dependencies", async () => {
+                const $state = state(1);
+                const error = new Error("Compute error");
+                const $derivation = derivation((t) => {
+                    const value = $state.get(t);
+                    if (value > 1) {
+                        throw error;
+                    }
+                    return value;
+                });
+
+                expect(await $derivation.pick()).toBe(1);
+
+                $state.set(2);
+                await expect($derivation.pick()).rejects.toThrow("Compute error");
+            });
+        });
+    });
+
+    describe("with effect", () => {
+        describe("reactive dependencies", () => {
+            it("should re-execute effect when derivation dependency changes", async () => {
+                const $state = state(1);
+                const $derivation = derivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+            });
+
+            it("should  re-execute effect if derivation value is identical", async () => {
+                const $state = state(2);
+                const $derivation = derivation((t) => $state.get(t) * 0);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(5);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+            });
+
+            it("should work with derivation depending on state", async () => {
+                const $state = state(1);
+                const $derivation = derivation((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(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 = state(0);
+                const $derivation = derivation((t) => {
+                    $signal.watch(t);
+                    return $state.get(t);
+                });
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(0);
+
+                $state.set(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 = state(1);
+                const $derivation1 = derivation((t) => $state.get(t) * 2);
+                const $derivation2 = derivation((t) => $derivation1.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation2.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $state.set(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 = state(5);
+                const $stateB = state(10);
+                const $derivation = derivation((t) => $stateA.get(t) + $stateB.get(t));
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(15);
+
+                $stateA.set(6);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(16);
+
+                $stateB.set(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 = derivation((t) => {
+                    $signal1.watch(t);
+                    $signal2.watch(t);
+                    return 42;
+                });
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.watch(t), onData);
+
+                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 = state(1);
+                const $derivation = derivation((t) => {
+                    $signal.watch(t);
+                    return $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);
+
+                $signal.trigger();
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(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 = state(1);
+                const $derivation1 = derivation((t) => $state.get(t) * 2);
+                const $derivation2 = derivation((t) => $state.get(t) + $derivation1.get(t));
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation2.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(3);
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(6);
+            });
+        });
+
+        describe("nested derivations", () => {
+            it("should work with chained derivations", async () => {
+                const $state = state(1);
+                const $derivation1 = derivation((t) => $state.get(t) * 2);
+                const $derivation2 = derivation((t) => $derivation1.get(t) * 2);
+                const $derivation3 = derivation((t) => $derivation2.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation3.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(8);
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(16);
+            });
+
+            it("should re-execute effect when distant dependency changes", async () => {
+                const $state = state(1);
+                const $derivation1 = derivation((t) => $state.get(t) * 2);
+                const $derivation2 = derivation((t) => $derivation1.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation2.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(8);
+            });
+
+            it("should propagate changes correctly through the chain", async () => {
+                const $state = state(1);
+                const $derivation1 = derivation((t) => $state.get(t) * 2);
+                const $derivation2 = derivation((t) => $derivation1.get(t) * 2);
+                const onData1 = vi.fn();
+                const onData2 = vi.fn();
+
+                subscribe((t) => $derivation1.get(t), onData1);
+                subscribe((t) => $derivation2.get(t), onData2);
+
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(1);
+                });
+
+                $state.set(2);
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(2);
+                    expect(onData2).toHaveBeenCalledTimes(2);
+                });
+            });
+        });
+
+        describe("dynamic dependencies", () => {
+            it("should work with derivation with conditional dependencies", async () => {
+                const $state1 = state(1);
+                const $state2 = state(10);
+                const $cond = state(true);
+                const $derivation = derivation((t) => {
+                    if ($cond.get(t)) {
+                        return $state1.get(t) * 2;
+                    }
+                    return $state2.get(t) * 2;
+                });
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state1.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(4);
+
+                $cond.set(false);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(20);
+
+                $state2.set(20);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                expect(onData).toHaveBeenLastCalledWith(40);
+            });
+
+            it("should re-execute effect when dependencies change dynamically", async () => {
+                const $state1 = state(1);
+                const $state2 = state(2);
+                const $useState1 = state(true);
+                const $derivation = derivation((t) => {
+                    if ($useState1.get(t)) {
+                        return $state1.get(t);
+                    }
+                    return $state2.get(t);
+                });
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $useState1.set(false);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state1.set(10);
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+
+                $state2.set(20);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(20);
+            });
+
+            it("should unregister old dependencies correctly", async () => {
+                const $state1 = state(1);
+                const $state2 = state(10);
+                const $cond = state(true);
+                const $derivation = derivation((t) => {
+                    if ($cond.get(t)) {
+                        return $state1.get(t);
+                    }
+                    return $state2.get(t);
+                });
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $cond.set(false);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+
+                $state1.set(100);
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe("complex patterns", () => {
+            it("should handle diamond pattern", async () => {
+                const $stateA = state(1);
+                const $aMult3 = derivation((t) => $stateA.get(t) * 3);
+                const $aMult2 = derivation((t) => $stateA.get(t) * 2);
+                const $addAmult3Amult2 = derivation((t) => $aMult3.get(t) + $aMult2.get(t));
+                const onData = vi.fn();
+
+                subscribe((t) => $addAmult3Amult2.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(5);
+
+                $stateA.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(10);
+
+                $stateA.set(3);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(15);
+            });
+
+            it("should handle multi-diamond pattern", async () => {
+                const $stateA = state(1);
+                const $stateB = state(2);
+                const $addAB = derivation((t) => {
+                    const a = $stateA.get(t);
+                    const b = $stateB.get(t);
+                    return a + b;
+                });
+                const $multiplyAB = derivation((t) => {
+                    const a = $stateA.get(t);
+                    const b = $stateB.get(t);
+                    return a * b;
+                });
+                const $addAndMultiply = derivation((t) => {
+                    const add = $addAB.get(t);
+                    const multiply = $multiplyAB.get(t);
+                    return add * multiply;
+                });
+                const onData = vi.fn();
+
+                subscribe((t) => $addAndMultiply.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(6);
+
+                $stateA.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(16);
+
+                $stateB.set(3);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(30);
+            });
+        });
+
+        describe("with refresh", () => {
+            it("should re-execute effect when refresh forces recomputation", async () => {
+                let multiplier = 2;
+                const $state = state(5);
+                const $derivation = derivation((t) => $state.get(t) * multiplier);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                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 = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $derivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+
+            it("should force recomputation even if dependencies have not changed", async () => {
+                const $state = state(1);
+                const computeFn = vi.fn((t) => $state.get(t) * 2);
+                const $derivation = derivation(computeFn);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(computeFn).toHaveBeenCalledTimes(1);
+
+                $derivation.refresh();
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(computeFn).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe("error handling", () => {
+            it("should propagate errors in compute function with dependencies in effect", async () => {
+                const $state = state(1);
+                const error = new Error("Effect compute error");
+                const $derivation = derivation((t) => {
+                    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));
+
+                $state.set(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 = state(1);
+                const $derivation = derivation((t) => $state.get(t) * 2);
+                const onData = vi.fn();
+
+                subscribe((t) => $derivation.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.dispose();
+
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+            });
+        });
+    });
+});