@zeix/cause-effect 0.17.3 → 0.18.0

package/test/effect.test.ts

@@ -1,13 +1,12 @@
 import { describe, expect, mock, test } from 'bun:test'
 import {
 	createEffect,
-	isAbortError,
-	Memo,
+	createMemo,
+	createScope,
+	createState,
+	createTask,
 	match,
-	resolve,
-	State,
-	Task,
-	UNSET,
+	RequiredOwnerError,
 } from '../index.ts'
 
 /* === Utility Functions === */
@@ -16,797 +15,395 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 
 /* === Tests === */
 
-describe('Effect', () => {
-	test('should be triggered after a state change', () => {
-		const cause = new State('foo')
-		let count = 0
+describe('createEffect', () => {
+	test('should run immediately on creation', () => {
+		let ran = false
 		createEffect(() => {
-			cause.get()
-			count++
+			ran = true
 		})
-		expect(count).toBe(1)
-		cause.set('bar')
-		expect(count).toBe(2)
+		expect(ran).toBe(true)
 	})
 
-	test('should be triggered after computed async signals resolve without waterfalls', async () => {
-		const a = new Task(async () => {
-			await wait(100)
-			return 10
-		})
-		const b = new Task(async () => {
-			await wait(100)
-			return 20
-		})
-		let result = 0
+	test('should re-run when a tracked dependency changes', () => {
+		const source = createState('foo')
 		let count = 0
 		createEffect(() => {
-			const resolved = resolve({ a, b })
-			match(resolved, {
-				ok: ({ a: aValue, b: bValue }) => {
-					result = aValue + bValue
-					count++
-				},
-			})
+			source.get()
+			count++
 		})
-		expect(result).toBe(0)
-		expect(count).toBe(0)
-		await wait(110)
-		expect(result).toBe(30)
 		expect(count).toBe(1)
+		source.set('bar')
+		expect(count).toBe(2)
 	})
 
-	test('should be triggered repeatedly after repeated state change', async () => {
-		const cause = new State(0)
+	test('should re-run on each state change', () => {
+		const source = createState(0)
 		let result = 0
-		let count = 0
 		createEffect(() => {
-			result = cause.get()
-			count++
+			result = source.get()
 		})
-		for (let i = 0; i < 10; i++) {
-			cause.set(i)
+		for (let i = 1; i <= 5; i++) {
+			source.set(i)
 			expect(result).toBe(i)
-			expect(count).toBe(i + 1) // + 1 for effect initialization
 		}
 	})
 
-	test('should handle errors in effects with resolve handlers', () => {
-		const a = new State(1)
-		const b = new Memo(() => {
-			const v = a.get()
-			if (v > 5) throw new Error('Value too high')
-			return v * 2
-		})
-		let normalCallCount = 0
-		let errorCallCount = 0
+	test('should handle state updates inside effects', () => {
+		const count = createState(0)
+		let effectCount = 0
 		createEffect(() => {
-			const resolved = resolve({ b })
-			match(resolved, {
-				ok: () => {
-					normalCallCount++
-				},
-				err: errors => {
-					errorCallCount++
-					expect(errors[0].message).toBe('Value too high')
-				},
-			})
+			effectCount++
+			if (count.get() === 0) count.set(1)
 		})
+		expect(count.get()).toBe(1)
+		expect(effectCount).toBe(2)
+	})
 
-		// Normal case
-		a.set(2)
-		expect(normalCallCount).toBe(2)
-		expect(errorCallCount).toBe(0)
+	describe('Cleanup', () => {
+		test('should call cleanup before next run', () => {
+			const source = createState(0)
+			let cleanupCount = 0
+			let effectCount = 0
 
-		// Error case
-		a.set(6)
-		expect(normalCallCount).toBe(2)
-		expect(errorCallCount).toBe(1)
+			createEffect(() => {
+				source.get()
+				effectCount++
+				return () => {
+					cleanupCount++
+				}
+			})
 
-		// Back to normal
-		a.set(3)
-		expect(normalCallCount).toBe(3)
-		expect(errorCallCount).toBe(1)
-	})
+			expect(effectCount).toBe(1)
+			expect(cleanupCount).toBe(0)
 
-	test('should handle errors in effects with resolve result', () => {
-		const a = new State(1)
-		const b = new Memo(() => {
-			const v = a.get()
-			if (v > 5) throw new Error('Value too high')
-			return v * 2
-		})
-		let normalCallCount = 0
-		let errorCallCount = 0
-		createEffect(() => {
-			const result = resolve({ b })
-			if (result.ok) {
-				normalCallCount++
-			} else if (result.errors) {
-				errorCallCount++
-				expect(result.errors[0].message).toBe('Value too high')
-			}
-		})
+			source.set(1)
+			expect(effectCount).toBe(2)
+			expect(cleanupCount).toBe(1)
 
-		// Normal case
-		a.set(2)
-		expect(normalCallCount).toBe(2)
-		expect(errorCallCount).toBe(0)
+			source.set(2)
+			expect(effectCount).toBe(3)
+			expect(cleanupCount).toBe(2)
+		})
 
-		// Error case
-		a.set(6)
-		expect(normalCallCount).toBe(2)
-		expect(errorCallCount).toBe(1)
+		test('should call cleanup on disposal', () => {
+			const source = createState(0)
+			let cleanupCalled = false
 
-		// Back to normal
-		a.set(3)
-		expect(normalCallCount).toBe(3)
-		expect(errorCallCount).toBe(1)
-	})
+			const dispose = createEffect(() => {
+				source.get()
+				return () => {
+					cleanupCalled = true
+				}
+			})
 
-	test('should handle UNSET values in effects with resolve handlers', async () => {
-		const a = new Task(async () => {
-			await wait(100)
-			return 42
+			expect(cleanupCalled).toBe(false)
+			dispose()
+			expect(cleanupCalled).toBe(true)
 		})
-		let normalCallCount = 0
-		let nilCount = 0
-		createEffect(() => {
-			const resolved = resolve({ a })
-			match(resolved, {
-				ok: values => {
-					normalCallCount++
-					expect(values.a).toBe(42)
-				},
-				nil: () => {
-					nilCount++
-				},
+
+		test('should stop reacting after disposal', () => {
+			const source = createState(42)
+			let received = 0
+
+			const dispose = createEffect(() => {
+				received = source.get()
 			})
-		})
 
-		expect(normalCallCount).toBe(0)
-		expect(nilCount).toBe(1)
-		expect(a.get()).toBe(UNSET)
-		await wait(110)
-		expect(normalCallCount).toBeGreaterThan(0)
-		expect(nilCount).toBe(1)
-		expect(a.get()).toBe(42)
-	})
+			source.set(43)
+			expect(received).toBe(43)
 
-	test('should handle UNSET values in effects with resolve result', async () => {
-		const a = new Task(async () => {
-			await wait(100)
-			return 42
-		})
-		let normalCallCount = 0
-		let nilCount = 0
-		createEffect(() => {
-			const result = resolve({ a })
-			if (result.ok) {
-				normalCallCount++
-				expect(result.values.a).toBe(42)
-			} else if (result.pending) {
-				nilCount++
-			}
+			dispose()
+			source.set(44)
+			expect(received).toBe(43)
 		})
-
-		expect(normalCallCount).toBe(0)
-		expect(nilCount).toBe(1)
-		expect(a.get()).toBe(UNSET)
-		await wait(110)
-		expect(normalCallCount).toBeGreaterThan(0)
-		expect(nilCount).toBe(1)
-		expect(a.get()).toBe(42)
 	})
 
-	test('should log error to console when error is not handled', () => {
-		// Mock console.error
-		const originalConsoleError = console.error
-		const mockConsoleError = mock(() => {})
-		console.error = mockConsoleError
+	describe('Owner Registration', () => {
+		test('should dispose nested effects when parent scope is disposed', () => {
+			const source = createState(0)
+			let innerRuns = 0
 
-		try {
-			const a = new State(1)
-			const b = new Memo(() => {
-				const v = a.get()
-				if (v > 5) throw new Error('Value too high')
-				return v * 2
+			const dispose = createScope(() => {
+				createEffect(() => {
+					source.get()
+					innerRuns++
+				})
 			})
 
-			// Create an effect without explicit error handling
-			createEffect(() => {
-				b.get()
-			})
+			expect(innerRuns).toBe(1)
+			source.set(1)
+			expect(innerRuns).toBe(2)
 
-			// This should trigger the error
-			a.set(6)
+			dispose()
+			source.set(2)
+			expect(innerRuns).toBe(2) // no longer reacting
+		})
+	})
 
-			// Check if console.error was called with the error message
-			expect(mockConsoleError).toHaveBeenCalledWith(
-				'Error in effect callback:',
-				expect.any(Error),
+	describe('Input Validation', () => {
+		test('should throw InvalidCallbackError for non-function', () => {
+			// @ts-expect-error - Testing invalid input
+			expect(() => createEffect(null)).toThrow(
+				'[Effect] Callback null is invalid',
 			)
-		} finally {
-			// Restore the original console.error
-			console.error = originalConsoleError
-		}
+			// @ts-expect-error - Testing invalid input
+			expect(() => createEffect(42)).toThrow(
+				'[Effect] Callback 42 is invalid',
+			)
+		})
 	})
+})
 
-	test('should clean up subscriptions when disposed', () => {
-		const count = new State(42)
-		let received = 0
+describe('match', () => {
+	test('should call ok handler when all signals have values', () => {
+		const a = createState(1)
+		const b = createState(2)
+		let result = 0
+		createEffect(() =>
+			match([a, b], {
+				ok: ([aVal, bVal]) => {
+					result = aVal + bVal
+				},
+			}),
+		)
+		expect(result).toBe(3)
+	})
 
-		const cleanup = createEffect(() => {
-			received = count.get()
+	test('should call nil handler when signals are unset', async () => {
+		const task = createTask(async () => {
+			await wait(50)
+			return 42
 		})
+		let okCount = 0
+		let nilCount = 0
+		createEffect(() =>
+			match([task], {
+				ok: ([value]) => {
+					okCount++
+					expect(value).toBe(42)
+				},
+				nil: () => {
+					nilCount++
+				},
+			}),
+		)
 
-		count.set(43)
-		expect(received).toBe(43)
-
-		cleanup()
-		count.set(44)
-		expect(received).toBe(43) // Should not update after dispose
+		expect(okCount).toBe(0)
+		expect(nilCount).toBe(1)
+		await wait(60)
+		expect(okCount).toBeGreaterThan(0)
+		expect(nilCount).toBe(1)
 	})
 
-	test('should detect and throw error for circular dependencies in effects', () => {
+	test('should call err handler when signals throw', () => {
+		const a = createState(1)
+		const b = createMemo(() => {
+			if (a.get() > 5) throw new Error('Too high')
+			return a.get() * 2
+		})
 		let okCount = 0
 		let errCount = 0
-		const count = new State(0)
-
-		createEffect(() => {
-			const resolved = resolve({ count })
-			match(resolved, {
+		createEffect(() =>
+			match([b], {
 				ok: () => {
 					okCount++
-					// This effect updates the signal it depends on, creating a circular dependency
-					count.update(v => ++v)
 				},
 				err: errors => {
 					errCount++
-					expect(errors[0]).toBeInstanceOf(Error)
-					expect(errors[0].message).toBe(
-						'Circular dependency detected in effect',
-					)
+					expect(errors[0].message).toBe('Too high')
 				},
-			})
-		})
+			}),
+		)
 
-		// Verify that the count was changed only once due to the circular dependency error
-		expect(count.get()).toBe(1)
 		expect(okCount).toBe(1)
+		a.set(6)
 		expect(errCount).toBe(1)
-	})
-})
-
-describe('Effect - Async with AbortSignal', () => {
-	test('should pass AbortSignal to async effect callback', async () => {
-		let abortSignalReceived = false
-		let effectCompleted = false
-
-		createEffect(async (abort: AbortSignal) => {
-			expect(abort).toBeInstanceOf(AbortSignal)
-			expect(abort.aborted).toBe(false)
-			abortSignalReceived = true
-
-			await wait(50)
-			effectCompleted = true
-			return () => {}
-		})
-
-		expect(abortSignalReceived).toBe(true)
-		await wait(60)
-		expect(effectCompleted).toBe(true)
-	})
-
-	test('should abort async operations when signal changes', async () => {
-		const testSignal = new State(1)
-		let operationAborted = false
-		let operationCompleted = false
-		let abortReason: DOMException | undefined
-
-		createEffect(async abort => {
-			const result = resolve({ testSignal })
-			if (!result.ok) return
-
-			abort.addEventListener('abort', () => {
-				operationAborted = true
-				abortReason = abort.reason
-			})
-
-			try {
-				await wait(100)
-				operationCompleted = true
-			} catch (error) {
-				if (
-					error instanceof DOMException &&
-					error.name === 'AbortError'
-				) {
-					operationAborted = true
-				}
-			}
-		})
-
-		// Change signal quickly to trigger abort
-		await wait(20)
-		testSignal.set(2)
-
-		await wait(50)
-		expect(operationAborted).toBe(true)
-		expect(operationCompleted).toBe(false)
-		expect(abortReason instanceof DOMException).toBe(true)
-		expect((abortReason as DOMException).name).toBe('AbortError')
-	})
-
-	test('should abort async operations on effect cleanup', async () => {
-		let operationAborted = false
-		let abortReason: DOMException | undefined
-
-		const cleanup = createEffect(async abort => {
-			abort.addEventListener('abort', () => {
-				operationAborted = true
-				abortReason = abort.reason
-			})
-
-			await wait(100)
-		})
 
-		await wait(20)
-		cleanup()
-
-		await wait(30)
-		expect(operationAborted).toBe(true)
-		expect(abortReason instanceof DOMException).toBe(true)
-		expect((abortReason as DOMException).name).toBe('AbortError')
+		a.set(3)
+		expect(okCount).toBe(2)
+		expect(errCount).toBe(1)
 	})
 
-	test('should handle AbortError gracefully without logging to console', async () => {
+	test('should fall back to console.error when err handler is not provided', () => {
 		const originalConsoleError = console.error
 		const mockConsoleError = mock(() => {})
 		console.error = mockConsoleError
 
 		try {
-			const testSignal = new State(1)
-
-			createEffect(async abort => {
-				const result = resolve({ testSignal })
-				if (!result.ok) return
-
-				try {
-					await new Promise((resolve, reject) => {
-						const timeout = setTimeout(resolve, 100)
-						abort.addEventListener('abort', () => {
-							clearTimeout(timeout)
-							reject(new DOMException('Aborted', 'AbortError'))
-						})
-					})
-				} catch (error) {
-					if (
-						error instanceof DOMException &&
-						error.name === 'AbortError'
-					) {
-						// This is expected, should not be logged
-						return
-					} else {
-						throw error
-					}
-				}
+			const a = createState(1)
+			const b = createMemo(() => {
+				if (a.get() > 5) throw new Error('Too high')
+				return a.get() * 2
 			})
 
-			await wait(20)
-			testSignal.set(2)
-			await wait(50)
-
-			// Should not have logged the AbortError
-			expect(mockConsoleError).not.toHaveBeenCalledWith(
-				'Effect callback error:',
-				expect.any(DOMException),
+			createEffect(() =>
+				match([b], {
+					ok: () => {},
+				}),
 			)
+
+			a.set(6)
+			expect(mockConsoleError).toHaveBeenCalled()
 		} finally {
 			console.error = originalConsoleError
 		}
 	})
 
-	test('should handle async effects that return cleanup functions', async () => {
-		let asyncEffectCompleted = false
-		let cleanupRegistered = false
-		const testSignal = new State('initial')
-
-		const cleanup = createEffect(async () => {
-			const result = resolve({ testSignal })
-			if (!result.ok) return
-
-			await wait(30)
-			asyncEffectCompleted = true
-			return () => {
-				cleanupRegistered = true
-			}
-		})
-
-		// Wait for async effect to complete
-		await wait(50)
-		expect(asyncEffectCompleted).toBe(true)
-
-		cleanup()
-		expect(cleanupRegistered).toBe(true)
-		expect(cleanup).toBeInstanceOf(Function)
-	})
-
-	test('should handle rapid signal changes with concurrent async operations', async () => {
-		const testSignal = new State(0)
-		let completedOperations = 0
-		let abortedOperations = 0
-
-		createEffect(async abort => {
-			const result = resolve({ testSignal })
-			if (!result.ok) return
-
-			try {
-				await wait(30)
-				if (!abort.aborted) {
-					completedOperations++
-				}
-			} catch (error) {
-				if (
-					error instanceof DOMException &&
-					error.name === 'AbortError'
-				) {
-					abortedOperations++
-				}
-			}
-		})
-
-		// Rapidly change signal multiple times
-		testSignal.set(1)
-		await wait(5)
-		testSignal.set(2)
-		await wait(5)
-		testSignal.set(3)
-		await wait(5)
-		testSignal.set(4)
-
-		// Wait for all operations to complete or abort
-		await wait(60)
-
-		// Only the last operation should complete
-		expect(completedOperations).toBe(1)
-		expect(abortedOperations).toBe(0) // AbortError is handled gracefully, not thrown
+	test('should throw RequiredOwnerError when called outside an owner', () => {
+		expect(() => match([], { ok: () => {} })).toThrow(RequiredOwnerError)
 	})
 
-	test('should handle async errors that are not AbortError', async () => {
-		const originalConsoleError = console.error
-		const mockConsoleError = mock(() => {})
-		console.error = mockConsoleError
-
-		try {
-			const testSignal = new State(1)
-
-			const errorThrower = new Memo(() => {
-				const value = testSignal.get()
-				if (value > 5) throw new Error('Value too high')
-				return value
-			})
-
-			createEffect(async () => {
-				const result = resolve({ errorThrower })
-				if (result.ok) {
-					// Normal operation
-				} else if (result.errors) {
-					// Handle errors from resolve
-					expect(result.errors[0].message).toBe('Value too high')
-					return
-				}
-
-				// Simulate an async error that's not an AbortError
-				if (result.ok && result.values.errorThrower > 3) {
-					throw new Error('Async processing error')
-				}
-			})
-
-			testSignal.set(4) // This will cause an async error
+	test('should resolve multiple async tasks without waterfalls', async () => {
+		const a = createTask(async () => {
 			await wait(20)
-
-			// Should have logged the async error
-			expect(mockConsoleError).toHaveBeenCalledWith(
-				'Error in async effect callback:',
-				expect.any(Error),
-			)
-		} finally {
-			console.error = originalConsoleError
-		}
-	})
-
-	test('should handle promise-based async effects', async () => {
-		let promiseResolved = false
-		let effectValue = ''
-		const testSignal = new State('test-value')
-
-		createEffect(async abort => {
-			const result = resolve({ testSignal })
-			if (!result.ok) return
-
-			// Simulate async work that respects abort signal
-			await new Promise<void>((resolve, reject) => {
-				const timeout = setTimeout(() => {
-					effectValue = result.values.testSignal
-					promiseResolved = true
-					resolve()
-				}, 40)
-
-				abort.addEventListener('abort', () => {
-					clearTimeout(timeout)
-					reject(new DOMException('Aborted', 'AbortError'))
-				})
-			})
-
-			return () => {
-				// Cleanup function
-			}
+			return 10
 		})
-
-		await wait(60)
-		expect(promiseResolved).toBe(true)
-		expect(effectValue).toBe('test-value')
-	})
-
-	test('should not create AbortController for sync functions', () => {
-		const testSignal = new State('test')
-		let syncCallCount = 0
-
-		// Mock AbortController constructor to detect if it's called
-		const originalAbortController = globalThis.AbortController
-		let abortControllerCreated = false
-
-		globalThis.AbortController = class extends originalAbortController {
-			constructor() {
-				super()
-				abortControllerCreated = true
-			}
-		}
-
-		try {
-			createEffect(() => {
-				const result = resolve({ testSignal })
-				if (result.ok) {
-					syncCallCount++
-				}
-			})
-
-			testSignal.set('changed')
-			expect(syncCallCount).toBe(2)
-			expect(abortControllerCreated).toBe(false)
-		} finally {
-			globalThis.AbortController = originalAbortController
-		}
-	})
-
-	test('should handle concurrent async operations with abort', async () => {
-		const testSignal = new State(1)
-		let operation1Completed = false
-		let operation1Aborted = false
-
-		createEffect(async abort => {
-			const result = resolve({ testSignal })
-			if (!result.ok) return
-
-			try {
-				// Create a promise that can be aborted
-				await new Promise<void>((resolve, reject) => {
-					const timeout = setTimeout(() => {
-						operation1Completed = true
-						resolve()
-					}, 80)
-
-					abort.addEventListener('abort', () => {
-						operation1Aborted = true
-						clearTimeout(timeout)
-						reject(new DOMException('Aborted', 'AbortError'))
-					})
-				})
-			} catch (error) {
-				if (
-					error instanceof DOMException &&
-					error.name === 'AbortError'
-				) {
-					// Expected when aborted
-					return
-				}
-				throw error
-			}
+		const b = createTask(async () => {
+			await wait(20)
+			return 20
 		})
-
-		// Start first operation
-		await wait(20)
-
-		// Trigger second operation before first completes
-		testSignal.set(2)
-
-		// Wait a bit for abort to take effect
+		let result = 0
+		let nilCount = 0
+		createEffect(() =>
+			match([a, b], {
+				ok: ([aVal, bVal]) => {
+					result = aVal + bVal
+				},
+				nil: () => {
+					nilCount++
+				},
+			}),
+		)
+		expect(result).toBe(0)
+		expect(nilCount).toBe(1)
 		await wait(30)
-
-		expect(operation1Aborted).toBe(true)
-		expect(operation1Completed).toBe(false)
+		expect(result).toBe(30)
 	})
-})
 
-describe('Effect + Resolve Integration', () => {
-	test('should work with resolve discriminated union', () => {
-		const a = new State(10)
-		const b = new State('hello')
-		let effectRan = false
+	describe('Async Handlers', () => {
+		test('should not register cleanup from stale async handler after disposal', async () => {
+			let cleanupRegistered = false
+
+			const dispose = createEffect(() =>
+				match([], {
+					ok: async () => {
+						await wait(50)
+						return () => {
+							cleanupRegistered = true
+						}
+					},
+				}),
+			)
 
-		createEffect(() => {
-			const result = resolve({ a, b })
+			await wait(10)
+			dispose()
+			await wait(60)
 
-			if (result.ok) {
-				effectRan = true
-				expect(result.values.a).toBe(10)
-				expect(result.values.b).toBe('hello')
-			}
+			expect(cleanupRegistered).toBe(false)
 		})
 
-		expect(effectRan).toBe(true)
-	})
-
-	test('should work with match function', () => {
-		const a = new State(42)
-		let matchedValue = 0
+		test('should register and run cleanup from completed async handler', async () => {
+			let cleanupCalled = false
+
+			const dispose = createEffect(() =>
+				match([], {
+					ok: async () => {
+						await wait(10)
+						return () => {
+							cleanupCalled = true
+						}
+					},
+				}),
+			)
 
-		createEffect(() => {
-			const result = resolve({ a })
-			match(result, {
-				ok: values => {
-					matchedValue = values.a
-				},
-			})
+			await wait(20)
+			dispose()
+			expect(cleanupCalled).toBe(true)
 		})
 
-		expect(matchedValue).toBe(42)
-	})
-})
-
-describe('Effect - Race Conditions and Consistency', () => {
-	test('should handle race conditions between abort and cleanup properly', async () => {
-		// This test explores potential race conditions in effect cleanup
-		const testSignal = new State(0)
-		let cleanupCallCount = 0
-		let abortCallCount = 0
-		let operationCount = 0
-
-		createEffect(async abort => {
-			testSignal.get()
-			++operationCount
-
-			abort.addEventListener('abort', () => {
-				abortCallCount++
-			})
+		test('should route async errors to err handler', async () => {
+			const originalConsoleError = console.error
+			const mockConsoleError = mock(() => {})
+			console.error = mockConsoleError
 
 			try {
-				await wait(50)
-				// This cleanup should only be registered if the operation wasn't aborted
-				return () => {
-					cleanupCallCount++
-				}
-			} catch (error) {
-				if (!isAbortError(error)) throw error
+				const source = createState(1)
+
+				createEffect(() =>
+					match([source], {
+						ok: async ([value]) => {
+							await wait(10)
+							if (value > 3) throw new Error('Async error')
+						},
+					}),
+				)
+
+				source.set(4)
+				await wait(20)
+
+				expect(mockConsoleError).toHaveBeenCalled()
+			} finally {
+				console.error = originalConsoleError
 			}
 		})
 
-		// Rapid signal changes to test race conditions
-		testSignal.set(1)
-		await wait(10)
-		testSignal.set(2)
-		await wait(10)
-		testSignal.set(3)
-		await wait(100) // Let all operations complete
-
-		// Without proper abort handling, we might get multiple cleanups
-		expect(cleanupCallCount).toBeLessThanOrEqual(1) // Should be at most 1
-		expect(operationCount).toBeGreaterThan(1) // Should have multiple operations
-		expect(abortCallCount).toBeGreaterThan(0) // Should have some aborts
-	})
-
-	test('should demonstrate difference in abort handling between computed and effect', async () => {
-		// This test shows why computed needs an abort listener but effect might not
-		const source = new State(1)
-		let computedRetries = 0
-		let effectRuns = 0
-
-		// Computed with abort listener (current implementation)
-		const comp = new Task(async () => {
-			computedRetries++
-			await wait(30)
-			return source.get() * 2
-		})
-
-		// Effect without abort listener (current implementation)
-		createEffect(async () => {
-			effectRuns++
-			// Must access the source to make effect reactive
-			source.get()
-			await wait(30)
-			resolve({ comp })
-			// Effect doesn't need to return a value immediately
-		})
-
-		// Change source rapidly
-		source.set(2)
-		await wait(10)
-		source.set(3)
-		await wait(50)
-
-		// Computed should retry efficiently due to abort listener
-		// Effect should handle the changes naturally through dependency tracking
-		expect(computedRetries).toBeGreaterThan(0)
-		expect(effectRuns).toBeGreaterThan(0)
-	})
+		test('should discard stale async cleanup when effect re-runs', async () => {
+			const source = createState(1)
+			let staleCleanupCalled = false
+			let freshCleanupCalled = false
+
+			const dispose = createEffect(() =>
+				match([source], {
+					ok: async ([value]) => {
+						if (value === 1) {
+							await wait(80)
+							return () => {
+								staleCleanupCalled = true
+							}
+						}
+						await wait(10)
+						return () => {
+							freshCleanupCalled = true
+						}
+					},
+				}),
+			)
 
-	test('should prevent stale cleanup registration with generation counter approach', async () => {
-		// This test verifies that the currentController check prevents stale cleanups
-		const testSignal = new State(0)
-		let cleanupCallCount = 0
-		let effectRunCount = 0
-		let staleCleanupAttempts = 0
+			await wait(20)
+			source.set(2)
+			await wait(100)
 
-		createEffect(async () => {
-			effectRunCount++
-			const currentRun = effectRunCount
-			testSignal.get() // Make reactive
+			expect(staleCleanupCalled).toBe(false)
 
-			try {
-				await wait(60)
-				// This cleanup should only be registered for the latest run
-				return () => {
-					cleanupCallCount++
-					if (currentRun !== effectRunCount) {
-						staleCleanupAttempts++
-					}
-				}
-			} catch (error) {
-				if (!isAbortError(error)) throw error
-				return undefined
-			}
+			dispose()
+			expect(freshCleanupCalled).toBe(true)
 		})
 
-		// Trigger multiple rapid changes
-		testSignal.set(1)
-		await wait(20)
-		testSignal.set(2)
-		await wait(20)
-		testSignal.set(3)
-		await wait(80) // Let final operation complete
-
-		// Should have multiple runs but only one cleanup (from the last successful run)
-		expect(effectRunCount).toBeGreaterThan(1)
-		expect(cleanupCallCount).toBeLessThanOrEqual(1)
-		expect(staleCleanupAttempts).toBe(0) // No stale cleanups should be registered
-	})
+		test('should call async cleanup before re-running', async () => {
+			const source = createState(0)
+			let cleanupCount = 0
+			let okCount = 0
+
+			createEffect(() =>
+				match([source], {
+					ok: async () => {
+						okCount++
+						await wait(10)
+						return () => {
+							cleanupCount++
+						}
+					},
+				}),
+			)
 
-	test('should demonstrate why computed needs immediate retry via abort listener', async () => {
-		// This test shows the performance benefit of immediate retry in computed
-		const source = new State(1)
-		let computeAttempts = 0
-		let finalValue: number = 0
+			await wait(20)
+			expect(okCount).toBe(1)
+			expect(cleanupCount).toBe(0)
 
-		const comp = new Task(async () => {
-			computeAttempts++
-			await wait(30)
-			return source.get() * 2
+			source.set(1)
+			expect(cleanupCount).toBe(1)
+			await wait(20)
+			expect(okCount).toBe(2)
 		})
-
-		// Start computation
-		expect(comp.get()).toBe(UNSET)
-
-		// Change source during computation - this should trigger immediate retry
-		await wait(10)
-		source.set(5)
-
-		// Wait for computation to complete
-		await wait(50)
-		finalValue = comp.get()
-
-		// The abort listener allows immediate retry, so we should get the latest value
-		expect(finalValue).toBe(10) // 5 * 2
-		// Note: The number of attempts can vary due to timing, but should get correct result
-		expect(computeAttempts).toBeGreaterThanOrEqual(1)
 	})
 })