@ersbeth/picoflow 2.0.2 → 2.0.3

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

@@ -1,898 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { FlowTracker } from "~";
-import { derivation, signal, stateAsync, subscribe } from "~";
-
-describe("flowDerivation", () => {
-    describe("unit", () => {
-        describe("initialization", () => {
-            it("should support self-derivation function without previous value", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const compute = (t: FlowTracker) => {
-                    return 2 * $stateAsync.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);
-
-                $stateAsync.set(Promise.resolve(2));
-                expect(await $derivation.pick()).toBe(4);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                expect(onData).toHaveBeenLastCalledWith(4);
-            });
-
-            it("should support self-derivation function with previous value", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const compute = (t: FlowTracker, previous?: number) => {
-                    const current = $stateAsync.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);
-
-                $stateAsync.set(Promise.resolve(2));
-                expect(await $derivation.pick()).toBe(3);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                expect(onData).toHaveBeenLastCalledWith(3);
-            });
-        });
-
-        describe("reactive dependencies", () => {
-            it("should recompute when state dependency changes", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.get(t) * 2);
-                const $derivation = derivation(computeFn);
-
-                expect(await $derivation.pick()).toBe(2);
-                expect(computeFn).toHaveBeenCalledTimes(2);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(0));
-                const computeFn = vi.fn((t) => {
-                    $signal.watch(t);
-                    return $stateAsync.get(t);
-                });
-                const $derivation = derivation(computeFn);
-
-                expect(await $derivation.pick()).toBe(0);
-                expect(computeFn).toHaveBeenCalledTimes(2);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation1 = derivation((t) => $stateAsync.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(2);
-
-                $stateAsync.set(Promise.resolve(2));
-                expect(await $derivation2Spy.pick()).toBe(8);
-                expect(computeFn).toHaveBeenCalledTimes(4);
-            });
-
-            it("should mark as dirty when dependency changes", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.get(t) * 2);
-                const $derivation = derivation(computeFn);
-
-                await $derivation.pick();
-                expect(computeFn).toHaveBeenCalledTimes(2);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(2));
-                const computeFn = vi.fn((t) => $stateAsync.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);
-
-                $stateAsync.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);
-            });
-        });
-
-        describe("get", () => {
-            it("should recompute when dependency changes with tracking via subscribe", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.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(2);
-
-                $stateAsync.set(Promise.resolve(2));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(4);
-                expect(computeFn).toHaveBeenCalledTimes(3);
-            });
-
-            it("should register dependencies automatically via tracker in subscribe", async () => {
-                const $state1Async = stateAsync(Promise.resolve(1));
-                const $state2Async = stateAsync(Promise.resolve(2));
-                const computeFn = vi.fn((t) => {
-                    return $state1Async.get(t) + $state2Async.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);
-
-                $state1Async.set(Promise.resolve(3));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(5);
-
-                $state2Async.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const error = new Error("Compute error");
-                const $derivation = derivation((t) => {
-                    const value = $stateAsync.get(t);
-                    if (value > 1) {
-                        throw error;
-                    }
-                    return value;
-                });
-
-                await $derivation.pick();
-
-                $stateAsync.set(Promise.resolve(2));
-                await expect($derivation.pick()).rejects.toThrow(error);
-            });
-        });
-
-        describe("watch", () => {
-            it("should register dependency when watch is called in effect context", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation = derivation((t) => $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.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(2);
-
-                $stateAsync.set(Promise.resolve(2));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(computeFn).toHaveBeenCalledTimes(3);
-            });
-        });
-
-        describe("pick", () => {
-            it("should recompute when dependency changes without tracking", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.get(t) * 2);
-                const $derivation = derivation(computeFn);
-
-                expect(await $derivation.pick()).toBe(2);
-                expect(computeFn).toHaveBeenCalledTimes(2);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.get(t) * 2);
-                const $derivation = derivation(computeFn);
-
-                await $derivation.pick();
-                expect(computeFn).toHaveBeenCalledTimes(2);
-
-                $derivation.refresh();
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                expect(computeFn).toHaveBeenCalledTimes(3);
-            });
-
-            it("should notify only if value changes after refresh", async () => {
-                let multiplier = 2;
-                const $stateAsync = stateAsync(Promise.resolve(5));
-                const $derivation = derivation((t) => $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(5));
-                const $derivation = derivation((t) => $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.get(t) * 2);
-                const $derivation = derivation(computeFn);
-
-                await $derivation.pick();
-                expect(computeFn).toHaveBeenCalledTimes(2);
-
-                $derivation.refresh();
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                expect(computeFn).toHaveBeenCalledTimes(3);
-            });
-        });
-
-        describe("dynamic dependencies", () => {
-            it("should handle dependencies that change between computations", async () => {
-                const $state1Async = stateAsync(Promise.resolve(1));
-                const $state2Async = stateAsync(Promise.resolve(10));
-                const $condAsync = stateAsync(Promise.resolve(true));
-                const computeFn = vi.fn((t) => {
-                    if ($condAsync.get(t)) {
-                        return $state1Async.get(t) * 2;
-                    }
-                    return $state2Async.get(t) * 2;
-                });
-                const $derivation = derivation(computeFn);
-
-                expect(await $derivation.pick()).toBe(2);
-                expect(computeFn).toHaveBeenCalledTimes(3);
-
-                $state1Async.set(Promise.resolve(2));
-                expect(await $derivation.pick()).toBe(4);
-                expect(computeFn).toHaveBeenCalledTimes(5);
-
-                $condAsync.set(Promise.resolve(false));
-                expect(await $derivation.pick()).toBe(20);
-                expect(computeFn).toHaveBeenCalledTimes(8);
-
-                $state2Async.set(Promise.resolve(20));
-                expect(await $derivation.pick()).toBe(40);
-                expect(computeFn).toHaveBeenCalledTimes(10);
-
-                $state1Async.set(Promise.resolve(100));
-                expect(await $derivation.pick()).toBe(40);
-                expect(computeFn).toHaveBeenCalledTimes(10);
-            });
-
-            it("should unregister dependencies that are no longer used", async () => {
-                const $state1Async = stateAsync(Promise.resolve(1));
-                const $state2Async = stateAsync(Promise.resolve(10));
-                const $condAsync = stateAsync(Promise.resolve(true));
-                const $derivation = derivation((t) => {
-                    if ($condAsync.get(t)) {
-                        return $state1Async.get(t);
-                    }
-                    return $state2Async.get(t);
-                });
-                const onData = vi.fn();
-
-                $derivation.subscribe(onData);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $condAsync.set(Promise.resolve(false));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-
-                $state1Async.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 $state1Async = stateAsync(Promise.resolve(1));
-                const $state2Async = stateAsync(Promise.resolve(2));
-                const $useState1Async = stateAsync(Promise.resolve(true));
-                const $derivation = derivation((t) => {
-                    if ($useState1Async.get(t)) {
-                        return $state1Async.get(t);
-                    }
-                    return $state2Async.get(t);
-                });
-                const onData = vi.fn();
-
-                $derivation.subscribe(onData);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(1);
-
-                $useState1Async.set(Promise.resolve(false));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(2);
-
-                $useState1Async.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation1 = derivation((t) => $stateAsync.get(t) * 2);
-                const $derivation2 = derivation((t) => $derivation1.get(t) * 2);
-
-                expect(await $derivation2.pick()).toBe(4);
-
-                $stateAsync.set(Promise.resolve(2));
-                expect(await $derivation2.pick()).toBe(8);
-            });
-
-            it("should handle chain of derivations", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivationA = derivation((t) => $stateAsync.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);
-
-                $stateAsync.set(Promise.resolve(2));
-                expect(await $derivationC.pick()).toBe(16);
-            });
-
-            it("should recompute in cascade when dependency changes", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFnA = vi.fn((t) => $stateAsync.get(t) * 2);
-                const computeFnB = vi.fn((t) => {
-                    const $a = derivation(computeFnA);
-                    return $a.get(t) * 2;
-                });
-                derivation(computeFnA);
-                const $derivationB = derivation(computeFnB);
-
-                const result1 = await $derivationB.pick();
-                expect(result1).toBe(4);
-                expect(computeFnA).toHaveBeenCalled();
-                expect(computeFnB).toHaveBeenCalled();
-
-                $stateAsync.set(Promise.resolve(2));
-                const result2 = await $derivationB.pick();
-                expect(result2).toBe(8);
-                expect(computeFnA).toHaveBeenCalledTimes(6);
-                expect(computeFnB).toHaveBeenCalledTimes(4);
-            });
-        });
-
-        describe("error handling", () => {
-            it("should propagate errors in compute function with dependencies", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const error = new Error("Compute error");
-                const $derivation = derivation((t) => {
-                    const value = $stateAsync.get(t);
-                    if (value > 1) {
-                        throw error;
-                    }
-                    return value;
-                });
-
-                expect(await $derivation.pick()).toBe(1);
-
-                $stateAsync.set(Promise.resolve(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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation = derivation((t) => $stateAsync.get(t) * 2);
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $stateAsync.set(Promise.resolve(2));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-            });
-
-            it("should  re-execute effect if derivation value is identical", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(2));
-                const $derivation = derivation((t) => $stateAsync.get(t) * 0);
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $stateAsync.set(Promise.resolve(5));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-            });
-
-            it("should work with derivation depending on state", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation = derivation((t) => $stateAsync.get(t) * 2);
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(2);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(0));
-                const $derivation = derivation((t) => {
-                    $signal.watch(t);
-                    return $stateAsync.get(t);
-                });
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(0);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation1 = derivation((t) => $stateAsync.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);
-
-                $stateAsync.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 $stateAAsync = stateAsync(Promise.resolve(5));
-                const $stateBAsync = stateAsync(Promise.resolve(10));
-                const $derivation = derivation((t) => $stateAAsync.get(t) + $stateBAsync.get(t));
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(15);
-
-                $stateAAsync.set(Promise.resolve(6));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(16);
-
-                $stateBAsync.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 = 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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation = derivation((t) => {
-                    $signal.watch(t);
-                    return $stateAsync.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);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation1 = derivation((t) => $stateAsync.get(t) * 2);
-                const $derivation2 = derivation((t) => $stateAsync.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);
-
-                $stateAsync.set(Promise.resolve(2));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(6);
-            });
-        });
-
-        describe("nested derivations", () => {
-            it("should work with chained derivations", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation1 = derivation((t) => $stateAsync.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);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation1 = derivation((t) => $stateAsync.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);
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation1 = derivation((t) => $stateAsync.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);
-                });
-
-                $stateAsync.set(Promise.resolve(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 $state1Async = stateAsync(Promise.resolve(1));
-                const $state2Async = stateAsync(Promise.resolve(10));
-                const $condAsync = stateAsync(Promise.resolve(true));
-                const $derivation = derivation((t) => {
-                    if ($condAsync.get(t)) {
-                        return $state1Async.get(t) * 2;
-                    }
-                    return $state2Async.get(t) * 2;
-                });
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(2);
-
-                $state1Async.set(Promise.resolve(2));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(4);
-
-                $condAsync.set(Promise.resolve(false));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                expect(onData).toHaveBeenLastCalledWith(20);
-
-                $state2Async.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 $state1Async = stateAsync(Promise.resolve(1));
-                const $state2Async = stateAsync(Promise.resolve(2));
-                const $useState1Async = stateAsync(Promise.resolve(true));
-                const $derivation = derivation((t) => {
-                    if ($useState1Async.get(t)) {
-                        return $state1Async.get(t);
-                    }
-                    return $state2Async.get(t);
-                });
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(1);
-
-                $useState1Async.set(Promise.resolve(false));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(2);
-
-                $state1Async.set(Promise.resolve(10));
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                expect(onData).toHaveBeenCalledTimes(2);
-
-                $state2Async.set(Promise.resolve(20));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                expect(onData).toHaveBeenLastCalledWith(20);
-            });
-
-            it("should unregister old dependencies correctly", async () => {
-                const $state1Async = stateAsync(Promise.resolve(1));
-                const $state2Async = stateAsync(Promise.resolve(10));
-                const $condAsync = stateAsync(Promise.resolve(true));
-                const $derivation = derivation((t) => {
-                    if ($condAsync.get(t)) {
-                        return $state1Async.get(t);
-                    }
-                    return $state2Async.get(t);
-                });
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $condAsync.set(Promise.resolve(false));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-
-                $state1Async.set(Promise.resolve(100));
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                expect(onData).toHaveBeenCalledTimes(2);
-            });
-        });
-
-        describe("complex patterns", () => {
-            it("should handle diamond pattern", async () => {
-                const $stateAAsync = stateAsync(Promise.resolve(1));
-                const $aMult3 = derivation((t) => $stateAAsync.get(t) * 3);
-                const $aMult2 = derivation((t) => $stateAAsync.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);
-
-                $stateAAsync.set(Promise.resolve(2));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(10);
-
-                $stateAAsync.set(Promise.resolve(3));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                expect(onData).toHaveBeenLastCalledWith(15);
-            });
-
-            it("should handle multi-diamond pattern", async () => {
-                const $stateAAsync = stateAsync(Promise.resolve(1));
-                const $stateBAsync = stateAsync(Promise.resolve(2));
-                const $addAB = derivation((t) => {
-                    const a = $stateAAsync.get(t);
-                    const b = $stateBAsync.get(t);
-                    return a + b;
-                });
-                const $multiplyAB = derivation((t) => {
-                    const a = $stateAAsync.get(t);
-                    const b = $stateBAsync.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);
-
-                $stateAAsync.set(Promise.resolve(2));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(16);
-
-                $stateBAsync.set(Promise.resolve(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 $stateAsync = stateAsync(Promise.resolve(5));
-                const $derivation = derivation((t) => $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.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(2);
-
-                $derivation.refresh();
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                expect(onData).toHaveBeenCalledTimes(1);
-                expect(computeFn).toHaveBeenCalledTimes(3);
-            });
-
-            it("should force recomputation even if dependencies have not changed", async () => {
-                const $stateAsync = stateAsync(Promise.resolve(1));
-                const computeFn = vi.fn((t) => $stateAsync.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(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 $stateAsync = stateAsync(Promise.resolve(1));
-                const error = new Error("Effect compute error");
-                const $derivation = derivation((t) => {
-                    const value = $stateAsync.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));
-
-                $stateAsync.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 $stateAsync = stateAsync(Promise.resolve(1));
-                const $derivation = derivation((t) => $stateAsync.get(t) * 2);
-                const onData = vi.fn();
-
-                subscribe((t) => $derivation.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $stateAsync.dispose();
-
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                expect(onData).toHaveBeenCalledTimes(1);
-            });
-        });
-    });
-});