@ersbeth/picoflow 1.1.1 → 2.0.0

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

@@ -1,1517 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { derivationAsync, effect, signal, stateAsync } from "#package";
-
-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 computeFn = vi.fn(() => 100);
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(async (t) => {
-					computeFn();
-					return (await $state.get(t)) * 2;
-				});
-
-				expect(computeFn).not.toHaveBeenCalled();
-				await $derivation.pick();
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should call compute function again when dependency changes", async () => {
-				const computeFn = vi.fn(async (t) => {
-					const $s = stateAsync(Promise.resolve(1));
-					return (await $s.get(t)) * 2;
-				});
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(async (t) => {
-					await computeFn(t);
-					return (await $state.get(t)) * 2;
-				});
-
-				await $derivation.pick();
-				expect(computeFn).toHaveBeenCalledTimes(1);
-
-				$state.set(Promise.resolve(2));
-				await $derivation.pick();
-				expect(computeFn).toHaveBeenCalledTimes(2);
-			});
-
-			it("should handle number return values", async () => {
-				const $state = stateAsync(Promise.resolve(5));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				expect(await $derivation.pick()).toBe(10);
-			});
-
-			it("should handle string return values", async () => {
-				const $state = stateAsync(Promise.resolve("hello"));
-				const $derivation = derivationAsync(async (t) =>
-					(await $state.get(t)).toUpperCase(),
-				);
-				expect(await $derivation.pick()).toBe("HELLO");
-			});
-
-			it("should handle object return values", async () => {
-				const $state = stateAsync(Promise.resolve({ a: 1 }));
-				const $derivation = derivationAsync(async (t) => ({
-					...(await $state.get(t)),
-					b: 2,
-				}));
-				const value = await $derivation.pick();
-				expect(value).toEqual({ a: 1, b: 2 });
-			});
-
-			it("should handle array return values", async () => {
-				const $state = stateAsync(Promise.resolve([1, 2]));
-				const $derivation = derivationAsync(async (t) => [
-					...(await $state.get(t)),
-					3,
-				]);
-				const value = await $derivation.pick();
-				expect(value).toEqual([1, 2, 3]);
-			});
-
-			it("should handle null return values", async () => {
-				const $state = stateAsync(Promise.resolve(true));
-				const $derivation = derivationAsync(async (t) =>
-					(await $state.get(t)) ? null : "not null",
-				);
-				expect(await $derivation.pick()).toBeNull();
-			});
-
-			it("should handle undefined return values", async () => {
-				const $state = stateAsync(Promise.resolve(true));
-				const $derivation = derivationAsync(async (t) =>
-					(await $state.get(t)) ? undefined : "defined",
-				);
-				expect(await $derivation.pick()).toBeUndefined();
-			});
-		});
-
-		describe("get", () => {
-			it("should return computed value with tracking context", async () => {
-				const $state = stateAsync(Promise.resolve(5));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const $tracker = stateAsync(Promise.resolve(0));
-				const value = await $derivation.get($tracker);
-				expect(value).toBe(10);
-			});
-
-			it("should compute lazy value on first get call", async () => {
-				const computeFn = vi.fn(async (t) => {
-					const $s = stateAsync(Promise.resolve(10));
-					return (await $s.get(t)) * 2;
-				});
-				const $state = stateAsync(Promise.resolve(10));
-				const $derivation = derivationAsync(async (t) => {
-					await computeFn(t);
-					return (await $state.get(t)) * 2;
-				});
-				const $tracker = stateAsync(Promise.resolve(0));
-
-				expect(computeFn).not.toHaveBeenCalled();
-				const value = await $derivation.get($tracker);
-				expect(value).toBe(20);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should recompute when dependency changes", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const $tracker = stateAsync(Promise.resolve(0));
-
-				expect(await $derivation.get($tracker)).toBe(2);
-
-				await $state.set(Promise.resolve(2));
-				expect(await $derivation.get($tracker)).toBe(4);
-			});
-		});
-
-		describe("pick", () => {
-			it("should return computed value without tracking", async () => {
-				const $state = stateAsync(Promise.resolve(15));
-				const $derivation = derivationAsync(
-					async (t) => (await $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) => {
-					const $s = stateAsync(Promise.resolve(25));
-					return (await $s.get(t)) * 2;
-				});
-				const $state = stateAsync(Promise.resolve(25));
-				const $derivation = derivationAsync(async (t) => {
-					await computeFn(t);
-					return (await $state.get(t)) * 2;
-				});
-
-				expect(computeFn).not.toHaveBeenCalled();
-				const value = await $derivation.pick();
-				expect(value).toBe(50);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should recompute when dependency changes", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-
-				expect(await $derivation.pick()).toBe(2);
-
-				$state.set(Promise.resolve(2));
-				expect(await $derivation.pick()).toBe(4);
-			});
-		});
-
-		describe("refresh", () => {
-			it("should force recomputation", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const computeFn = vi.fn(async (t) => (await $state.get(t)) * 2);
-				const $derivation = derivationAsync(computeFn);
-
-				await $derivation.pick();
-				expect(computeFn).toHaveBeenCalledTimes(1);
-
-				await $derivation.refresh();
-				expect(computeFn).toHaveBeenCalledTimes(2);
-			});
-
-			it("should return a Promise", () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const result = $derivation.refresh();
-				expect(result).toBeInstanceOf(Promise);
-			});
-
-			it("should not notify when refresh returns same value", async () => {
-				const $state = stateAsync(Promise.resolve(5));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener = vi.fn();
-				$derivation.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				// Value is 10, refresh will compute same value
-				await $derivation.refresh();
-
-				// Wait to ensure no additional calls
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-
-			it("should notify when refresh returns different value", async () => {
-				let multiplier = 2;
-				const $state = stateAsync(Promise.resolve(5));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * multiplier,
-				);
-				const listener = vi.fn();
-				$derivation.subscribe(async (promise) => listener(await promise));
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(listener).toHaveBeenLastCalledWith(10);
-
-				multiplier = 3;
-				await $derivation.refresh();
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
-			});
-
-			it("should recompute even if not dirty", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const computeFn = vi.fn(async (t) => (await $state.get(t)) * 2);
-				const $derivation = derivationAsync(computeFn);
-
-				await $derivation.pick();
-				expect(computeFn).toHaveBeenCalledTimes(1);
-
-				// Not dirty, but refresh forces recomputation
-				await $derivation.refresh();
-				expect(computeFn).toHaveBeenCalledTimes(2);
-			});
-		});
-
-		describe("watch", () => {
-			it("should register dependency when watch is called", async () => {
-				const $state = stateAsync(Promise.resolve(35));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const $tracker = stateAsync(Promise.resolve(0));
-
-				expect(() => $derivation.watch($tracker)).not.toThrow();
-			});
-
-			it("should compute lazy value when watch is called", async () => {
-				const computeFn = vi.fn(async (t) => {
-					const $s = stateAsync(Promise.resolve(40));
-					return (await $s.get(t)) * 2;
-				});
-				const $state = stateAsync(Promise.resolve(40));
-				const $derivation = derivationAsync(async (t) => {
-					await computeFn(t);
-					return (await $state.get(t)) * 2;
-				});
-				const $tracker = stateAsync(Promise.resolve(0));
-
-				expect(computeFn).not.toHaveBeenCalled();
-				$derivation.watch($tracker);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-		});
-
-		describe("subscribe", () => {
-			it("should return a disposer function", () => {
-				const $state = stateAsync(Promise.resolve(50));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener = vi.fn();
-				const disposer = $derivation.subscribe(listener);
-
-				expect(typeof disposer).toBe("function");
-			});
-
-			it("should call listener immediately with computed value", async () => {
-				const $state = stateAsync(Promise.resolve(55));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener = vi.fn();
-
-				$derivation.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(await listener.mock.calls[0][0]).toBe(110);
-			});
-
-			it("should call listener when value changes", async () => {
-				const $state = stateAsync(Promise.resolve(60));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener = vi.fn();
-
-				$derivation.subscribe(async (promise) => listener(await promise));
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				$state.set(Promise.resolve(70));
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
-				expect(await listener.mock.calls[1][0]).toBe(140);
-			});
-
-			it("should not call listener when value does not change", async () => {
-				const $state = stateAsync(Promise.resolve(75));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener = vi.fn();
-
-				$derivation.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				$state.set(Promise.resolve(75));
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-
-			it("should support multiple subscriptions", async () => {
-				const $state = stateAsync(Promise.resolve(80));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener1 = vi.fn();
-				const listener2 = vi.fn();
-				const listener3 = vi.fn();
-
-				$derivation.subscribe(listener1);
-				$derivation.subscribe(listener2);
-				$derivation.subscribe(listener3);
-
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(1);
-					expect(listener2).toHaveBeenCalledTimes(1);
-					expect(listener3).toHaveBeenCalledTimes(1);
-				});
-
-				expect(await listener1.mock.calls[0][0]).toBe(160);
-				expect(await listener2.mock.calls[0][0]).toBe(160);
-				expect(await listener3.mock.calls[0][0]).toBe(160);
-			});
-
-			it("should dispose effect when disposer is called", async () => {
-				const $state = stateAsync(Promise.resolve(85));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener = vi.fn();
-
-				const unsubscribe = $derivation.subscribe(async (promise) =>
-					listener(await promise),
-				);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				$state.set(Promise.resolve(90));
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
-
-				unsubscribe();
-
-				$state.set(Promise.resolve(95));
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(2);
-			});
-		});
-
-		describe("trigger", () => {
-			it("should return a Promise", () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const result = $derivation.trigger();
-				expect(result).toBeInstanceOf(Promise);
-			});
-
-			it("should allow multiple triggers", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const promise1 = $derivation.trigger();
-				const promise2 = $derivation.trigger();
-				const promise3 = $derivation.trigger();
-
-				expect(promise1).toBeInstanceOf(Promise);
-				expect(promise2).toBeInstanceOf(Promise);
-				expect(promise3).toBeInstanceOf(Promise);
-
-				await Promise.all([promise1, promise2, promise3]);
-			});
-		});
-
-		describe("disposal", () => {
-			it("should have disposed property set to false initially", () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $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({ self: true })).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 dynamic dependencies - dependencies 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) => {
-					if (await $cond.get(t)) {
-						return await $state1.get(t);
-					}
-					return await $state2.get(t);
-				});
-
-				await $derivation.pick();
-				// Initially depends on state1
-
-				$cond.set(Promise.resolve(false));
-				await $derivation.pick();
-				// Now depends on state2, state1 should be unregistered
-			});
-
-			it("should mark as dirty when dependency changes", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const computeFn = vi.fn(async (t) => (await $state.get(t)) * 2);
-				const $derivation = derivationAsync(computeFn);
-
-				await $derivation.pick();
-				expect(computeFn).toHaveBeenCalledTimes(1);
-
-				// Change dependency - marks as dirty but doesn't recompute yet
-				$state.set(Promise.resolve(2));
-
-				// Next access triggers recomputation
-				await $derivation.pick();
-				expect(computeFn).toHaveBeenCalledTimes(2);
-			});
-
-			it("should recompute only on next access when dirty", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const computeFn = vi.fn(async (t) => (await $state.get(t)) * 2);
-				const $derivation = derivationAsync(computeFn);
-
-				await $derivation.pick();
-				expect(computeFn).toHaveBeenCalledTimes(1);
-
-				// 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(2);
-			});
-
-			it("should handle nested derivations", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation1 = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const $derivation2 = derivationAsync(
-					async (t) => (await $derivation1.get(t)) * 2,
-				);
-
-				expect(await $derivation2.pick()).toBe(4);
-
-				$state.set(Promise.resolve(2));
-				expect(await $derivation2.pick()).toBe(8);
-			});
-
-			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("error handling", () => {
-			describe("compute function errors", () => {
-				it("should propagate error when pick is called with throwing compute", async () => {
-					const error = new Error("Compute pick error");
-					const $derivation = derivationAsync(async () => {
-						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) => {
-						if (throwNow) {
-							throw new Error("Compute pick error");
-						}
-						throwNow = true;
-						return await $state.get(t);
-					});
-
-					expect(await $derivation.pick()).toBe(1);
-
-					$state.set(Promise.resolve(2));
-					await expect($derivation.pick()).rejects.toThrow(
-						"Compute pick error",
-					);
-				});
-
-				it("should propagate error when get is called with throwing compute", async () => {
-					const error = new Error("Compute get error");
-					const $derivation = derivationAsync(async () => {
-						throw error;
-					});
-
-					const $tracker = stateAsync(Promise.resolve(0));
-					await expect($derivation.get($tracker)).rejects.toThrow(
-						"Compute get error",
-					);
-				});
-
-				it("should propagate error when get throws on subsequent compute", async () => {
-					let throwNow = false;
-					const $state = stateAsync(Promise.resolve(1));
-					const $derivation = derivationAsync(async (t) => {
-						if (throwNow) {
-							throw new Error("Compute get error");
-						}
-						throwNow = true;
-						return await $state.get(t);
-					});
-					const $tracker = stateAsync(Promise.resolve(0));
-
-					expect(await $derivation.get($tracker)).toBe(1);
-					await $state.set(Promise.resolve(2));
-					await expect($derivation.get($tracker)).rejects.toThrow(
-						"Compute get error",
-					);
-				});
-			});
-
-			describe("disposed derivation", () => {
-				it("should throw error when pick is called after disposal", async () => {
-					const $derivation = derivationAsync(
-						async (t) => (await stateAsync(Promise.resolve(1)).get(t)) * 2,
-					);
-
-					await $derivation.pick();
-					$derivation.dispose();
-
-					await expect($derivation.pick()).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when get is called after disposal", async () => {
-					const $derivation = derivationAsync(
-						async (t) => (await stateAsync(Promise.resolve(1)).get(t)) * 2,
-					);
-					const $tracker = stateAsync(Promise.resolve(0));
-
-					await $derivation.get($tracker);
-					$derivation.dispose();
-
-					await expect($derivation.get($tracker)).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when refresh is called after disposal", async () => {
-					const $derivation = derivationAsync(
-						async (t) => (await stateAsync(Promise.resolve(1)).get(t)) * 2,
-					);
-
-					$derivation.dispose();
-
-					await expect($derivation.refresh()).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when watch is called after disposal", async () => {
-					const $derivation = derivationAsync(
-						async (t) => (await stateAsync(Promise.resolve(1)).get(t)) * 2,
-					);
-					const $tracker = stateAsync(Promise.resolve(0));
-
-					await $derivation.watch($tracker);
-					$derivation.dispose();
-
-					await expect($derivation.watch($tracker)).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when subscribe is called after disposal", () => {
-					const $derivation = derivationAsync(
-						async (t) => (await stateAsync(Promise.resolve(1)).get(t)) * 2,
-					);
-					const listener = vi.fn();
-
-					$derivation.dispose();
-
-					expect(() => $derivation.subscribe(listener)).toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when trigger is called after disposal", async () => {
-					const $derivation = derivationAsync(
-						async (t) => (await stateAsync(Promise.resolve(1)).get(t)) * 2,
-					);
-					$derivation.dispose();
-					await expect($derivation.trigger()).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-			});
-		});
-	});
-
-	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 effectFn = vi.fn();
-
-				effect(async (t) => {
-					await $derivation.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).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 effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-			});
-
-			it("should call effect when dependency changes", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-
-				$state.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(4);
-			});
-
-			it("should not call effect when value does not change", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				$state.set(Promise.resolve(1));
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should not call effect after effect is disposed", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-				const $effect = effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-
-				$state.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(4);
-
-				$effect.dispose();
-
-				$state.set(Promise.resolve(3));
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(2);
-			});
-
-			it("should support multiple effects depending on same derivation", async () => {
-				const $state = stateAsync(Promise.resolve(200));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn1 = vi.fn();
-				const effectFn2 = vi.fn();
-				const effectFn3 = vi.fn();
-
-				effect(async (t) => {
-					await $derivation.get(t);
-					effectFn1();
-				});
-
-				effect(async (t) => {
-					await $derivation.get(t);
-					effectFn2();
-				});
-
-				effect(async (t) => {
-					await $derivation.get(t);
-					effectFn3();
-				});
-
-				await vi.waitFor(() => {
-					expect(effectFn1).toHaveBeenCalledTimes(1);
-					expect(effectFn2).toHaveBeenCalledTimes(1);
-					expect(effectFn3).toHaveBeenCalledTimes(1);
-				});
-
-				$state.set(Promise.resolve(300));
-				await vi.waitFor(() => {
-					expect(effectFn1).toHaveBeenCalledTimes(2);
-					expect(effectFn2).toHaveBeenCalledTimes(2);
-					expect(effectFn3).toHaveBeenCalledTimes(2);
-				});
-			});
-
-			it("should support effect with get and untracked get mixed", async () => {
-				const $state1 = stateAsync(Promise.resolve(10));
-				const $state2 = stateAsync(Promise.resolve(20));
-				const $derivation1 = derivationAsync(
-					async (t) => (await $state1.get(t)) * 2,
-				);
-				const $derivation2 = derivationAsync(
-					async (t) => (await $state2.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					const tracked = await $derivation1.get(t);
-					const untracked = await $derivation2.get(null);
-					effectFn(tracked, untracked);
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(20, 40);
-
-				// Changing derivation1 should trigger effect
-				$state1.set(Promise.resolve(11));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(22, 40);
-
-				// Changing derivation2 should not trigger effect (untracked)
-				$state2.set(Promise.resolve(21));
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).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 effectFn = vi.fn();
-
-				effect(async (t) => {
-					const a = await $derivationA.get(t);
-					const b = await $derivationB.get(t);
-					effectFn(a, b);
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(10, 20);
-
-				$stateA.set(Promise.resolve(6));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(12, 20);
-
-				$stateB.set(Promise.resolve(11));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				expect(effectFn).toHaveBeenLastCalledWith(12, 22);
-			});
-		});
-
-		describe("watch", () => {
-			it("should register dependency when watch is used in effect", async () => {
-				const $state = stateAsync(Promise.resolve(400));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					await $derivation.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-			});
-
-			it("should trigger re-runs when derivation changes after watch", async () => {
-				const $state = stateAsync(Promise.resolve(500));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					await $derivation.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				$state.set(Promise.resolve(600));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-			});
-		});
-
-		describe("subscribe", () => {
-			it("should create effect internally when subscribe is used", async () => {
-				const $state = stateAsync(Promise.resolve(700));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener = vi.fn();
-
-				$derivation.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(await listener.mock.calls[0][0]).toBe(1400);
-			});
-
-			it("should support multiple subscriptions with effects", async () => {
-				const $state = stateAsync(Promise.resolve(800));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener1 = vi.fn();
-				const listener2 = vi.fn();
-
-				$derivation.subscribe(listener1);
-				$derivation.subscribe(listener2);
-
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(1);
-					expect(listener2).toHaveBeenCalledTimes(1);
-				});
-
-				$state.set(Promise.resolve(900));
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(2);
-					expect(listener2).toHaveBeenCalledTimes(2);
-				});
-			});
-
-			it("should dispose effect when disposer is called", async () => {
-				const $state = stateAsync(Promise.resolve(1000));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const listener = vi.fn();
-
-				const unsubscribe = $derivation.subscribe(async (promise) =>
-					listener(await promise),
-				);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				$state.set(Promise.resolve(1100));
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
-
-				unsubscribe();
-
-				$state.set(Promise.resolve(1200));
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(2);
-			});
-		});
-
-		describe("error handling", () => {
-			describe("compute function errors", () => {
-				it("should propagate error when lazy compute throws in effect", async () => {
-					const error = new Error("Effect compute error");
-					const $derivation = derivationAsync(async () => {
-						throw error;
-					});
-
-					const $effect = effect(async (t) => {
-						await $derivation.get(t);
-					});
-
-					await expect($effect.settled).rejects.toThrow("Effect compute error");
-				});
-
-				it("should propagate error when lazy compute throws on subsequent effect run", async () => {
-					const $state = stateAsync(Promise.resolve(1));
-					const $derivation = derivationAsync(async (t) => {
-						const value = await $state.get(t);
-						if (value > 1) {
-							throw new Error("Effect compute error");
-						}
-						return value;
-					});
-
-					const $effect = effect(async (t) => {
-						await $derivation.get(t);
-					});
-
-					await expect($effect.settled).resolves.toBeUndefined();
-
-					await expect($state.set(Promise.resolve(2))).rejects.toThrow(
-						"Effect compute error",
-					);
-					await expect($effect.settled).rejects.toThrow("Effect compute error");
-				});
-			});
-
-			describe("disposed derivation", () => {
-				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 $effect = effect(async (t) => {
-						await $derivation.get(t);
-					});
-
-					await expect($effect.settled).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-			});
-		});
-
-		describe("disposal", () => {
-			it("should dispose effects when derivation is disposed", async () => {
-				const $state = stateAsync(Promise.resolve(1300));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-				const $effect = effect(async (t) => {
-					await $derivation.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect($effect.disposed).toBe(false);
-
-				$derivation.dispose();
-
-				expect($effect.disposed).toBe(true);
-			});
-
-			it("should not dispose effects when derivation is disposed with self option", async () => {
-				const $state = stateAsync(Promise.resolve(1400));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-				const $effect = effect(async (t) => {
-					await $derivation.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect($effect.disposed).toBe(false);
-
-				$derivation.dispose({ self: true });
-
-				expect($effect.disposed).toBe(false);
-				expect($derivation.disposed).toBe(true);
-			});
-
-			it("should unregister effects when derivation is disposed with self option", async () => {
-				const $state = stateAsync(Promise.resolve(1500));
-				const $derivation = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-				const $effect = effect(async (t) => {
-					await $derivation.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				$derivation.dispose({ self: true });
-
-				// Effect should still be active but not notified
-				expect($effect.disposed).toBe(false);
-
-				// But derivation is disposed so operations should fail
-				const $tracker = stateAsync(Promise.resolve(0));
-				await expect($derivation.get($tracker)).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("dependencies", () => {
-			it("should handle chained dependencies", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation1 = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const $derivation2 = derivationAsync(
-					async (t) => (await $derivation1.get(t)) * 2,
-				);
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation2.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(4);
-
-				$state.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(8);
-			});
-
-			it("should handle multiple dependencies", async () => {
-				const $state1 = stateAsync(Promise.resolve(1));
-				const $state2 = stateAsync(Promise.resolve(2));
-				const $derivation = derivationAsync(
-					async (t) => (await $state1.get(t)) + (await $state2.get(t)),
-				);
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(3);
-
-				$state1.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(4);
-
-				$state2.set(Promise.resolve(3));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				expect(effectFn).toHaveBeenLastCalledWith(5);
-			});
-
-			it("should handle multiple dependants", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation1 = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const $derivation2 = derivationAsync(
-					async (t) => (await $state.get(t)) * 3,
-				);
-				const effect1Fn = vi.fn();
-				const effect2Fn = vi.fn();
-
-				effect(async (t) => effect1Fn(await $derivation1.get(t)));
-				effect(async (t) => effect2Fn(await $derivation2.get(t)));
-
-				await vi.waitFor(() => {
-					expect(effect1Fn).toHaveBeenCalledTimes(1);
-					expect(effect2Fn).toHaveBeenCalledTimes(1);
-				});
-				expect(effect1Fn).toHaveBeenLastCalledWith(2);
-				expect(effect2Fn).toHaveBeenLastCalledWith(3);
-
-				$state.set(Promise.resolve(2));
-				await vi.waitFor(() => {
-					expect(effect1Fn).toHaveBeenCalledTimes(2);
-					expect(effect2Fn).toHaveBeenCalledTimes(2);
-				});
-				expect(effect1Fn).toHaveBeenLastCalledWith(4);
-				expect(effect2Fn).toHaveBeenLastCalledWith(6);
-			});
-
-			it("should handle derivation depending on state and signal", async () => {
-				const $signal = signal();
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation = derivationAsync(async (t) => {
-					$signal.watch(t);
-					return (await $state.get(t)) * 2;
-				});
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-
-				$signal.trigger();
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-
-				$state.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				expect(effectFn).toHaveBeenLastCalledWith(4);
-			});
-
-			it("should handle derivation depending on multiple states", async () => {
-				const $state1 = stateAsync(Promise.resolve(5));
-				const $state2 = stateAsync(Promise.resolve(10));
-				const $state3 = stateAsync(Promise.resolve(15));
-				const $derivation = derivationAsync(
-					async (t) =>
-						(await $state1.get(t)) +
-						(await $state2.get(t)) +
-						(await $state3.get(t)),
-				);
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(30);
-
-				$state1.set(Promise.resolve(6));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(31);
-			});
-
-			it("should handle derivation depending on multiple signals", async () => {
-				const $signal1 = signal();
-				const $signal2 = signal();
-				const $derivation = derivationAsync(async (t) => {
-					$signal1.watch(t);
-					$signal2.watch(t);
-				});
-				const effectFn = vi.fn();
-				effect(async (t) => {
-					await $derivation.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				$signal1.trigger();
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-
-				$signal2.trigger();
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-			});
-
-			it("should handle derivation depending on state and other derivation", async () => {
-				const $state = stateAsync(Promise.resolve(1));
-				const $derivation1 = derivationAsync(
-					async (t) => (await $state.get(t)) * 2,
-				);
-				const $derivation2 = derivationAsync(
-					async (t) => (await $state.get(t)) + (await $derivation1.get(t)),
-				);
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation2.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(3);
-
-				$state.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(6);
-			});
-		});
-
-		describe("patterns", () => {
-			it("should handle diamond pattern", async () => {
-				const $stateA = stateAsync(Promise.resolve(1));
-				const $aMult3 = derivationAsync(
-					async (t) => (await $stateA.get(t)) * 3,
-				);
-				const $aMult2 = derivationAsync(
-					async (t) => (await $stateA.get(t)) * 2,
-				);
-				const $addAmult3Amult2 = derivationAsync(
-					async (t) => (await $aMult3.get(t)) + (await $aMult2.get(t)),
-				);
-
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $addAmult3Amult2.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(5);
-
-				$stateA.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(10);
-
-				$stateA.set(Promise.resolve(3));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				expect(effectFn).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) => {
-					const a = await $stateA.get(t);
-					const b = await $stateB.get(t);
-					return a + b;
-				});
-
-				const $multiplyAB = derivationAsync(async (t) => {
-					const a = await $stateA.get(t);
-					const b = await $stateB.get(t);
-					return a * b;
-				});
-
-				const $addAndMultiply = derivationAsync(async (t) => {
-					const add = await $addAB.get(t);
-					const multiply = await $multiplyAB.get(t);
-					return add * multiply;
-				});
-
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $addAndMultiply.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(6);
-
-				$stateA.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(16);
-
-				$stateB.set(Promise.resolve(3));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				expect(effectFn).toHaveBeenLastCalledWith(30);
-			});
-
-			it("should handle derivation with conditional dependencies", async () => {
-				const obj = {
-					cond: stateAsync(Promise.resolve(false)),
-					b: stateAsync(Promise.resolve(2)),
-				};
-
-				const $state = stateAsync(Promise.resolve(obj));
-				const $derivation = derivationAsync(async (t) => {
-					const cond = await (await $state.get(t)).cond.get(t);
-					if (cond) {
-						return (await (await $state.get(t)).b.get(t)) * 2;
-					}
-					return 0;
-				});
-
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(0);
-
-				(await $state.pick()).cond.set(Promise.resolve(true));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(4);
-
-				await $state.set(
-					Promise.resolve({
-						cond: stateAsync(Promise.resolve(false)),
-						b: stateAsync(Promise.resolve(3)),
-					}),
-				);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				expect(effectFn).toHaveBeenLastCalledWith(0);
-
-				(await $state.pick()).cond.set(Promise.resolve(true));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(4));
-				expect(effectFn).toHaveBeenLastCalledWith(6);
-			});
-
-			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) => {
-					if (await $cond.get(t)) {
-						return (await $state1.get(t)) * 2;
-					}
-					return (await $state2.get(t)) * 2;
-				});
-
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-
-				$state1.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(4);
-
-				$cond.set(Promise.resolve(false));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				expect(effectFn).toHaveBeenLastCalledWith(20);
-
-				$state2.set(Promise.resolve(20));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(4));
-				expect(effectFn).toHaveBeenLastCalledWith(40);
-			});
-
-			it("should handle nested states in derivation", async () => {
-				const obj1 = {
-					cond: stateAsync(Promise.resolve(false)),
-					num: stateAsync(Promise.resolve(2)),
-					dispose: (options: { self: boolean }) => {
-						obj1.cond.dispose(options);
-						obj1.num.dispose(options);
-					},
-				};
-				const obj2 = {
-					cond: stateAsync(Promise.resolve(false)),
-					num: stateAsync(Promise.resolve(4)),
-					dispose: (options: { self: boolean }) => {
-						obj2.cond.dispose(options);
-						obj2.num.dispose(options);
-					},
-				};
-				const $state = stateAsync(Promise.resolve(obj1));
-				const $derivationCond = derivationAsync(async (t) =>
-					(await $state.get(t)).cond.get(t),
-				);
-				const $derivationNum = derivationAsync(
-					async (t) => (await (await $state.get(t)).num.get(t)) * 2,
-				);
-				const effectCondFn = vi.fn();
-				const effectNumFn = vi.fn();
-				effect(async (t) => effectCondFn(await $derivationCond.get(t)));
-				effect(async (t) => effectNumFn(await $derivationNum.get(t)));
-
-				await vi.waitFor(() => expect(effectCondFn).toHaveBeenCalledTimes(1));
-				expect(effectCondFn).toHaveBeenLastCalledWith(false);
-				await vi.waitFor(() => expect(effectNumFn).toHaveBeenCalledTimes(1));
-				expect(effectNumFn).toHaveBeenLastCalledWith(4);
-
-				(await $state.pick()).num.set(Promise.resolve(3));
-				await vi.waitFor(() => expect(effectCondFn).toHaveBeenCalledTimes(1));
-				expect(effectCondFn).toHaveBeenLastCalledWith(false);
-				await vi.waitFor(() => expect(effectNumFn).toHaveBeenCalledTimes(2));
-				expect(effectNumFn).toHaveBeenLastCalledWith(6);
-
-				(await $state.pick()).cond.set(Promise.resolve(true));
-				await vi.waitFor(() => expect(effectCondFn).toHaveBeenCalledTimes(2));
-				expect(effectCondFn).toHaveBeenLastCalledWith(true);
-				await vi.waitFor(() => expect(effectNumFn).toHaveBeenCalledTimes(2));
-				expect(effectNumFn).toHaveBeenLastCalledWith(6);
-
-				$state.set(Promise.resolve(obj2));
-				await vi.waitFor(() => expect(effectCondFn).toHaveBeenCalledTimes(3));
-				expect(effectCondFn).toHaveBeenLastCalledWith(false);
-				await vi.waitFor(() => expect(effectNumFn).toHaveBeenCalledTimes(3));
-				expect(effectNumFn).toHaveBeenLastCalledWith(8);
-
-				(await $state.pick()).cond.set(Promise.resolve(true));
-				await vi.waitFor(() => expect(effectCondFn).toHaveBeenCalledTimes(4));
-				expect(effectCondFn).toHaveBeenLastCalledWith(true);
-				await vi.waitFor(() => expect(effectNumFn).toHaveBeenCalledTimes(3));
-				expect(effectNumFn).toHaveBeenLastCalledWith(8);
-
-				(await $state.pick()).num.set(Promise.resolve(5));
-				await vi.waitFor(() => expect(effectCondFn).toHaveBeenCalledTimes(4));
-				expect(effectCondFn).toHaveBeenLastCalledWith(true);
-				await vi.waitFor(() => expect(effectNumFn).toHaveBeenCalledTimes(4));
-				expect(effectNumFn).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) => (await $state.get(t)) * multiplier,
-				);
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(10);
-
-				multiplier = 3;
-				await $derivation.refresh();
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).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) => (await $state.get(t)) * 2);
-				const $derivation = derivationAsync(computeFn);
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $derivation.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(computeFn).toHaveBeenCalledTimes(1);
-
-				// Refresh forces recomputation even though state hasn't changed
-				await $derivation.refresh();
-				await vi.waitFor(() => expect(computeFn).toHaveBeenCalledTimes(2));
-				// Effect should not be called again because value hasn't changed
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(1);
-			});
-		});
-	});
-});