@ersbeth/picoflow 1.0.1 → 1.1.0

package/test/nodes/async/flowStateAsync.test.ts

@@ -0,0 +1,1387 @@
+import { describe, expect, it, vi } from "vitest";
+import { effect, state, stateAsync } from "#package";
+import { FlowNodeAsync } from "../../../src/flow/nodes/async/flowNodeAsync";
+
+describe("flowStateAsync", () => {
+	describe("unit", () => {
+		describe("initialization", () => {
+			it("should initialize with direct Promise", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				expect(await $state.pick()).toBe(1);
+			});
+
+			it("should initialize lazily with function", async () => {
+				const initFn = vi.fn(() => Promise.resolve(42));
+				const $state = stateAsync(initFn);
+
+				// Function should not be called yet
+				expect(initFn).not.toHaveBeenCalled();
+
+				// First access triggers initialization
+				const value = await $state.pick();
+				expect(value).toBe(42);
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should call lazy init function only once", async () => {
+				const initFn = vi.fn(() => Promise.resolve(100));
+				const $state = stateAsync(initFn);
+
+				// Multiple accesses should only call init once
+				await $state.pick();
+				await $state.pick();
+				await $state.pick();
+
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should cache value after lazy initialization", async () => {
+				const initFn = vi.fn(() => Promise.resolve("cached"));
+				const $state = stateAsync(initFn);
+
+				const value1 = await $state.pick();
+				const value2 = await $state.pick();
+				const value3 = await $state.pick();
+
+				expect(value1).toBe("cached");
+				expect(value2).toBe("cached");
+				expect(value3).toBe("cached");
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should handle number values", async () => {
+				const $state = stateAsync(Promise.resolve(42));
+				expect(await $state.pick()).toBe(42);
+			});
+
+			it("should handle string values", async () => {
+				const $state = stateAsync(Promise.resolve("hello"));
+				expect(await $state.pick()).toBe("hello");
+			});
+
+			it("should handle object values", async () => {
+				const obj = { a: 1, b: 2 };
+				const $state = stateAsync(Promise.resolve(obj));
+				const value = await $state.pick();
+				expect(value).toBe(obj);
+				expect(value).toEqual({ a: 1, b: 2 });
+			});
+
+			it("should handle array values", async () => {
+				const arr = [1, 2, 3];
+				const $state = stateAsync(Promise.resolve(arr));
+				const value = await $state.pick();
+				expect(value).toBe(arr);
+				expect(value).toEqual([1, 2, 3]);
+			});
+
+			it("should handle null values", async () => {
+				const $state = stateAsync(Promise.resolve(null));
+				const value = await $state.pick();
+				expect(value).toBeNull();
+			});
+
+			it("should handle undefined values", async () => {
+				const $state = stateAsync(Promise.resolve(undefined));
+				const value = await $state.pick();
+				expect(value).toBeUndefined();
+			});
+
+			it("should handle Promise rejection in initialization", async () => {
+				const $state = stateAsync(Promise.reject(new Error("Init error")));
+				await expect($state.pick()).rejects.toThrow("Init error");
+			});
+		});
+
+		describe("get", () => {
+			it("should return Promise with tracking context", async () => {
+				const $state = stateAsync(Promise.resolve(5));
+				const $tracker = state(0);
+				const promise = $state.get($tracker);
+
+				expect(promise).toBeInstanceOf(Promise);
+				const value = await promise;
+				expect(value).toBe(5);
+			});
+
+			it("should compute lazy value on first get call", async () => {
+				const initFn = vi.fn(() => Promise.resolve(20));
+				const $state = stateAsync(initFn);
+				const $tracker = state(0);
+
+				expect(initFn).not.toHaveBeenCalled();
+				const promise = $state.get($tracker);
+				expect(promise).toBeInstanceOf(Promise);
+				const value = await promise;
+				expect(value).toBe(20);
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should return cached value on subsequent get calls", async () => {
+				const initFn = vi.fn(() => Promise.resolve(20));
+				const $state = stateAsync(initFn);
+				const $tracker = state(0);
+
+				const promise1 = $state.get($tracker);
+				const promise2 = $state.get($tracker);
+				const promise3 = $state.get($tracker);
+
+				const value1 = await promise1;
+				const value2 = await promise2;
+				const value3 = await promise3;
+
+				expect(value1).toBe(20);
+				expect(value2).toBe(20);
+				expect(value3).toBe(20);
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should throw error when get is called after disposal", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const $tracker = state(0);
+
+				await $state.get($tracker);
+				$state.dispose();
+
+				await expect($state.get($tracker)).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("pick", () => {
+			it("should return Promise without tracking", async () => {
+				const $state = stateAsync(Promise.resolve(15));
+				const promise = $state.pick();
+
+				expect(promise).toBeInstanceOf(Promise);
+				const value = await promise;
+				expect(value).toBe(15);
+			});
+
+			it("should compute lazy value on first pick call", async () => {
+				const initFn = vi.fn(() => Promise.resolve(25));
+				const $state = stateAsync(initFn);
+
+				expect(initFn).not.toHaveBeenCalled();
+				const promise = $state.pick();
+				expect(promise).toBeInstanceOf(Promise);
+				const value = await promise;
+				expect(value).toBe(25);
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should return cached value on subsequent pick calls", async () => {
+				const initFn = vi.fn(() => Promise.resolve(30));
+				const $state = stateAsync(initFn);
+
+				const value1 = await $state.pick();
+				const value2 = await $state.pick();
+				const value3 = await $state.pick();
+
+				expect(value1).toBe(30);
+				expect(value2).toBe(30);
+				expect(value3).toBe(30);
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should throw error when pick is called after disposal", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+
+				expect(await $state.pick()).toBe(1);
+
+				$state.dispose();
+
+				await expect($state.pick()).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("set", () => {
+			it("should update value with Promise", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				expect(await $state.pick()).toBe(1);
+
+				await $state.set(Promise.resolve(2));
+				expect(await $state.pick()).toBe(2);
+			});
+
+			it("should update value with updater function", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				expect(await $state.pick()).toBe(1);
+
+				await $state.set(async (state) => state + 1);
+				expect(await $state.pick()).toBe(2);
+			});
+
+			it("should return a Promise", () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const result = $state.set(Promise.resolve(2));
+				expect(result).toBeInstanceOf(Promise);
+			});
+
+			it("should not notify when set with same value", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const listener = vi.fn();
+				$state.subscribe(async (value) => listener(await value));
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				await $state.set(Promise.resolve(1));
+
+				// Wait to ensure no additional calls
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(listener).toHaveBeenCalledTimes(1);
+			});
+
+			it("should notify when set with different value", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const listener = vi.fn();
+				$state.subscribe(async (value) => listener(await value));
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				await $state.set(Promise.resolve(2));
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
+				expect(listener).toHaveBeenLastCalledWith(2);
+			});
+
+			it("should not notify when updater returns same value", async () => {
+				const $state = stateAsync(Promise.resolve(5));
+				const listener = vi.fn();
+				$state.subscribe(async (value) => listener(await value));
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				await $state.set(async (current) => current);
+
+				// Wait to ensure no additional calls
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(listener).toHaveBeenCalledTimes(1);
+			});
+
+			it("should notify when updater returns different value", async () => {
+				const $state = stateAsync(Promise.resolve(5));
+				const listener = vi.fn();
+				$state.subscribe(async (value) => listener(await value));
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				await $state.set(async (current) => current + 1);
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
+				expect(listener).toHaveBeenLastCalledWith(6);
+			});
+
+			it("should handle async updater function", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+
+				await $state.set(async (current) => {
+					await new Promise((resolve) => setTimeout(resolve, 10));
+					return current + 10;
+				});
+
+				expect(await $state.pick()).toBe(11);
+			});
+
+			it("should handle Promise rejection in set", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+
+				await expect(
+					$state.set(Promise.reject(new Error("Set error"))),
+				).rejects.toThrow("Set error");
+			});
+
+			it("should return Promise<void>", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const result = await $state.set(Promise.resolve(2));
+				expect(result).toBeUndefined();
+			});
+
+			it("should throw error when set is called after disposal", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+
+				expect(await $state.pick()).toBe(1);
+
+				await $state.set(Promise.resolve(2));
+				expect(await $state.pick()).toBe(2);
+
+				$state.dispose();
+
+				await expect($state.set(Promise.resolve(3))).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("watch", () => {
+			it("should register dependency when watch is called", () => {
+				const $state = stateAsync(Promise.resolve(35));
+				const $tracker = state(0);
+
+				expect(() => $state.watch($tracker)).not.toThrow();
+			});
+
+			it("should compute lazy value when watch is called", async () => {
+				const initFn = vi.fn(() => Promise.resolve(40));
+				const $state = stateAsync(initFn);
+				const $tracker = state(0);
+
+				expect(initFn).not.toHaveBeenCalled();
+				$state.watch($tracker);
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should throw error when watch is called after disposal", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const $tracker = state(0);
+
+				await $state.watch($tracker);
+				$state.dispose();
+
+				await expect($state.watch($tracker)).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("subscribe", () => {
+			it("should return a disposer function", () => {
+				const $state = stateAsync(Promise.resolve(50));
+				const listener = vi.fn();
+				const disposer = $state.subscribe(listener);
+
+				expect(typeof disposer).toBe("function");
+			});
+
+			it("should call listener immediately with current value", async () => {
+				const $state = stateAsync(Promise.resolve(55));
+				const listener = vi.fn();
+
+				$state.subscribe(async (value) => listener(await value));
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+				expect(listener).toHaveBeenLastCalledWith(55);
+			});
+
+			it("should call listener with lazy init value", async () => {
+				const $state = stateAsync(async () => 60);
+				const listener = vi.fn();
+
+				$state.subscribe(async (value) => listener(await value));
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+				expect(listener).toHaveBeenLastCalledWith(60);
+			});
+
+			it("should call listener when value is updated", async () => {
+				const $state = stateAsync(Promise.resolve(65));
+				const listener = vi.fn();
+
+				$state.subscribe(async (value) => listener(await value));
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				await $state.set(Promise.resolve(70));
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
+				expect(listener).toHaveBeenLastCalledWith(70);
+			});
+
+			it("should not call listener when updated with same value", async () => {
+				const $state = stateAsync(Promise.resolve(75));
+				const listener = vi.fn();
+
+				$state.subscribe(async (value) => listener(await value));
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				await $state.set(Promise.resolve(80));
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
+
+				await $state.set(Promise.resolve(80));
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(listener).toHaveBeenCalledTimes(2);
+			});
+
+			it("should not call listener after disposer is called", async () => {
+				const $state = stateAsync(Promise.resolve(85));
+				const listener = vi.fn();
+
+				const unsubscribe = $state.subscribe(async (value) =>
+					listener(await value),
+				);
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				unsubscribe();
+
+				await $state.set(Promise.resolve(90));
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(listener).toHaveBeenCalledTimes(1);
+			});
+
+			it("should support multiple subscriptions", async () => {
+				const $state = stateAsync(Promise.resolve(95));
+				const listener1 = vi.fn();
+				const listener2 = vi.fn();
+				const listener3 = vi.fn();
+
+				$state.subscribe(async (value) => listener1(await value));
+				$state.subscribe(async (value) => listener2(await value));
+				$state.subscribe(async (value) => listener3(await value));
+
+				await vi.waitFor(() => {
+					expect(listener1).toHaveBeenCalledTimes(1);
+					expect(listener2).toHaveBeenCalledTimes(1);
+					expect(listener3).toHaveBeenCalledTimes(1);
+				});
+
+				expect(listener1).toHaveBeenLastCalledWith(95);
+				expect(listener2).toHaveBeenLastCalledWith(95);
+				expect(listener3).toHaveBeenLastCalledWith(95);
+			});
+		});
+
+		describe("trigger", () => {
+			it("should return a Promise", () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const result = $state.trigger();
+				expect(result).toBeInstanceOf(Promise);
+			});
+
+			it("should allow multiple triggers", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const promise1 = $state.trigger();
+				const promise2 = $state.trigger();
+				const promise3 = $state.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));
+				expect($state.disposed).toBe(false);
+			});
+
+			it("should have disposed property set to true after disposal", () => {
+				const $state = stateAsync(Promise.resolve(1));
+				$state.dispose();
+				expect($state.disposed).toBe(true);
+			});
+
+			it("should throw error when disposed twice", () => {
+				const $state = stateAsync(Promise.resolve(1));
+				$state.dispose();
+				expect(() => $state.dispose()).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should accept self option without throwing", () => {
+				const $state = stateAsync(Promise.resolve(1));
+				expect(() => $state.dispose({ self: true })).not.toThrow();
+				expect($state.disposed).toBe(true);
+			});
+
+			it("should accept default options without throwing", () => {
+				const $state = stateAsync(Promise.resolve(1));
+				expect(() => $state.dispose()).not.toThrow();
+				expect($state.disposed).toBe(true);
+			});
+		});
+
+		describe("special cases", () => {
+			it("should handle lazy initialization with function returning different values", async () => {
+				let counter = 0;
+				const $state = stateAsync(async () => {
+					counter++;
+					return counter;
+				});
+
+				// First access should return 1
+				const $tracker = state(0);
+				expect(await $state.get($tracker)).toBe(1);
+
+				// Subsequent accesses should return cached value (1), not 2
+				expect(await $state.get($tracker)).toBe(1);
+				expect(await $state.get($tracker)).toBe(1);
+				expect(counter).toBe(1);
+			});
+
+			it("should handle nested states", async () => {
+				const $stateA = stateAsync(Promise.resolve(1));
+				const $stateB = stateAsync(Promise.resolve(2));
+				const $stateC = stateAsync(
+					Promise.resolve({
+						a: $stateA,
+						b: $stateB,
+					}),
+				);
+
+				const value = await $stateC.pick();
+				expect(value.a).toBe($stateA);
+				expect(value.b).toBe($stateB);
+			});
+
+			it("should handle state with complex object values", async () => {
+				const complexObj = {
+					nested: { deep: { value: 42 } },
+					array: [1, 2, 3],
+				};
+				const $state = stateAsync(Promise.resolve(complexObj));
+				const value = await $state.pick();
+				expect(value).toBe(complexObj);
+				expect(value.nested.deep.value).toBe(42);
+				expect(value.array).toEqual([1, 2, 3]);
+			});
+		});
+
+		describe("error handling", () => {
+			describe("compute function errors", () => {
+				it("should propagate error when pick is called with throwing init", async () => {
+					const error = new Error("Init pick error");
+					const $state = stateAsync(async () => {
+						throw error;
+					});
+
+					await expect($state.pick()).rejects.toThrow("Init pick error");
+				});
+
+				it("should propagate error when get is called with throwing init", async () => {
+					const error = new Error("Init get error");
+					const $state = stateAsync(async () => {
+						throw error;
+					});
+
+					const $tracker = state(0);
+					await expect($state.get($tracker)).rejects.toThrow("Init get error");
+				});
+			});
+
+			describe("disposed state", () => {
+				it("should throw error when pick is called after disposal", async () => {
+					const $state = stateAsync(Promise.resolve(1));
+
+					await $state.pick();
+					$state.dispose();
+
+					await expect($state.pick()).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+
+				it("should throw error when get is called after disposal", async () => {
+					const $state = stateAsync(Promise.resolve(1));
+					const $tracker = state(0);
+
+					await $state.get($tracker);
+					$state.dispose();
+
+					await expect($state.get($tracker)).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+
+				it("should throw error when set is called after disposal", async () => {
+					const $state = stateAsync(Promise.resolve(1));
+
+					await $state.pick();
+					await $state.set(Promise.resolve(2));
+					$state.dispose();
+
+					await expect($state.set(Promise.resolve(3))).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+
+				it("should throw error when watch is called after disposal", async () => {
+					const $state = stateAsync(Promise.resolve(1));
+					const $tracker = state(0);
+
+					await $state.watch($tracker);
+					$state.dispose();
+
+					await expect($state.watch($tracker)).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+
+				it("should throw error when subscribe is called after disposal", () => {
+					const $state = stateAsync(Promise.resolve(1));
+					const listener = vi.fn();
+
+					$state.dispose();
+
+					expect(() => $state.subscribe(listener)).toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+
+				it("should throw error when trigger is called after disposal", async () => {
+					const $state = stateAsync(Promise.resolve(1));
+					$state.dispose();
+					await expect($state.trigger()).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+			});
+		});
+
+		describe("FlowNodeAsync computed mode (derivation)", () => {
+			it("should compute value lazily", async () => {
+				const $source = stateAsync(Promise.resolve(10));
+				const computeFn = vi.fn(async (t) => {
+					const val = await $source.get(t);
+					return val * 2;
+				});
+
+				const $computed = new FlowNodeAsync(computeFn);
+				expect(computeFn).not.toHaveBeenCalled();
+
+				const value = await $computed.pick();
+				expect(value).toBe(20);
+				expect(computeFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should mark as dirty when dependency changes", async () => {
+				const $source = stateAsync(Promise.resolve(10));
+				const $computed = new FlowNodeAsync(async (t) => {
+					const val = await $source.get(t);
+					return val * 2;
+				});
+
+				await $computed.pick();
+				expect(await $computed.pick()).toBe(20);
+
+				await $source.set(Promise.resolve(15));
+				// Should recompute on next access
+				expect(await $computed.pick()).toBe(30);
+			});
+
+			it("should not recompute immediately when marked dirty", async () => {
+				const $source = stateAsync(Promise.resolve(10));
+				const computeFn = vi.fn(async (t) => {
+					const val = await $source.get(t);
+					return val * 2;
+				});
+
+				const $computed = new FlowNodeAsync(computeFn);
+				await $computed.pick();
+				expect(computeFn).toHaveBeenCalledTimes(1);
+
+				await $source.set(Promise.resolve(15));
+				// Should not recompute yet
+				expect(computeFn).toHaveBeenCalledTimes(1);
+
+				// Recomputes on next access
+				await $computed.pick();
+				expect(computeFn).toHaveBeenCalledTimes(2);
+			});
+
+			it("should allow temporary override with set()", async () => {
+				const $source = stateAsync(Promise.resolve(10));
+				const $computed = new FlowNodeAsync(async (t) => {
+					const val = await $source.get(t);
+					return val * 2;
+				});
+
+				expect(await $computed.pick()).toBe(20);
+
+				// Override temporarily
+				await $computed.set(Promise.resolve(100));
+				expect(await $computed.pick()).toBe(100);
+
+				// Dependency change clears override
+				await $source.set(Promise.resolve(15));
+				expect(await $computed.pick()).toBe(30);
+			});
+
+			it("should handle dynamic dependencies", async () => {
+				const $source1 = stateAsync(Promise.resolve(10));
+				const $source2 = stateAsync(Promise.resolve(20));
+				const $condition = stateAsync(Promise.resolve(true));
+
+				const $computed = new FlowNodeAsync(async (t) => {
+					const cond = await $condition.get(t);
+					if (cond) {
+						return await $source1.get(t);
+					}
+					return await $source2.get(t);
+				});
+
+				expect(await $computed.pick()).toBe(10);
+
+				await $condition.set(Promise.resolve(false));
+				expect(await $computed.pick()).toBe(20);
+
+				// Should track source2 now
+				await $source2.set(Promise.resolve(25));
+				expect(await $computed.pick()).toBe(25);
+			});
+		});
+
+		describe("cache and performance", () => {
+			it("should cache Promise until value changes", async () => {
+				const $state = stateAsync(Promise.resolve(42));
+
+				const promise1 = $state.pick();
+				const promise2 = $state.pick();
+				const promise3 = $state.pick();
+
+				const [value1, value2, value3] = await Promise.all([
+					promise1,
+					promise2,
+					promise3,
+				]);
+
+				expect(value1).toBe(42);
+				expect(value2).toBe(42);
+				expect(value3).toBe(42);
+			});
+
+			it("should not recompute if not dirty", async () => {
+				const computeFn = vi.fn(() => Promise.resolve(50));
+				const $state = stateAsync(computeFn);
+
+				await $state.pick();
+				expect(computeFn).toHaveBeenCalledTimes(1);
+
+				await $state.pick();
+				await $state.pick();
+				await $state.pick();
+
+				expect(computeFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should handle concurrent access", async () => {
+				const $state = stateAsync(Promise.resolve(100));
+
+				const promises = Array.from({ length: 10 }, () => $state.pick());
+				const values = await Promise.all(promises);
+
+				values.forEach((value) => {
+					expect(value).toBe(100);
+				});
+			});
+		});
+	});
+
+	describe("with effect", () => {
+		describe("get", () => {
+			it("should create reactive dependency when get is used in effect", async () => {
+				const $state = stateAsync(Promise.resolve(100));
+				const effectFn = vi.fn();
+
+				effect(async (t) => {
+					await $state.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+			});
+
+			it("should call effect with initial value", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const effectFn = vi.fn();
+				effect(async (t) => effectFn(await $state.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(1);
+			});
+
+			it("should call effect with lazy init value", async () => {
+				const $state = stateAsync(async () => 1);
+				const effectFn = vi.fn();
+				effect(async (t) => effectFn(await $state.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(1);
+			});
+
+			it("should call effect when value is updated", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const effectFn = vi.fn();
+				effect(async (t) => effectFn(await $state.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(1);
+
+				await $state.set(Promise.resolve(2));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(2);
+			});
+
+			it("should not call effect when updated with same value", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const effectFn = vi.fn();
+				effect(async (t) => effectFn(await $state.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				await $state.set(Promise.resolve(2));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(2);
+
+				await $state.set(Promise.resolve(2));
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(effectFn).toHaveBeenCalledTimes(2);
+			});
+
+			it("should not call effect after effect is disposed", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const effectFn = vi.fn();
+				const $effect = effect(async (t) => effectFn(await $state.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(1);
+
+				await $state.set(Promise.resolve(2));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(2);
+
+				$effect.dispose();
+
+				await $state.set(Promise.resolve(3));
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(effectFn).toHaveBeenCalledTimes(2);
+			});
+
+			it("should support multiple effects depending on same state", async () => {
+				const $state = stateAsync(Promise.resolve(200));
+				const effectFn1 = vi.fn();
+				const effectFn2 = vi.fn();
+				const effectFn3 = vi.fn();
+
+				effect(async (t) => {
+					await $state.get(t);
+					effectFn1();
+				});
+
+				effect(async (t) => {
+					await $state.get(t);
+					effectFn2();
+				});
+
+				effect(async (t) => {
+					await $state.get(t);
+					effectFn3();
+				});
+
+				await vi.waitFor(() => {
+					expect(effectFn1).toHaveBeenCalledTimes(1);
+					expect(effectFn2).toHaveBeenCalledTimes(1);
+					expect(effectFn3).toHaveBeenCalledTimes(1);
+				});
+
+				await $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 effectFn = vi.fn();
+
+				effect(async (t) => {
+					const tracked = await $state1.get(t);
+					const untracked = await $state2.get(null);
+					effectFn(tracked, untracked);
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(10, 20);
+
+				// Changing state1 should trigger effect
+				await $state1.set(Promise.resolve(11));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(11, 20);
+
+				// Changing state2 should not trigger effect (untracked)
+				await $state2.set(Promise.resolve(21));
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(effectFn).toHaveBeenCalledTimes(2);
+			});
+
+			it("should support effect depending on multiple states", async () => {
+				const $stateA = stateAsync(Promise.resolve(5));
+				const $stateB = stateAsync(Promise.resolve(10));
+				const effectFn = vi.fn();
+
+				effect(async (t) => {
+					const a = await $stateA.get(t);
+					const b = await $stateB.get(t);
+					effectFn(a, b);
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(5, 10);
+
+				await $stateA.set(Promise.resolve(6));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(6, 10);
+
+				await $stateB.set(Promise.resolve(11));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
+				expect(effectFn).toHaveBeenLastCalledWith(6, 11);
+			});
+		});
+
+		describe("watch", () => {
+			it("should register dependency when watch is used in effect", async () => {
+				const $state = stateAsync(Promise.resolve(400));
+				const effectFn = vi.fn();
+
+				effect(async (t) => {
+					await $state.watch(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+			});
+
+			it("should trigger re-runs when state changes after watch", async () => {
+				const $state = stateAsync(Promise.resolve(500));
+				const effectFn = vi.fn();
+
+				effect(async (t) => {
+					await $state.watch(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				await $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 listener = vi.fn();
+
+				$state.subscribe(async (value) => listener(await value));
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+				expect(listener).toHaveBeenLastCalledWith(700);
+			});
+
+			it("should support multiple subscriptions with effects", async () => {
+				const $state = stateAsync(Promise.resolve(800));
+				const listener1 = vi.fn();
+				const listener2 = vi.fn();
+
+				$state.subscribe(async (value) => listener1(await value));
+				$state.subscribe(async (value) => listener2(await value));
+
+				await vi.waitFor(() => {
+					expect(listener1).toHaveBeenCalledTimes(1);
+					expect(listener2).toHaveBeenCalledTimes(1);
+				});
+
+				await $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 listener = vi.fn();
+
+				const unsubscribe = $state.subscribe(async (value) =>
+					listener(await value),
+				);
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				await $state.set(Promise.resolve(1100));
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
+
+				unsubscribe();
+
+				await $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 init throws in effect", async () => {
+					const error = new Error("Effect init error");
+					const $state = stateAsync(async () => {
+						throw error;
+					});
+
+					const $effect = effect(async (t) => {
+						await $state.get(t);
+					});
+
+					await expect($effect.settled).rejects.toThrow("Effect init error");
+				});
+			});
+
+			describe("disposed state", () => {
+				it("should throw error when creating an effect with a disposed state", async () => {
+					const $state = stateAsync(Promise.resolve(1));
+
+					$state.dispose();
+
+					const $effect = effect(async (t) => {
+						await $state.get(t);
+					});
+
+					await expect($effect.settled).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+			});
+		});
+
+		describe("disposal", () => {
+			it("should dispose effects when state is disposed", async () => {
+				const $state = stateAsync(Promise.resolve(1300));
+				const effectFn = vi.fn();
+				const $effect = effect(async (t) => {
+					await $state.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect($effect.disposed).toBe(false);
+
+				$state.dispose();
+
+				expect($effect.disposed).toBe(true);
+			});
+
+			it("should not dispose effects when state is disposed with self option", async () => {
+				const $state = stateAsync(Promise.resolve(1400));
+				const effectFn = vi.fn();
+				const $effect = effect(async (t) => {
+					await $state.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect($effect.disposed).toBe(false);
+
+				$state.dispose({ self: true });
+
+				expect($effect.disposed).toBe(false);
+				expect($state.disposed).toBe(true);
+			});
+
+			it("should unregister effects when state is disposed with self option", async () => {
+				const $state = stateAsync(Promise.resolve(1500));
+				const effectFn = vi.fn();
+				const $effect = effect(async (t) => {
+					await $state.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				$state.dispose({ self: true });
+
+				// Effect should still be active but not notified
+				expect($effect.disposed).toBe(false);
+
+				// But state is disposed so operations should fail
+				const $tracker = state(0);
+				await expect($state.get($tracker)).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("complex cases", () => {
+			it("should handle nested states in effects", async () => {
+				const $stateA = stateAsync(Promise.resolve(1));
+				const $stateB = stateAsync(Promise.resolve(2));
+				const $stateC = stateAsync(
+					Promise.resolve({
+						a: $stateA,
+						b: $stateB,
+					}),
+				);
+
+				const effectFn = vi.fn();
+				effect(async (t) => {
+					const a = await (await $stateC.get(t)).a.get(t);
+					effectFn(a);
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(1);
+
+				await $stateA.set(Promise.resolve(3));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(3);
+			});
+
+			it("should handle effect depending on multiple states", async () => {
+				const $stateA = stateAsync(Promise.resolve(10));
+				const $stateB = stateAsync(Promise.resolve(20));
+				const $stateC = stateAsync(Promise.resolve(30));
+				const effectFn = vi.fn();
+
+				effect(async (t) => {
+					const a = await $stateA.get(t);
+					const b = await $stateB.get(t);
+					const c = await $stateC.get(t);
+					effectFn(a, b, c);
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(10, 20, 30);
+
+				await $stateA.set(Promise.resolve(11));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(11, 20, 30);
+
+				await $stateB.set(Promise.resolve(21));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
+				expect(effectFn).toHaveBeenLastCalledWith(11, 21, 30);
+			});
+
+			// TODO: Fix this test
+			it.skip("should handle state chaining (state A -> state B -> state C)", async () => {
+				const $stateA = stateAsync(Promise.resolve(100));
+				const $stateB = stateAsync(Promise.resolve(200));
+				const $stateC = stateAsync(Promise.resolve(300));
+				const effectFn = vi.fn();
+
+				// Effect watches A, which triggers B, which triggers C
+				effect(async (t) => {
+					const a = await $stateA.get(t);
+					if (a > 150) {
+						await $stateB.set(Promise.resolve(250));
+					}
+				});
+
+				effect(async (t) => {
+					const b = await $stateB.get(t);
+					if (b > 220) {
+						await $stateC.set(Promise.resolve(350));
+					}
+				});
+
+				effect(async (t) => {
+					const c = await $stateC.get(t);
+					effectFn(c);
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				await $stateA.set(Promise.resolve(200));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+			});
+		});
+
+		describe("with effects - computed mode", () => {
+			it("should call effect with computed state", async () => {
+				const $source = stateAsync(Promise.resolve(10));
+				const $computed = new FlowNodeAsync(async (t) => {
+					const val = await $source.get(t);
+					return val * 2;
+				});
+
+				const effectFn = vi.fn();
+				effect(async (t) => effectFn(await $computed.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(20);
+			});
+
+			it("should re-execute effect when computed dependency changes", async () => {
+				const $source = stateAsync(Promise.resolve(10));
+				const $computed = new FlowNodeAsync(async (t) => {
+					const val = await $source.get(t);
+					return val * 2;
+				});
+
+				const effectFn = vi.fn();
+				effect(async (t) => effectFn(await $computed.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(20);
+
+				await $source.set(Promise.resolve(15));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(30);
+			});
+
+			it("should handle dynamic dependencies in computed state", async () => {
+				const $source1 = stateAsync(Promise.resolve(10));
+				const $source2 = stateAsync(Promise.resolve(20));
+				const $condition = stateAsync(Promise.resolve(true));
+
+				const $computed = new FlowNodeAsync(async (t) => {
+					const cond = await $condition.get(t);
+					if (cond) {
+						return await $source1.get(t);
+					}
+					return await $source2.get(t);
+				});
+
+				const effectFn = vi.fn();
+				effect(async (t) => effectFn(await $computed.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(10);
+
+				await $condition.set(Promise.resolve(false));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(20);
+
+				await $source2.set(Promise.resolve(25));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
+				expect(effectFn).toHaveBeenLastCalledWith(25);
+			});
+
+			it("should handle temporary override in computed state", async () => {
+				const $source = stateAsync(Promise.resolve(10));
+				const $computed = new FlowNodeAsync(async (t) => {
+					const val = await $source.get(t);
+					return val * 2;
+				});
+
+				const effectFn = vi.fn();
+				effect(async (t) => effectFn(await $computed.get(t)));
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(20);
+
+				// Override temporarily
+				await $computed.set(Promise.resolve(100));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				expect(effectFn).toHaveBeenLastCalledWith(100);
+
+				// Dependency change clears override
+				await $source.set(Promise.resolve(15));
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
+				expect(effectFn).toHaveBeenLastCalledWith(30);
+			});
+		});
+
+		describe("with effects - errors", () => {
+			it("should handle Promise rejection in effect", async () => {
+				const $state = stateAsync(Promise.reject(new Error("State error")));
+				const effectFn = vi.fn();
+
+				effect(async (t) => {
+					try {
+						await $state.get(t);
+					} catch (error) {
+						effectFn(error);
+					}
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(
+					expect.objectContaining({ message: "State error" }),
+				);
+			});
+
+			it("should handle Promise rejection during set in effect", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const effectFn = vi.fn();
+
+				effect(async (t) => {
+					const val = await $state.get(t);
+					effectFn(val);
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				await expect(
+					$state.set(Promise.reject(new Error("Set error"))),
+				).rejects.toThrow("Set error");
+			});
+		});
+
+		describe("with effects - execution order", () => {
+			it("should execute multiple effects in order", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const executionOrder: string[] = [];
+
+				effect(async (t) => {
+					const val = await $state.get(t);
+					executionOrder.push(`effect1-${val}`);
+				});
+
+				effect(async (t) => {
+					const val = await $state.get(t);
+					executionOrder.push(`effect2-${val}`);
+				});
+
+				effect(async (t) => {
+					const val = await $state.get(t);
+					executionOrder.push(`effect3-${val}`);
+				});
+
+				await vi.waitFor(() => expect(executionOrder.length).toBe(3));
+				expect(executionOrder).toContain("effect1-1");
+				expect(executionOrder).toContain("effect2-1");
+				expect(executionOrder).toContain("effect3-1");
+			});
+
+			it("should handle async set() in effects", async () => {
+				const $state = stateAsync(Promise.resolve(1));
+				const executionOrder: string[] = [];
+
+				effect(async (t) => {
+					const val = await $state.get(t);
+					executionOrder.push(`effect-${val}`);
+				});
+
+				await vi.waitFor(() => expect(executionOrder.length).toBe(1));
+
+				executionOrder.push("before-set");
+				await $state.set(
+					(async () => {
+						await new Promise((resolve) => setTimeout(resolve, 10));
+						return 2;
+					})(),
+				);
+				executionOrder.push("after-set");
+
+				await vi.waitFor(() =>
+					expect(executionOrder.length).toBeGreaterThan(2),
+				);
+				expect(executionOrder).toContain("effect-2");
+			});
+
+			it("should handle computed state execution order", async () => {
+				const $source = stateAsync(Promise.resolve(10));
+				const $computed = new FlowNodeAsync(async (t) => {
+					const val = await $source.get(t);
+					return val * 2;
+				});
+
+				const executionOrder: string[] = [];
+
+				effect(async (t) => {
+					const val = await $computed.get(t);
+					executionOrder.push(`effect-${val}`);
+				});
+
+				await vi.waitFor(() => expect(executionOrder.length).toBe(1));
+				expect(executionOrder).toContain("effect-20");
+
+				await $source.set(Promise.resolve(15));
+				await vi.waitFor(() => expect(executionOrder.length).toBe(2));
+				expect(executionOrder).toContain("effect-30");
+			});
+		});
+	});
+});