@ersbeth/picoflow 2.0.2 → 2.0.3

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

@@ -1,1716 +0,0 @@
-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));
-            });
-        });
-    });
-});