fix: outer effect keeps responding to own dep after inner re-runs

When an inner effect re-runs on its own (its own dep changed),
notify() walks up the parent chain to add ancestors to the queue
and clears their Watching flag to prevent duplicate notification.
The parent then runs but isn't dirty/pending, so run() takes the
"not dirty" branch.

Before #109/#110, that branch unconditionally restored Watching.
The fix in #109/#110 added `if (e.flags)` to avoid restoring
Watching on disposed effects (whose flags were zeroed during
checkDirty's traversal). Unfortunately, parents added to the
queue via the chain also have flags === 0 (notify just cleared
Watching, no other flag set), so they fell into the same branch
and lost Watching permanently — the outer effect stopped
responding to its own dep after any inner re-run.

Disposed effects also have deps === undefined (purgeDeps clears
them). Use that as the more precise discriminator: restore
Watching when the effect still has deps, skip when fully disposed.

Fixes #115. Added a regression test mirroring the report.

Author: johnsoncodehk

src/index.ts

@@ -269,7 +269,7 @@ function run(e: EffectNode): void {
 			e.flags &= ~ReactiveFlags.RecursedCheck;
 			purgeDeps(e);
 		}
-	} else if (e.flags) {
+	} else if (e.deps !== undefined) {
 		e.flags = ReactiveFlags.Watching;
 	}
 }

tests/effect.spec.ts

@@ -15,3 +15,29 @@ test('should support custom recurse effect', () => {
 
 	expect(triggers).toBe(6);
 });
+
+// https://github.com/stackblitz/alien-signals/issues/115
+test('outer effect keeps responding to its own dep after inner re-runs', () => {
+	const a = signal(0);
+	const b = signal(0);
+	let outerRuns = 0;
+	let innerRuns = 0;
+
+	effect(() => {
+		a();
+		outerRuns++;
+		effect(() => {
+			b();
+			innerRuns++;
+		});
+	});
+	expect(outerRuns).toBe(1);
+	expect(innerRuns).toBe(1);
+
+	b(1);
+	expect(outerRuns).toBe(1);
+	expect(innerRuns).toBeGreaterThanOrEqual(2);
+
+	a(1);
+	expect(outerRuns).toBe(2);
+});