@ersbeth/picoflow 1.1.2 → 2.0.0

package/test/nodes/sync/flowState.test.ts

@@ -1,945 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { effect, state } from "#package";
-
-describe("flowState", () => {
-	describe("unit", () => {
-		describe("initialization", () => {
-			it("should initialize with direct value", async () => {
-				const $state = state(1);
-				expect(await $state.pick()).toBe(1);
-			});
-
-			it("should initialize lazily with function", async () => {
-				const initFn = vi.fn(() => 42);
-				const $state = state(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(() => 100);
-				const $state = state(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(() => "cached");
-				const $state = state(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 = state(42);
-				expect(await $state.pick()).toBe(42);
-			});
-
-			it("should handle string values", async () => {
-				const $state = state("hello");
-				expect(await $state.pick()).toBe("hello");
-			});
-
-			it("should handle object values", async () => {
-				const obj = { a: 1, b: 2 };
-				const $state = state(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 = state(arr);
-				const value = await $state.pick();
-				expect(value).toBe(arr);
-				expect(value).toEqual([1, 2, 3]);
-			});
-
-			it("should handle null values", async () => {
-				const $state = state(null);
-				const value = await $state.pick();
-				expect(value).toBeNull();
-			});
-
-			it("should handle undefined values", async () => {
-				const $state = state(undefined);
-				const value = await $state.pick();
-				expect(value).toBeUndefined();
-			});
-		});
-
-		describe("get", () => {
-			it("should return value with tracking context", () => {
-				const $state = state(5);
-				const $tracker = state(0); // Use state as FlowTracker
-				const value = $state.get($tracker);
-				expect(value).toBe(5);
-			});
-
-			it("should compute lazy value on first get call", () => {
-				const initFn = vi.fn(() => 10);
-				const $state = state(initFn);
-				const $tracker = state(0);
-
-				expect(initFn).not.toHaveBeenCalled();
-				const value = $state.get($tracker);
-				expect(value).toBe(10);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should return cached value on subsequent get calls", () => {
-				const initFn = vi.fn(() => 20);
-				const $state = state(initFn);
-				const $tracker = state(0);
-
-				const value1 = $state.get($tracker);
-				const value2 = $state.get($tracker);
-				const value3 = $state.get($tracker);
-
-				expect(value1).toBe(20);
-				expect(value2).toBe(20);
-				expect(value3).toBe(20);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-		});
-
-		describe("pick", () => {
-			it("should return value without tracking", async () => {
-				const $state = state(15);
-				const value = await $state.pick();
-				expect(value).toBe(15);
-			});
-
-			it("should compute lazy value on first pick call", async () => {
-				const initFn = vi.fn(() => 25);
-				const $state = state(initFn);
-
-				expect(initFn).not.toHaveBeenCalled();
-				const value = await $state.pick();
-				expect(value).toBe(25);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should return cached value on subsequent pick calls", async () => {
-				const initFn = vi.fn(() => 30);
-				const $state = state(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);
-			});
-		});
-
-		describe("set", () => {
-			it("should update value with direct value", async () => {
-				const $state = state(1);
-				expect(await $state.pick()).toBe(1);
-
-				await $state.set(2);
-				expect(await $state.pick()).toBe(2);
-			});
-
-			it("should update value with updater function", async () => {
-				const $state = state(1);
-				expect(await $state.pick()).toBe(1);
-
-				await $state.set((current) => current + 1);
-				expect(await $state.pick()).toBe(2);
-			});
-
-			it("should return a Promise", () => {
-				const $state = state(1);
-				const result = $state.set(2);
-				expect(result).toBeInstanceOf(Promise);
-			});
-
-			it("should not notify when set with same value", async () => {
-				const $state = state(1);
-				const listener = vi.fn();
-				$state.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				await $state.set(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 = state(1);
-				const listener = vi.fn();
-				$state.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				await $state.set(2);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
-				expect(listener).toHaveBeenLastCalledWith(2);
-			});
-
-			it("should not notify when updater returns same value", async () => {
-				const $state = state(5);
-				const listener = vi.fn();
-				$state.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				await $state.set((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 = state(5);
-				const listener = vi.fn();
-				$state.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				await $state.set((current) => current + 1);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
-				expect(listener).toHaveBeenLastCalledWith(6);
-			});
-		});
-
-		describe("watch", () => {
-			it("should register dependency when watch is called", () => {
-				const $state = state(35);
-				const $tracker = state(0);
-
-				expect(() => $state.watch($tracker)).not.toThrow();
-			});
-
-			it("should compute lazy value when watch is called", () => {
-				const initFn = vi.fn(() => 40);
-				const $state = state(initFn);
-				const $tracker = state(0);
-
-				expect(initFn).not.toHaveBeenCalled();
-				$state.watch($tracker);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-		});
-
-		describe("subscribe", () => {
-			it("should return a disposer function", () => {
-				const $state = state(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 = state(55);
-				const listener = vi.fn();
-
-				$state.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(listener).toHaveBeenLastCalledWith(55);
-			});
-
-			it("should call listener with lazy init value", async () => {
-				const $state = state(() => 60);
-				const listener = vi.fn();
-
-				$state.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(listener).toHaveBeenLastCalledWith(60);
-			});
-
-			it("should call listener when value is updated", async () => {
-				const $state = state(65);
-				const listener = vi.fn();
-
-				$state.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				await $state.set(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 = state(75);
-				const listener = vi.fn();
-
-				$state.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				await $state.set(80);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
-
-				await $state.set(80);
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(2);
-			});
-
-			it("should not call listener after disposer is called", async () => {
-				const $state = state(85);
-				const listener = vi.fn();
-
-				const unsubscribe = $state.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				unsubscribe();
-
-				await $state.set(90);
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-
-			it("should support multiple subscriptions", async () => {
-				const $state = state(95);
-				const listener1 = vi.fn();
-				const listener2 = vi.fn();
-				const listener3 = vi.fn();
-
-				$state.subscribe(listener1);
-				$state.subscribe(listener2);
-				$state.subscribe(listener3);
-
-				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 = state(1);
-				const result = $state.trigger();
-				expect(result).toBeInstanceOf(Promise);
-			});
-
-			it("should allow multiple triggers", async () => {
-				const $state = state(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 = state(1);
-				expect($state.disposed).toBe(false);
-			});
-
-			it("should have disposed property set to true after disposal", () => {
-				const $state = state(1);
-				$state.dispose();
-				expect($state.disposed).toBe(true);
-			});
-
-			it("should throw error when disposed twice", () => {
-				const $state = state(1);
-				$state.dispose();
-				expect(() => $state.dispose()).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should accept self option without throwing", () => {
-				const $state = state(1);
-				expect(() => $state.dispose({ self: true })).not.toThrow();
-				expect($state.disposed).toBe(true);
-			});
-
-			it("should accept default options without throwing", () => {
-				const $state = state(1);
-				expect(() => $state.dispose()).not.toThrow();
-				expect($state.disposed).toBe(true);
-			});
-		});
-
-		describe("special cases", () => {
-			it("should handle lazy initialization with function returning different values", () => {
-				let counter = 0;
-				const $state = state(() => {
-					counter++;
-					return counter;
-				});
-
-				// First access should return 1
-				expect($state.get(state(0))).toBe(1);
-
-				// Subsequent accesses should return cached value (1), not 2
-				expect($state.get(state(0))).toBe(1);
-				expect($state.get(state(0))).toBe(1);
-				expect(counter).toBe(1);
-			});
-
-			it("should handle nested states", async () => {
-				const $stateA = state(1);
-				const $stateB = state(2);
-				const $stateC = state({
-					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 = state(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 = state(() => {
-						throw error;
-					});
-
-					await expect($state.pick()).rejects.toThrow("Init pick error");
-				});
-
-				it("should propagate error when get is called with throwing init", () => {
-					const error = new Error("Init get error");
-					const $state = state(() => {
-						throw error;
-					});
-
-					expect(() => $state.get(state(0))).toThrow("Init get error");
-				});
-			});
-
-			describe("disposed state", () => {
-				it("should throw error when pick is called after disposal", async () => {
-					const $state = state(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", () => {
-					const $state = state(1);
-					const $tracker = state(0);
-
-					$state.get($tracker);
-					$state.dispose();
-
-					expect(() => $state.get($tracker)).toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when set is called after disposal", async () => {
-					const $state = state(1);
-
-					await $state.pick();
-					await $state.set(2);
-					$state.dispose();
-
-					expect(() => $state.set(3)).toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when watch is called after disposal", () => {
-					const $state = state(1);
-					const $tracker = state(0);
-
-					$state.watch($tracker);
-					$state.dispose();
-
-					expect(() => $state.watch($tracker)).toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when subscribe is called after disposal", () => {
-					const $state = state(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 = state(1);
-					$state.dispose();
-					await expect($state.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 = state(100);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					$state.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-			});
-
-			it("should call effect with initial value", async () => {
-				const $state = state(1);
-				const effectFn = vi.fn();
-				effect((t) => effectFn($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 = state(() => 1);
-				const effectFn = vi.fn();
-				effect((t) => effectFn($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 = state(1);
-				const effectFn = vi.fn();
-				effect((t) => effectFn($state.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(1);
-
-				await $state.set(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 = state(1);
-				const effectFn = vi.fn();
-				effect((t) => effectFn($state.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				await $state.set(2);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-
-				await $state.set(2);
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(2);
-			});
-
-			it("should not call effect after effect is disposed", async () => {
-				const $state = state(1);
-				const effectFn = vi.fn();
-				const $effect = effect((t) => effectFn($state.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(1);
-
-				await $state.set(2);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-
-				$effect.dispose();
-
-				await $state.set(3);
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(2);
-			});
-
-			it("should support multiple effects depending on same state", async () => {
-				const $state = state(200);
-				const effectFn1 = vi.fn();
-				const effectFn2 = vi.fn();
-				const effectFn3 = vi.fn();
-
-				effect((t) => {
-					$state.get(t);
-					effectFn1();
-				});
-
-				effect((t) => {
-					$state.get(t);
-					effectFn2();
-				});
-
-				effect((t) => {
-					$state.get(t);
-					effectFn3();
-				});
-
-				await vi.waitFor(() => {
-					expect(effectFn1).toHaveBeenCalledTimes(1);
-					expect(effectFn2).toHaveBeenCalledTimes(1);
-					expect(effectFn3).toHaveBeenCalledTimes(1);
-				});
-
-				await $state.set(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 = state(10);
-				const $state2 = state(20);
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					const tracked = $state1.get(t);
-					const untracked = $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(11);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(11, 20);
-
-				// Changing state2 should not trigger effect (untracked)
-				await $state2.set(21);
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(2);
-			});
-
-			it("should support effect depending on multiple states", async () => {
-				const $stateA = state(5);
-				const $stateB = state(10);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					const a = $stateA.get(t);
-					const b = $stateB.get(t);
-					effectFn(a, b);
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(5, 10);
-
-				await $stateA.set(6);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(6, 10);
-
-				await $stateB.set(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 = state(400);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					$state.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-			});
-
-			it("should trigger re-runs when state changes after watch", async () => {
-				const $state = state(500);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					$state.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				await $state.set(600);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-			});
-		});
-
-		describe("subscribe", () => {
-			it("should create effect internally when subscribe is used", async () => {
-				const $state = state(700);
-				const listener = vi.fn();
-
-				$state.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(listener).toHaveBeenLastCalledWith(700);
-			});
-
-			it("should support multiple subscriptions with effects", async () => {
-				const $state = state(800);
-				const listener1 = vi.fn();
-				const listener2 = vi.fn();
-
-				$state.subscribe(listener1);
-				$state.subscribe(listener2);
-
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(1);
-					expect(listener2).toHaveBeenCalledTimes(1);
-				});
-
-				await $state.set(900);
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(2);
-					expect(listener2).toHaveBeenCalledTimes(2);
-				});
-			});
-
-			it("should dispose effect when disposer is called", async () => {
-				const $state = state(1000);
-				const listener = vi.fn();
-
-				const unsubscribe = $state.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				await $state.set(1100);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
-
-				unsubscribe();
-
-				await $state.set(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 = state(() => {
-						throw error;
-					});
-
-					const $effect = effect((t) => {
-						$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 = state(1);
-
-					$state.dispose();
-
-					const $effect = effect((t) => {
-						$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 = state(1300);
-				const effectFn = vi.fn();
-				const $effect = effect((t) => {
-					$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 = state(1400);
-				const effectFn = vi.fn();
-				const $effect = effect((t) => {
-					$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 = state(1500);
-				const effectFn = vi.fn();
-				const $effect = effect((t) => {
-					$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);
-				expect(() => $state.get($tracker)).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("complex cases", () => {
-			it("should handle nested states in effects", async () => {
-				const $stateA = state(1);
-				const $stateB = state(2);
-				const $stateC = state({
-					a: $stateA,
-					b: $stateB,
-				});
-
-				const effectFn = vi.fn();
-				effect((t) => {
-					const a = $stateC.get(t).a.get(t);
-					effectFn(a);
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(1);
-
-				await $stateA.set(3);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(3);
-			});
-
-			it("should handle effect depending on multiple states", async () => {
-				const $stateA = state(10);
-				const $stateB = state(20);
-				const $stateC = state(30);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					const a = $stateA.get(t);
-					const b = $stateB.get(t);
-					const c = $stateC.get(t);
-					effectFn(a, b, c);
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(10, 20, 30);
-
-				await $stateA.set(11);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(11, 20, 30);
-
-				await $stateB.set(21);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				expect(effectFn).toHaveBeenLastCalledWith(11, 21, 30);
-			});
-
-			it("should handle state chaining (state A -> state B -> state C)", async () => {
-				const $stateA = state(100);
-				const $stateB = state(200);
-				const $stateC = state(300);
-				const effectFn = vi.fn();
-
-				// Effect watches A, which triggers B, which triggers C
-				effect((t) => {
-					const a = $stateA.get(t);
-					if (a > 150) {
-						$stateB.set(250);
-					}
-				});
-
-				effect((t) => {
-					const b = $stateB.get(t);
-					if (b > 220) {
-						$stateC.set(350);
-					}
-				});
-
-				effect((t) => {
-					const c = $stateC.get(t);
-					effectFn(c);
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				await $stateA.set(200);
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-			});
-		});
-	});
-});