@ersbeth/picoflow 1.1.2 → 2.0.0

package/test/collections/flowMap.asyncStates.test.ts

@@ -1,1105 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-	effect,
-	FlowGraph,
-	type FlowStateAsync,
-	map,
-	stateAsync,
-} from "#package";
-
-describe("FlowMap", () => {
-	describe("unit", () => {
-		describe("initialization", () => {
-			it("should initialize with provided Record of FlowStateAsync values", async () => {
-				const $map = map({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-					key3: stateAsync(Promise.resolve(3)),
-				});
-
-				const values = await Promise.all(
-					Array.from((await $map.pick()).entries()).map(
-						async ([_, value]) => await value.pick(),
-					),
-				);
-
-				expect(values).toEqual([1, 2, 3]);
-			});
-
-			it("should initialize with provided Map of FlowStateAsync values", async () => {
-				const $value1 = stateAsync(Promise.resolve(1));
-				const $value2 = stateAsync(Promise.resolve(2));
-				const initialMap = new Map([
-					["key1", $value1],
-					["key2", $value2],
-				]);
-				const $map = map(initialMap);
-
-				expect(Array.from((await $map.pick()).entries())).toEqual([
-					["key1", $value1],
-					["key2", $value2],
-				]);
-			});
-
-			it("should initialize with empty map when no value provided", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-
-				expect(Array.from((await $map.pick()).entries())).toEqual([]);
-				expect((await $map.pick()).size).toBe(0);
-			});
-
-			it("should initialize $lastAction with set action on creation", async () => {
-				const $value1 = stateAsync(Promise.resolve(1));
-				const $value2 = stateAsync(Promise.resolve(2));
-				const $map = map({
-					key1: $value1,
-					key2: $value2,
-				});
-				const action = await $map.$lastAction.pick();
-				expect(action.type).toBe("set");
-				if (action.type === "set") {
-					expect(action.map.size).toBe(2);
-					expect(action.map.get("key1")).toBe($value1);
-					expect(action.map.get("key2")).toBe($value2);
-				}
-			});
-
-			it("should initialize $lastAction with empty map when no value provided", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const action = await $map.$lastAction.pick();
-				expect(action.type).toBe("set");
-				if (action.type === "set") {
-					expect(action.map.size).toBe(0);
-				}
-			});
-		});
-
-		describe("disposal", () => {
-			it("should have disposed property set to false initially and true after disposal", () => {
-				const $map = map({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-				});
-				expect($map.disposed).toBe(false);
-				$map.dispose();
-				expect($map.disposed).toBe(true);
-			});
-
-			it("should throw error when disposed twice", () => {
-				const $map = map({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-				});
-				$map.dispose();
-				expect(() => $map.dispose()).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should throw when pick is called after disposal", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-					key3: stateAsync(Promise.resolve(3)),
-				});
-				$map.dispose();
-				await expect($map.pick()).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should throw when set is called after disposal", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-				});
-				$map.dispose();
-				await expect(
-					$map.set(new Map([["key2", stateAsync(Promise.resolve(2))]])),
-				).rejects.toThrow("[PicoFlow] Primitive is disposed");
-			});
-
-			it("should throw when add is called after disposal", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				$map.dispose();
-				await expect(
-					$map.add("key1", stateAsync(Promise.resolve(2))),
-				).rejects.toThrow("[PicoFlow] Primitive is disposed");
-			});
-
-			it("should throw when update is called after disposal", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				$map.dispose();
-				await expect(
-					$map.update("key1", stateAsync(Promise.resolve(2))),
-				).rejects.toThrow("[PicoFlow] Primitive is disposed");
-			});
-
-			it("should throw when delete is called after disposal", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-					key3: stateAsync(Promise.resolve(3)),
-				});
-				$map.dispose();
-				await expect($map.delete("key1")).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should throw when clear is called after disposal", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-				});
-				$map.dispose();
-				await expect($map.clear()).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should dispose values when FlowMap is disposed", () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const $value1 = stateAsync(Promise.resolve(1));
-				const $value2 = stateAsync(Promise.resolve(2));
-				const $value3 = stateAsync(Promise.resolve(3));
-
-				$map.add("key1", $value1);
-				$map.add("key2", $value2);
-				$map.add("key3", $value3);
-
-				expect($value1.disposed).toBe(false);
-				expect($value2.disposed).toBe(false);
-				expect($value3.disposed).toBe(false);
-
-				$map.dispose();
-
-				expect($value1.disposed).toBe(true);
-				expect($value2.disposed).toBe(true);
-				expect($value3.disposed).toBe(true);
-			});
-
-			it("should dispose values with provided options when FlowMap is disposed", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const $value1 = stateAsync(Promise.resolve(1));
-				const $value2 = stateAsync(Promise.resolve(2));
-
-				$map.add("key1", $value1);
-				$map.add("key2", $value2);
-
-				const $effect = effect(async (t) => {
-					await $value1.get(t);
-				});
-
-				await $effect.settled;
-
-				expect($effect.disposed).toBe(false);
-
-				$map.dispose({ self: true });
-
-				expect($value1.disposed).toBe(true);
-				expect($value2.disposed).toBe(true);
-				expect($effect.disposed).toBe(false);
-
-				$effect.dispose();
-			});
-
-			it("should handle non-disposable values gracefully", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				await $map.add("key2", stateAsync(Promise.resolve(2)));
-				await $map.add("key3", stateAsync(Promise.resolve(3)));
-
-				expect((await $map.pick()).size).toBe(3);
-
-				expect(() => $map.dispose()).not.toThrow();
-			});
-		});
-
-		describe("set", () => {
-			it("should replace entire map when set is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-				});
-				const $newValue1 = stateAsync(Promise.resolve(3));
-				const $newValue2 = stateAsync(Promise.resolve(4));
-				const newMap = new Map([
-					["key3", $newValue1],
-					["key4", $newValue2],
-				]);
-
-				await $map.set(newMap);
-				expect(Array.from((await $map.pick()).entries())).toEqual([
-					["key3", $newValue1],
-					["key4", $newValue2],
-				]);
-			});
-
-			it("should dispose values when set replaces map", async () => {
-				const $oldValue1 = stateAsync(Promise.resolve(1));
-				const $oldValue2 = stateAsync(Promise.resolve(2));
-				const $map = map(
-					new Map([
-						["key1", $oldValue1],
-						["key2", $oldValue2],
-					]),
-				);
-
-				expect($oldValue1.disposed).toBe(false);
-				expect($oldValue2.disposed).toBe(false);
-
-				await $map.set(
-					new Map([
-						["key3", stateAsync(Promise.resolve(3))],
-						["key4", stateAsync(Promise.resolve(4))],
-					]),
-				);
-
-				expect($oldValue1.disposed).toBe(true);
-				expect($oldValue2.disposed).toBe(true);
-			});
-
-			it("should dispose values with self option when set replaces map", async () => {
-				const $oldValue = stateAsync(Promise.resolve(1));
-				const $map = map(new Map([["key1", $oldValue]]));
-
-				const $effect = effect(async (t) => {
-					await $oldValue.get(t);
-				});
-
-				expect($effect.disposed).toBe(false);
-
-				await $map.set(new Map([["key2", stateAsync(Promise.resolve(2))]]));
-
-				expect($oldValue.disposed).toBe(true);
-				expect($effect.disposed).toBe(false);
-
-				$effect.dispose();
-			});
-
-			it("should update $lastAction with set action when set is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-				});
-				const $newValue1 = stateAsync(Promise.resolve(3));
-				const $newValue2 = stateAsync(Promise.resolve(4));
-				const newMap = new Map([
-					["key3", $newValue1],
-					["key4", $newValue2],
-				]);
-
-				await $map.set(newMap);
-				const action = await $map.$lastAction.pick();
-				expect(action).toEqual({
-					type: "set",
-					map: newMap,
-				});
-			});
-		});
-
-		describe("add", () => {
-			it("should add key-value pair to map", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				expect(await (await $map.pick()).get("key1")?.pick()).toBe(1);
-				expect((await $map.pick()).size).toBe(1);
-			});
-
-			it("should add multiple keys successively", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				await $map.add("key2", stateAsync(Promise.resolve(2)));
-				await $map.add("key3", stateAsync(Promise.resolve(3)));
-
-				expect((await $map.pick()).size).toBe(3);
-				expect(await (await $map.pick()).get("key1")?.pick()).toBe(1);
-				expect(await (await $map.pick()).get("key2")?.pick()).toBe(2);
-				expect(await (await $map.pick()).get("key3")?.pick()).toBe(3);
-			});
-
-			it("should throw when key already exists", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				await expect(
-					$map.add("key1", stateAsync(Promise.resolve(2))),
-				).rejects.toThrow("[PicoFlow] Key already exists");
-			});
-
-			it("should update $lastAction with add action when add is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const $value = stateAsync(Promise.resolve(1));
-				await $map.add("key1", $value);
-				const action = await $map.$lastAction.pick();
-				expect(action).toEqual({
-					type: "add",
-					key: "key1",
-					value: $value,
-				});
-			});
-
-			it("should have FlowStateAsync value in $lastAction when add is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const $value = stateAsync(Promise.resolve(100));
-				await $map.add("key1", $value);
-				const action = await $map.$lastAction.pick();
-				expect(action.type).toBe("add");
-				if (action.type === "add") {
-					expect(action.value).toBe($value);
-					expect(await action.value.pick()).toBe(100);
-				}
-			});
-
-			it("should trigger reactivity when add is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $map.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-			});
-		});
-
-		describe("update", () => {
-			it("should update existing key-value pair", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-
-				const $newValue = stateAsync(Promise.resolve(2));
-				await $map.update("key1", $newValue);
-				expect(await (await $map.pick()).get("key1")?.pick()).toBe(2);
-			});
-
-			it("should update multiple keys successively", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				await $map.add("key2", stateAsync(Promise.resolve(2)));
-
-				await $map.update("key1", stateAsync(Promise.resolve(10)));
-				await $map.update("key2", stateAsync(Promise.resolve(20)));
-
-				expect(await (await $map.pick()).get("key1")?.pick()).toBe(10);
-				expect(await (await $map.pick()).get("key2")?.pick()).toBe(20);
-			});
-
-			it("should throw when key does not exist", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await expect(
-					$map.update("key1", stateAsync(Promise.resolve(1))),
-				).rejects.toThrow("[PicoFlow] Key does not exist");
-			});
-
-			it("should update $lastAction with update action when update is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				const $newValue = stateAsync(Promise.resolve(2));
-				await $map.update("key1", $newValue);
-				const action = await $map.$lastAction.pick();
-				expect(action).toEqual({
-					type: "update",
-					key: "key1",
-					value: $newValue,
-				});
-			});
-
-			it("should have FlowStateAsync value in $lastAction when update is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				const $newValue = stateAsync(Promise.resolve(200));
-				await $map.update("key1", $newValue);
-				const action = await $map.$lastAction.pick();
-				expect(action.type).toBe("update");
-				if (action.type === "update") {
-					expect(action.value).toBe($newValue);
-					expect(await action.value.pick()).toBe(200);
-				}
-			});
-
-			it("should dispose old value when update is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const $oldValue = stateAsync(Promise.resolve(1));
-				await $map.add("key1", $oldValue);
-
-				const $newValue = stateAsync(Promise.resolve(2));
-				await $map.update("key1", $newValue);
-
-				expect($oldValue.disposed).toBe(true);
-				expect($newValue.disposed).toBe(false);
-			});
-
-			it("should trigger reactivity when update is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $map.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				await $map.update("key1", stateAsync(Promise.resolve(2)));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-			});
-		});
-
-		describe("delete", () => {
-			it("should delete key from map", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				await $map.add("key2", stateAsync(Promise.resolve(2)));
-
-				await $map.delete("key1");
-				expect(await (await $map.pick()).get("key1")?.pick()).toBe(undefined);
-				expect(await (await $map.pick()).get("key2")?.pick()).toBe(2);
-				expect((await $map.pick()).size).toBe(1);
-			});
-
-			it("should delete multiple keys successively", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				await $map.add("key2", stateAsync(Promise.resolve(2)));
-				await $map.add("key3", stateAsync(Promise.resolve(3)));
-
-				await $map.delete("key1");
-				await $map.delete("key2");
-
-				expect((await $map.pick()).size).toBe(1);
-				expect(await (await $map.pick()).get("key3")?.pick()).toBe(3);
-			});
-
-			it("should throw when key does not exist", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await expect($map.delete("key1")).rejects.toThrow(
-					"[PicoFlow] Key does not exist",
-				);
-			});
-
-			it("should update $lastAction with delete action when delete is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const $value = stateAsync(Promise.resolve(1));
-				await $map.add("key1", $value);
-				await $map.delete("key1");
-				const action = await $map.$lastAction.pick();
-				expect(action.type).toBe("delete");
-				if (action.type === "delete") {
-					expect(action.key).toBe("key1");
-					expect(action.value).toBe($value);
-				}
-			});
-
-			it("should have disposed FlowStateAsync value in $lastAction when delete is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				const $value = stateAsync(Promise.resolve(300));
-				await $map.add("key1", $value);
-				await $map.delete("key1");
-				const action = await $map.$lastAction.pick();
-				expect(action.type).toBe("delete");
-				if (action.type === "delete") {
-					expect(action.value).toBe($value);
-					expect(action.value.disposed).toBe(true);
-				}
-			});
-
-			it("should dispose value with self option when delete is called", async () => {
-				const $value = stateAsync(Promise.resolve(1));
-				const $map = map(new Map([["key1", $value]]));
-
-				const $effect = effect(async (t) => {
-					await $value.get(t);
-				});
-
-				expect($effect.disposed).toBe(false);
-
-				await $map.delete("key1");
-
-				expect($value.disposed).toBe(true);
-				expect($effect.disposed).toBe(false);
-
-				$effect.dispose();
-			});
-
-			it("should trigger reactivity when delete is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				const effectFn = vi.fn();
-				effect(async (t) => effectFn(await $map.get(t)));
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				await $map.delete("key1");
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-			});
-		});
-
-		describe("clear", () => {
-			it("should remove all entries from map", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-					key3: stateAsync(Promise.resolve(3)),
-				});
-				expect((await $map.pick()).size).toBe(3);
-
-				await $map.clear();
-				expect((await $map.pick()).size).toBe(0);
-			});
-
-			it("should dispose all values when clear is called", async () => {
-				const $value1 = stateAsync(Promise.resolve(1));
-				const $value2 = stateAsync(Promise.resolve(2));
-				const $value3 = stateAsync(Promise.resolve(3));
-				const $map = map(
-					new Map([
-						["key1", $value1],
-						["key2", $value2],
-						["key3", $value3],
-					]),
-				);
-
-				expect($value1.disposed).toBe(false);
-				expect($value2.disposed).toBe(false);
-				expect($value3.disposed).toBe(false);
-
-				await $map.clear();
-
-				expect($value1.disposed).toBe(true);
-				expect($value2.disposed).toBe(true);
-				expect($value3.disposed).toBe(true);
-			});
-
-			it("should dispose values with self option when clear is called", async () => {
-				const $value = stateAsync(Promise.resolve(1));
-				const $map = map(
-					new Map([
-						["key1", $value],
-						["key2", stateAsync(Promise.resolve(2))],
-					]),
-				);
-
-				const $effect = effect(async (t) => {
-					await $value.get(t);
-				});
-
-				expect($effect.disposed).toBe(false);
-
-				await $map.clear();
-
-				expect($value.disposed).toBe(true);
-				expect($effect.disposed).toBe(false);
-
-				$effect.dispose();
-			});
-
-			it("should update $lastAction with clear action when clear is called", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-					key2: stateAsync(Promise.resolve(2)),
-				});
-				await $map.clear();
-				const action = await $map.$lastAction.pick();
-				expect(action).toEqual({ type: "clear" });
-			});
-		});
-
-		describe("$lastAction", () => {
-			describe("set action", () => {
-				it("should initialize $lastAction with set action on creation", async () => {
-					const $value1 = stateAsync(Promise.resolve(1));
-					const $value2 = stateAsync(Promise.resolve(2));
-					const $map = map({
-						key1: $value1,
-						key2: $value2,
-					});
-					const action = await $map.$lastAction.pick();
-					expect(action).toEqual({
-						type: "set",
-						map: expect.any(Map),
-					});
-					if (action.type === "set") {
-						expect(action.map.get("key1")).toBe($value1);
-						expect(action.map.get("key2")).toBe($value2);
-					}
-				});
-
-				it("should update $lastAction with set action when set is called", async () => {
-					const $map = map<string, FlowStateAsync<number>>({
-						key1: stateAsync(Promise.resolve(1)),
-					});
-					const $newValue = stateAsync(Promise.resolve(2));
-					const newMap = new Map([["key2", $newValue]]);
-					await $map.set(newMap);
-					const action = await $map.$lastAction.pick();
-					expect(action).toEqual({
-						type: "set",
-						map: newMap,
-					});
-				});
-
-				it("should have correct structure for set action (type + map with FlowStateAsync)", async () => {
-					const $value = stateAsync(Promise.resolve(1));
-					const $map = map({ key1: $value });
-					const action = await $map.$lastAction.pick();
-					expect(action).toHaveProperty("type", "set");
-					if (action.type === "set") {
-						expect(action).toHaveProperty("map");
-						expect(action.map).toBeInstanceOf(Map);
-						expect(action.map.get("key1")).toBe($value);
-					}
-				});
-			});
-
-			describe("add action", () => {
-				it("should update $lastAction with add action when add is called", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					const $value = stateAsync(Promise.resolve(1));
-					await $map.add("key1", $value);
-					const action = await $map.$lastAction.pick();
-					expect(action).toEqual({
-						type: "add",
-						key: "key1",
-						value: $value,
-					});
-				});
-
-				it("should have correct structure for add action (type + key + FlowStateAsync value)", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					const $value = stateAsync(Promise.resolve(100));
-					await $map.add("key1", $value);
-					const action = await $map.$lastAction.pick();
-					expect(action).toHaveProperty("type", "add");
-					if (action.type === "add") {
-						expect(action).toHaveProperty("key");
-						expect(action).toHaveProperty("value");
-						expect(action.key).toBe("key1");
-						expect(action.value).toBe($value);
-						expect(await action.value.pick()).toBe(100);
-					}
-				});
-			});
-
-			describe("update action", () => {
-				it("should update $lastAction with update action when update is called", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					await $map.add("key1", stateAsync(Promise.resolve(1)));
-					const $newValue = stateAsync(Promise.resolve(2));
-					await $map.update("key1", $newValue);
-					const action = await $map.$lastAction.pick();
-					expect(action).toEqual({
-						type: "update",
-						key: "key1",
-						value: $newValue,
-					});
-				});
-
-				it("should have correct structure for update action (type + key + FlowStateAsync value)", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					await $map.add("key1", stateAsync(Promise.resolve(1)));
-					const $newValue = stateAsync(Promise.resolve(200));
-					await $map.update("key1", $newValue);
-					const action = await $map.$lastAction.pick();
-					expect(action).toHaveProperty("type", "update");
-					if (action.type === "update") {
-						expect(action).toHaveProperty("key");
-						expect(action).toHaveProperty("value");
-						expect(action.key).toBe("key1");
-						expect(action.value).toBe($newValue);
-						expect(await action.value.pick()).toBe(200);
-					}
-				});
-			});
-
-			describe("delete action", () => {
-				it("should update $lastAction with delete action when delete is called", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					const $value = stateAsync(Promise.resolve(1));
-					await $map.add("key1", $value);
-					await $map.delete("key1");
-					const action = await $map.$lastAction.pick();
-					expect(action).toEqual({
-						type: "delete",
-						key: "key1",
-						value: $value,
-					});
-				});
-
-				it("should have correct structure for delete action (type + key + disposed FlowStateAsync value)", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					const $value = stateAsync(Promise.resolve(300));
-					await $map.add("key1", $value);
-					await $map.delete("key1");
-					const action = await $map.$lastAction.pick();
-					expect(action).toHaveProperty("type", "delete");
-					if (action.type === "delete") {
-						expect(action).toHaveProperty("key");
-						expect(action).toHaveProperty("value");
-						expect(action.key).toBe("key1");
-						expect(action.value).toBe($value);
-						expect(action.value.disposed).toBe(true);
-					}
-				});
-			});
-
-			describe("clear action", () => {
-				it("should update $lastAction with clear action when clear is called", async () => {
-					const $map = map<string, FlowStateAsync<number>>({
-						key1: stateAsync(Promise.resolve(1)),
-						key2: stateAsync(Promise.resolve(2)),
-					});
-					await $map.clear();
-					const action = await $map.$lastAction.pick();
-					expect(action).toEqual({
-						type: "clear",
-					});
-				});
-
-				it("should have correct structure for clear action (type only)", async () => {
-					const $map = map<string, FlowStateAsync<number>>({
-						key1: stateAsync(Promise.resolve(1)),
-					});
-					await $map.clear();
-					const action = await $map.$lastAction.pick();
-					expect(action).toHaveProperty("type", "clear");
-					if (action.type === "clear") {
-						expect(action).not.toHaveProperty("key");
-						expect(action).not.toHaveProperty("value");
-						expect(action).not.toHaveProperty("map");
-					}
-				});
-			});
-		});
-
-		describe("edge cases", () => {
-			it("should handle multiple rapid operations", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				await $map.add("key2", stateAsync(Promise.resolve(2)));
-				await $map.add("key3", stateAsync(Promise.resolve(3)));
-				await $map.update("key1", stateAsync(Promise.resolve(10)));
-				await $map.delete("key2");
-				await $map.add("key4", stateAsync(Promise.resolve(4)));
-				await $map.clear();
-				await $map.add("key5", stateAsync(Promise.resolve(5)));
-
-				expect((await $map.pick()).size).toBe(1);
-				expect(await (await $map.pick()).get("key5")?.pick()).toBe(5);
-			});
-
-			it("should handle empty map operations", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				expect((await $map.pick()).size).toBe(0);
-
-				await $map.add("key1", stateAsync(Promise.resolve(1)));
-				expect((await $map.pick()).size).toBe(1);
-
-				await $map.delete("key1");
-				expect((await $map.pick()).size).toBe(0);
-			});
-
-			it("should handle map with single entry", async () => {
-				const $map = map<string, FlowStateAsync<number>>({
-					key1: stateAsync(Promise.resolve(1)),
-				});
-				expect((await $map.pick()).size).toBe(1);
-
-				await $map.update("key1", stateAsync(Promise.resolve(2)));
-				expect(await (await $map.pick()).get("key1")?.pick()).toBe(2);
-
-				await $map.delete("key1");
-				expect((await $map.pick()).size).toBe(0);
-			});
-
-			it("should handle map with many entries", async () => {
-				const $map = map<string, FlowStateAsync<number>>();
-				for (let i = 0; i < 100; i++) {
-					await $map.add(`key${i}`, stateAsync(Promise.resolve(i)));
-				}
-				expect((await $map.pick()).size).toBe(100);
-
-				for (let i = 0; i < 50; i++) {
-					await $map.delete(`key${i}`);
-				}
-				expect((await $map.pick()).size).toBe(50);
-			});
-
-			it("should handle disposed values in map", async () => {
-				const $value = stateAsync(Promise.resolve(1));
-				const $map = map(new Map([["key1", $value]]));
-
-				await $map.delete("key1");
-
-				expect($value.disposed).toBe(true);
-				expect((await $map.pick()).size).toBe(0);
-			});
-
-			it("should handle effects on FlowStateAsync values in map", async () => {
-				const $value = stateAsync(Promise.resolve(1));
-				const $map = map(new Map([["key1", $value]]));
-				const effectFn = vi.fn();
-
-				effect(async (t) => {
-					const mapValue = (await $map.get(t)).get("key1");
-					if (mapValue) {
-						effectFn(await mapValue.get(t));
-					}
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(1);
-
-				await $value.set(Promise.resolve(2));
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				expect(effectFn).toHaveBeenLastCalledWith(2);
-			});
-		});
-	});
-
-	describe("integration", () => {
-		beforeEach(() => {
-			FlowGraph.clear();
-		});
-
-		describe("with effects", () => {
-			describe("reactivity", () => {
-				it("should call effect when initialized", async () => {
-					const $map = map<string, FlowStateAsync<number>>({
-						key1: stateAsync(Promise.resolve(1)),
-						key2: stateAsync(Promise.resolve(2)),
-					});
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-					expect(effectFn).toHaveBeenLastCalledWith(
-						expect.objectContaining({
-							size: 2,
-						}),
-					);
-				});
-
-				it("should call effect when updated with set", async () => {
-					const $map = map<string, FlowStateAsync<number>>({
-						key1: stateAsync(Promise.resolve(1)),
-					});
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					const $newValue = stateAsync(Promise.resolve(2));
-					await $map.set(new Map([["key2", $newValue]]));
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith(
-						expect.objectContaining({
-							size: 1,
-						}),
-					);
-				});
-
-				it("should call effect when updated with add", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-					expect(effectFn).toHaveBeenLastCalledWith(new Map());
-
-					const $key1Value = stateAsync(Promise.resolve(1));
-					await $map.add("key1", $key1Value);
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith(
-						new Map([["key1", $key1Value]]),
-					);
-
-					const $key2Value = stateAsync(Promise.resolve(2));
-					await $map.add("key2", $key2Value);
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-					expect(effectFn).toHaveBeenLastCalledWith(
-						new Map([
-							["key1", $key1Value],
-							["key2", $key2Value],
-						]),
-					);
-				});
-
-				it("should call effect when updated with update", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					await $map.add("key1", stateAsync(Promise.resolve(1)));
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					const $newValue = stateAsync(Promise.resolve(2));
-					await $map.update("key1", $newValue);
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith(
-						new Map([["key1", $newValue]]),
-					);
-				});
-
-				it("should call effect when updated with delete", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					await $map.add("key1", stateAsync(Promise.resolve(1)));
-					await $map.add("key2", stateAsync(Promise.resolve(2)));
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					await $map.delete("key1");
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					const mapAfterDelete = effectFn.mock.calls[1][0];
-					expect(mapAfterDelete.size).toBe(1);
-					expect(mapAfterDelete.has("key2")).toBe(true);
-				});
-
-				it("should call effect when updated with clear", async () => {
-					const $map = map<string, FlowStateAsync<number>>({
-						key1: stateAsync(Promise.resolve(1)),
-						key2: stateAsync(Promise.resolve(2)),
-					});
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					await $map.clear();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith(new Map());
-				});
-
-				it("should call effect when FlowStateAsync values in map are updated", async () => {
-					const $value = stateAsync(Promise.resolve(1));
-					const $map = map(new Map([["key1", $value]]));
-					const effectFn = vi.fn();
-
-					effect(async (t) => {
-						const mapValue = (await $map.get(t)).get("key1");
-						if (mapValue) {
-							effectFn(await mapValue.get(t));
-						}
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-					expect(effectFn).toHaveBeenLastCalledWith(1);
-
-					await $value.set(Promise.resolve(2));
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith(2);
-				});
-			});
-
-			describe("$lastAction", () => {
-				it("should call effect when $lastAction is updated with set action", async () => {
-					const $map = map<string, FlowStateAsync<number>>({
-						key1: stateAsync(Promise.resolve(1)),
-					});
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.$lastAction.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					const $newValue = stateAsync(Promise.resolve(2));
-					await $map.set(new Map([["key2", $newValue]]));
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith({
-						type: "set",
-						map: expect.any(Map),
-					});
-				});
-
-				it("should call effect when $lastAction is updated with add action", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.$lastAction.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					const $value = stateAsync(Promise.resolve(1));
-					await $map.add("key1", $value);
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith({
-						type: "add",
-						key: "key1",
-						value: $value,
-					});
-				});
-
-				it("should call effect when $lastAction is updated with update action", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					await $map.add("key1", stateAsync(Promise.resolve(1)));
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.$lastAction.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					const $newValue = stateAsync(Promise.resolve(2));
-					await $map.update("key1", $newValue);
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith({
-						type: "update",
-						key: "key1",
-						value: $newValue,
-					});
-				});
-
-				it("should call effect when $lastAction is updated with delete action", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					const $value = stateAsync(Promise.resolve(1));
-					await $map.add("key1", $value);
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.$lastAction.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					await $map.delete("key1");
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith({
-						type: "delete",
-						key: "key1",
-						value: $value,
-					});
-				});
-
-				it("should call effect when $lastAction is updated with clear action", async () => {
-					const $map = map<string, FlowStateAsync<number>>({
-						key1: stateAsync(Promise.resolve(1)),
-						key2: stateAsync(Promise.resolve(2)),
-					});
-					const effectFn = vi.fn();
-					effect(async (t) => effectFn(await $map.$lastAction.get(t)));
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					await $map.clear();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith({ type: "clear" });
-				});
-
-				it("should call effect when FlowStateAsync value in $lastAction is updated", async () => {
-					const $map = map<string, FlowStateAsync<number>>();
-					const $value = stateAsync(Promise.resolve(1));
-					await $map.add("key1", $value);
-					const effectFn = vi.fn();
-
-					effect(async (t) => {
-						const action = await $map.$lastAction.get(t);
-						if (action.type === "add") {
-							effectFn(await action.value.get(t));
-						}
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-					expect(effectFn).toHaveBeenLastCalledWith(1);
-
-					await $value.set(Promise.resolve(2));
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-					expect(effectFn).toHaveBeenLastCalledWith(2);
-				});
-			});
-		});
-	});
-});