@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/nodes/async/flowConstantAsync.test.ts

@@ -1,860 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { constantAsync, effect, state } from "#package";
-
-describe("flowConstantAsync", () => {
-	describe("unit", () => {
-		describe("initialization", () => {
-			it("should initialize with direct Promise", async () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				expect(await $constant.pick()).toBe(1);
-			});
-
-			it("should initialize lazily with function", async () => {
-				const initFn = vi.fn(() => Promise.resolve(42));
-				const $constant = constantAsync(initFn);
-
-				// Function should not be called yet
-				expect(initFn).not.toHaveBeenCalled();
-
-				// First access triggers initialization
-				const value = await $constant.pick();
-				expect(value).toBe(42);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should not call lazy function on creation", () => {
-				const initFn = vi.fn(() => Promise.resolve(100));
-				constantAsync(initFn);
-
-				expect(initFn).not.toHaveBeenCalled();
-			});
-
-			it("should call lazy function on first access", async () => {
-				const initFn = vi.fn(() => Promise.resolve(200));
-				const $constant = constantAsync(initFn);
-
-				expect(initFn).not.toHaveBeenCalled();
-				await $constant.pick();
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should call lazy function only once", async () => {
-				const initFn = vi.fn(() => Promise.resolve(300));
-				const $constant = constantAsync(initFn);
-
-				// Multiple accesses should only call init once
-				await $constant.pick();
-				await $constant.pick();
-				await $constant.pick();
-
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should call lazy function only once", async () => {
-				const initFn = vi.fn(() => Promise.resolve(300));
-				const $constant = constantAsync(initFn);
-
-				// Multiple accesses should only call init once
-				$constant.pick();
-				$constant.pick();
-				$constant.pick();
-
-				await vi.waitFor(() => expect(initFn).toHaveBeenCalledTimes(1));
-			});
-
-			it("should cache Promise after lazy initialization", async () => {
-				const initFn = vi.fn(() => Promise.resolve("cached"));
-				const $constant = constantAsync(initFn);
-
-				const value1 = await $constant.pick();
-				const value2 = await $constant.pick();
-				const value3 = await $constant.pick();
-
-				expect(value1).toBe("cached");
-				expect(value2).toBe("cached");
-				expect(value3).toBe("cached");
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should handle number values", async () => {
-				const $constant = constantAsync(Promise.resolve(42));
-				expect(await $constant.pick()).toBe(42);
-			});
-
-			it("should handle string values", async () => {
-				const $constant = constantAsync(Promise.resolve("hello"));
-				expect(await $constant.pick()).toBe("hello");
-			});
-
-			it("should handle object values", async () => {
-				const obj = { a: 1, b: 2 };
-				const $constant = constantAsync(Promise.resolve(obj));
-				const value = await $constant.pick();
-				expect(value).toBe(obj);
-				expect(value).toEqual({ a: 1, b: 2 });
-			});
-
-			it("should handle array values", async () => {
-				const arr = [1, 2, 3];
-				const $constant = constantAsync(Promise.resolve(arr));
-				const value = await $constant.pick();
-				expect(value).toBe(arr);
-				expect(value).toEqual([1, 2, 3]);
-			});
-
-			it("should handle null values", async () => {
-				const $constant = constantAsync(Promise.resolve(null));
-				const value = await $constant.pick();
-				expect(value).toBeNull();
-			});
-
-			it("should handle undefined values", async () => {
-				const $constant = constantAsync(Promise.resolve(undefined));
-				const value = await $constant.pick();
-				expect(value).toBeUndefined();
-			});
-		});
-
-		describe("get", () => {
-			it("should return Promise with tracking context", async () => {
-				const $constant = constantAsync(Promise.resolve(5));
-				const $tracker = state(0); // Use state as FlowTracker
-				const promise = $constant.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(10));
-				const $constant = constantAsync(initFn);
-				const $tracker = state(0);
-
-				expect(initFn).not.toHaveBeenCalled();
-				const promise = $constant.get($tracker);
-				expect(promise).toBeInstanceOf(Promise);
-				const value = await promise;
-				expect(value).toBe(10);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should return cached Promise on subsequent get calls", async () => {
-				const initFn = vi.fn(() => Promise.resolve(20));
-				const $constant = constantAsync(initFn);
-				const $tracker = state(0);
-
-				const promise1 = $constant.get($tracker);
-				const promise2 = $constant.get($tracker);
-				const promise3 = $constant.get($tracker);
-
-				// All should be the same Promise instance (cached)
-				// expect(promise 1).toBe(promise2);
-				// expect(promise2).toBe(promise3);
-
-				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 await Promise to get value", async () => {
-				const $constant = constantAsync(Promise.resolve(25));
-				const $tracker = state(0);
-
-				const promise = $constant.get($tracker);
-				const value = await promise;
-				expect(value).toBe(25);
-			});
-
-			it("should throw error when get is called after disposal", async () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				const $tracker = state(0);
-
-				await $constant.get($tracker);
-				$constant.dispose();
-
-				await expect($constant.get($tracker)).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("pick", () => {
-			it("should return Promise without tracking", async () => {
-				const $constant = constantAsync(Promise.resolve(15));
-				const promise = $constant.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 $constant = constantAsync(initFn);
-
-				expect(initFn).not.toHaveBeenCalled();
-				const promise = $constant.pick();
-				expect(promise).toBeInstanceOf(Promise);
-				const value = await promise;
-				expect(value).toBe(25);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should return cached Promise on subsequent pick calls", async () => {
-				const initFn = vi.fn(() => Promise.resolve(30));
-				const $constant = constantAsync(initFn);
-
-				const promise1 = $constant.pick();
-				const promise2 = $constant.pick();
-				const promise3 = $constant.pick();
-
-				const value1 = await promise1;
-				const value2 = await promise2;
-				const value3 = await promise3;
-
-				expect(value1).toBe(30);
-				expect(value2).toBe(30);
-				expect(value3).toBe(30);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should await Promise to get value", async () => {
-				const $constant = constantAsync(Promise.resolve(35));
-				const value = await $constant.pick();
-				expect(value).toBe(35);
-			});
-
-			it("should throw error when pick is called after disposal", async () => {
-				const $constant = constantAsync(Promise.resolve(1));
-
-				expect(await $constant.pick()).toBe(1);
-
-				$constant.dispose();
-
-				await expect($constant.pick()).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("watch", () => {
-			it("should register dependency when watch is called", () => {
-				const $constant = constantAsync(Promise.resolve(35));
-				const $tracker = state(0);
-
-				expect(() => $constant.watch($tracker)).not.toThrow();
-			});
-
-			it("should compute lazy value when watch is called", async () => {
-				const initFn = vi.fn(() => Promise.resolve(40));
-				const $constant = constantAsync(initFn);
-				const $tracker = state(0);
-
-				expect(initFn).not.toHaveBeenCalled();
-				$constant.watch($tracker);
-				expect(initFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should throw error when watch is called after disposal", async () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				const $tracker = state(0);
-
-				await $constant.watch($tracker);
-				$constant.dispose();
-
-				await expect($constant.watch($tracker)).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("subscribe", () => {
-			it("should return a disposer function", () => {
-				const $constant = constantAsync(Promise.resolve(50));
-				const listener = vi.fn();
-				const disposer = $constant.subscribe(listener);
-
-				expect(typeof disposer).toBe("function");
-			});
-
-			it("should call listener immediately with Promise<T>", async () => {
-				const $constant = constantAsync(Promise.resolve(55));
-				const listener = vi.fn();
-
-				$constant.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(listener).toHaveBeenCalledTimes(1);
-
-				// Listener receives Promise<T>, not T
-				const receivedPromise = listener.mock.calls[0][0];
-				expect(receivedPromise).toBeInstanceOf(Promise);
-				const value = await receivedPromise;
-				expect(value).toBe(55);
-			});
-
-			it("should require listener to await Promise to get value", async () => {
-				const $constant = constantAsync(Promise.resolve(60));
-				const listener = vi.fn(async (promise) => {
-					const value = await promise;
-					return value;
-				});
-
-				$constant.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				const result = await listener.mock.results[0].value;
-				expect(result).toBe(60);
-			});
-
-			it("should not call listener after constant disposal", async () => {
-				const $constant = constantAsync(Promise.resolve(65));
-				const listener = vi.fn();
-
-				$constant.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				$constant.dispose();
-
-				// Wait to ensure listener is not called again
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-
-			it("should not call listener after disposer is called", async () => {
-				const $constant = constantAsync(Promise.resolve(70));
-				const listener = vi.fn();
-
-				const disposer = $constant.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				disposer();
-
-				// Wait to ensure listener is not called again
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-
-			it("should support multiple subscriptions", async () => {
-				const $constant = constantAsync(Promise.resolve(75));
-				const listener1 = vi.fn();
-				const listener2 = vi.fn();
-				const listener3 = vi.fn();
-
-				$constant.subscribe(listener1);
-				$constant.subscribe(listener2);
-				$constant.subscribe(listener3);
-
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(1);
-					expect(listener2).toHaveBeenCalledTimes(1);
-					expect(listener3).toHaveBeenCalledTimes(1);
-				});
-
-				// All listeners receive the same Promise instance
-				const promise1 = listener1.mock.calls[0][0];
-				const promise2 = listener2.mock.calls[0][0];
-				const promise3 = listener3.mock.calls[0][0];
-
-				const value1 = await promise1;
-				const value2 = await promise2;
-				const value3 = await promise3;
-				expect(value1).toBe(75);
-				expect(value2).toBe(75);
-				expect(value3).toBe(75);
-			});
-
-			it("should throw error when subscribe is called after disposal", () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				const listener = vi.fn();
-
-				$constant.dispose();
-
-				expect(() => $constant.subscribe(listener)).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("trigger", () => {
-			it("should return a Promise", () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				const result = $constant.trigger();
-				expect(result).toBeInstanceOf(Promise);
-			});
-
-			it("should throw error when trigger is called after disposal", async () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				$constant.dispose();
-				await expect($constant.trigger()).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should allow multiple triggers", async () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				const promise1 = $constant.trigger();
-				const promise2 = $constant.trigger();
-				const promise3 = $constant.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 $constant = constantAsync(Promise.resolve(1));
-				expect($constant.disposed).toBe(false);
-			});
-
-			it("should have disposed property set to true after disposal", () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				$constant.dispose();
-				expect($constant.disposed).toBe(true);
-			});
-
-			it("should throw error when disposed twice", () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				$constant.dispose();
-				expect(() => $constant.dispose()).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should accept self option without throwing", () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				expect(() => $constant.dispose({ self: true })).not.toThrow();
-				expect($constant.disposed).toBe(true);
-			});
-
-			it("should accept default options without throwing", () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				expect(() => $constant.dispose()).not.toThrow();
-				expect($constant.disposed).toBe(true);
-			});
-		});
-
-		describe("special cases", () => {
-			it("should handle lazy function using closure to capture values", async () => {
-				let externalValue = 10;
-				const $constant = constantAsync(() =>
-					Promise.resolve(externalValue * 2),
-				);
-
-				const value1 = await $constant.pick();
-				expect(value1).toBe(20);
-
-				// Changing external value should not affect constant (it's cached)
-				externalValue = 20;
-				const value2 = await $constant.pick();
-				expect(value2).toBe(20);
-			});
-
-			it("should handle Promise that rejects", async () => {
-				const error = new Error("Promise rejected");
-				const $constant = constantAsync(Promise.reject(error));
-
-				await expect($constant.pick()).rejects.toThrow("Promise rejected");
-			});
-
-			it("should handle lazy function that rejects", async () => {
-				const error = new Error("Lazy function rejected");
-				const $constant = constantAsync(() => Promise.reject(error));
-
-				await expect($constant.pick()).rejects.toThrow(
-					"Lazy function rejected",
-				);
-			});
-
-			it("should handle Promise that resolves to null", async () => {
-				const $constant = constantAsync(Promise.resolve(null));
-				const value = await $constant.pick();
-				expect(value).toBeNull();
-			});
-
-			it("should handle Promise that resolves to undefined", async () => {
-				const $constant = constantAsync(Promise.resolve(undefined));
-				const value = await $constant.pick();
-				expect(value).toBeUndefined();
-			});
-
-			it("should handle complex object values in Promise", async () => {
-				const complexObj = {
-					nested: { deep: { value: 42 } },
-					array: [1, 2, 3],
-				};
-				const $constant = constantAsync(Promise.resolve(complexObj));
-				const value = await $constant.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", async () => {
-					const error = new Error("Compute error");
-					const $constant = constantAsync(Promise.reject<never>(error));
-
-					await expect($constant.pick()).rejects.toThrow("Compute error");
-				});
-
-				it("should propagate error when get is called with a rejecting Promise", async () => {
-					const error = new Error("Get error");
-					const $constant = constantAsync(Promise.reject<never>(error));
-
-					await expect($constant.get(state(0))).rejects.toThrow("Get error");
-				});
-
-				it("should propagate error when get is called and lazy function rejects", async () => {
-					const error = new Error("Lazy function rejected");
-					const $constant = constantAsync(() => Promise.reject<never>(error));
-
-					await expect($constant.get(state(0))).rejects.toThrow(
-						"Lazy function rejected",
-					);
-				});
-			});
-
-			describe("disposed constant", () => {
-				it("should throw error when pick is called after disposal", async () => {
-					const $constant = constantAsync(Promise.resolve(1));
-
-					$constant.dispose();
-
-					await expect($constant.pick()).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when get is called after disposal", async () => {
-					const $constant = constantAsync(Promise.resolve(1));
-					const $tracker = state(0);
-
-					await $constant.dispose();
-
-					await expect($constant.get($tracker)).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-			});
-		});
-
-		describe("error handling", () => {
-			describe("compute function errors", () => {
-				it("should propagate error when used inside an async effect", async () => {
-					const error = new Error("Effect compute error");
-					const $constant = constantAsync(() => Promise.reject<never>(error));
-
-					const $effect = effect(async (t) => {
-						await $constant.get(t);
-					});
-
-					await expect($effect.settled).rejects.toThrow("Effect compute error");
-				});
-			});
-
-			describe("disposed constant", () => {
-				it("should throw error when creating an effect with a disposed async constant", async () => {
-					const $constant = constantAsync(Promise.resolve(1));
-
-					$constant.dispose();
-
-					const $effect = effect(async (t) => {
-						await $constant.get(t);
-					});
-
-					await expect($effect.settled).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-			});
-		});
-	});
-
-	describe("with effect", () => {
-		describe("get", () => {
-			it("should create reactive dependency when get is used in effect", async () => {
-				const $constant = constantAsync(Promise.resolve(100));
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					await $constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-			});
-
-			it("should call effect with initial value", async () => {
-				const $constant = constantAsync(Promise.resolve(1));
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $constant.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(1);
-			});
-
-			it("should call effect with lazy init value", async () => {
-				const $constant = constantAsync(() => Promise.resolve(1));
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $constant.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(1);
-			});
-
-			it("should await Promise returned by get() in effect", async () => {
-				const $constant = constantAsync(Promise.resolve(200));
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					const promise = $constant.get(t);
-					expect(promise).toBeInstanceOf(Promise);
-					const value = await promise;
-					effectFn(value);
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(200);
-			});
-
-			it("should not re-execute effect when constant value does not change", async () => {
-				const $constant = constantAsync(Promise.resolve(300));
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					await $constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				// Wait to ensure effect doesn't re-run (constant is immutable)
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should not re-execute effect when async constant value is immutable (closure)", async () => {
-				let capturedValue = 5;
-				const $constant = constantAsync(() =>
-					Promise.resolve(capturedValue * 3),
-				);
-
-				const effectFn = vi.fn();
-				effect(async (t) => {
-					const value = await $constant.get(t);
-					effectFn(value);
-				});
-
-				// Initial execution with computed value (5 * 3 = 15)
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(15);
-
-				// Change captured value - constant is cached, so effect should not re-run
-				capturedValue = 10;
-				await new Promise((resolve) => setTimeout(resolve, 50));
-
-				// Effect should not re-run because constant is immutable and cached
-				expect(effectFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should support multiple effects depending on same constant", async () => {
-				const $constant = constantAsync(Promise.resolve(400));
-				const effectFn1 = vi.fn();
-				const effectFn2 = vi.fn();
-				const effectFn3 = vi.fn();
-
-				effect(async (t) => {
-					await $constant.get(t);
-					effectFn1();
-				});
-
-				effect(async (t) => {
-					await $constant.get(t);
-					effectFn2();
-				});
-
-				effect(async (t) => {
-					await $constant.get(t);
-					effectFn3();
-				});
-
-				await vi.waitFor(() => {
-					expect(effectFn1).toHaveBeenCalledTimes(1);
-					expect(effectFn2).toHaveBeenCalledTimes(1);
-					expect(effectFn3).toHaveBeenCalledTimes(1);
-				});
-			});
-
-			it("should support effect with tracked and untracked get mixed", async () => {
-				const $constant1 = constantAsync(Promise.resolve(10));
-				const $constant2 = constantAsync(Promise.resolve(20));
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					const tracked = await $constant1.get(t);
-					const untracked = await $constant2.get(null);
-					effectFn(tracked, untracked);
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(10, 20);
-			});
-		});
-
-		describe("watch", () => {
-			it("should register dependency when watch is used in effect", async () => {
-				const $constant = constantAsync(Promise.resolve(500));
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					$constant.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-			});
-
-			it("should not trigger re-runs when constant is watched (immutable)", async () => {
-				const $constant = constantAsync(Promise.resolve(600));
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					$constant.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				// Wait to ensure effect doesn't re-run
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(1);
-			});
-		});
-
-		describe("subscribe", () => {
-			it("should create effect internally when subscribe is used", async () => {
-				const $constant = constantAsync(Promise.resolve(700));
-				const listener = vi.fn();
-
-				$constant.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(listener).toHaveBeenCalledTimes(1);
-
-				// Listener receives Promise<T>
-				const receivedPromise = listener.mock.calls[0][0];
-				expect(receivedPromise).toBeInstanceOf(Promise);
-			});
-
-			it("should require listener to await Promise", async () => {
-				const $constant = constantAsync(Promise.resolve(800));
-				const listener = vi.fn(async (promise) => {
-					const value = await promise;
-					expect(value).toBe(800);
-				});
-
-				$constant.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-			});
-
-			it("should support multiple subscriptions with effects", async () => {
-				const $constant = constantAsync(Promise.resolve(900));
-				const listener1 = vi.fn();
-				const listener2 = vi.fn();
-
-				$constant.subscribe(listener1);
-				$constant.subscribe(listener2);
-
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(1);
-					expect(listener2).toHaveBeenCalledTimes(1);
-				});
-			});
-
-			it("should dispose effect when disposer is called", async () => {
-				const $constant = constantAsync(Promise.resolve(1000));
-				const listener = vi.fn();
-
-				const unsubscribe = $constant.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				unsubscribe();
-
-				// Wait to ensure listener is not called again
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-		});
-
-		describe("disposal", () => {
-			it("should dispose effects when constant is disposed", async () => {
-				const $constant = constantAsync(Promise.resolve(1100));
-				const effectFn = vi.fn();
-				const $effect = effect(async (t) => {
-					await $constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect($effect.disposed).toBe(false);
-
-				$constant.dispose();
-
-				expect($effect.disposed).toBe(true);
-			});
-
-			it("should not dispose effects when constant is disposed with self option", async () => {
-				const $constant = constantAsync(Promise.resolve(1200));
-				const effectFn = vi.fn();
-				const $effect = effect(async (t) => {
-					await $constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect($effect.disposed).toBe(false);
-
-				$constant.dispose({ self: true });
-
-				expect($effect.disposed).toBe(false);
-				expect($constant.disposed).toBe(true);
-			});
-
-			it("should unregister effects when constant is disposed with self option", async () => {
-				const $constant = constantAsync(Promise.resolve(1300));
-				const effectFn = vi.fn();
-				const $effect = effect(async (t) => {
-					await $constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				$constant.dispose({ self: true });
-
-				// Effect should still be active but not notified
-				expect($effect.disposed).toBe(false);
-
-				// But constant is disposed so operations should fail
-				const $tracker = state(0);
-				await expect($constant.get($tracker)).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-	});
-});