fix: fix missing effects if derived added, removed, and re-added as dependency

Add HAS_EFFECTS flag to mark derived reactions that have side effects.
Update effects.js to set this flag when effects are added to derived.
Modify runtime.js to re-run derived computations if effects were once
present but are now missing, ensuring effects are properly recreated.
This improves reactivity consistency and prevents lost side effects.

Author: mtsgrd

packages/svelte/src/internal/client/constants.js

@@ -25,6 +25,7 @@ export const REACTION_IS_UPDATING = 1 << 21;
 export const ASYNC = 1 << 22;
 
 export const ERROR_VALUE = 1 << 23;
+export const HAS_EFFECTS = 1 << 24;
 
 export const STATE_SYMBOL = Symbol('$state');
 export const LEGACY_PROPS = Symbol('legacy props');

packages/svelte/src/internal/client/reactivity/effects.js

@@ -33,7 +33,8 @@ import {
 	EFFECT_PRESERVED,
 	STALE_REACTION,
 	USER_EFFECT,
-	ASYNC
+	ASYNC,
+	HAS_EFFECTS
 } from '#client/constants';
 import * as e from '../errors.js';
 import { DEV } from 'esm-env';
@@ -156,6 +157,8 @@ function create_effect(type, fn, sync, push = true) {
 		) {
 			var derived = /** @type {Derived} */ (active_reaction);
 			(derived.effects ??= []).push(effect);
+			// Mark the derived as having effects
+			derived.f |= HAS_EFFECTS;
 		}
 	}
 

packages/svelte/src/internal/client/runtime.js

@@ -20,7 +20,8 @@ import {
 	DISCONNECTED,
 	REACTION_IS_UPDATING,
 	STALE_REACTION,
-	ERROR_VALUE
+	ERROR_VALUE,
+	HAS_EFFECTS
 } from './constants.js';
 import { old_values } from './reactivity/sources.js';
 import {
@@ -671,6 +672,10 @@ export function get(signal) {
 
 		if (is_dirty(derived)) {
 			update_derived(derived);
+		} else if ((derived.f & HAS_EFFECTS) !== 0 && (derived.effects === null || derived.effects.length === 0)) {
+			// If the derived once had effects but they're now missing (destroyed),
+			// we need to re-execute to recreate them
+			update_derived(derived);
 		}
 	}
 

packages/svelte/tests/signals/test.ts

@@ -1441,4 +1441,62 @@ describe('signals', () => {
 			assert.deepEqual(log, ['inner destroyed', 'inner destroyed']);
 		};
 	});
+
+	test('derived effects reconnect after disconnection', () => {
+		return () => {
+			const effectLog: string[] = [];
+			let result!: Derived<number>;
+
+			// Create derived with effects inside an effect root to give it proper context
+			const derivedRoot = effect_root(() => {
+				result = derived(() => {
+					user_effect(() => {
+						effectLog.push('effect-executed');
+					});
+					return 42;
+				});
+			});
+
+			// First render effect that accesses the derived
+			const firstRoot = effect_root(() => {
+				render_effect(() => {
+					$.get(result); // This creates the derived's effects but doesn't execute them yet
+				});
+			});
+
+			// DON'T flush here - we want to simulate the effect never getting a chance to execute
+			// before the component unmounts
+
+			// Verify no effects have executed yet (they're scheduled but not flushed)
+			assert.equal(effectLog.length, 0, 'Effect should not have executed before flush');
+			assert.equal(result.effects?.length, 1, 'Derived should have one effect created');
+
+			// Simulate disconnection by destroying the first render context
+			firstRoot();
+			flushSync();
+
+			// Verify the derived is now disconnected (effects destroyed)
+			assert.equal(result.effects, null, 'Effects should be destroyed after disconnection');
+			assert.equal(effectLog.length, 0, 'Effect should still not have executed');
+
+			// Create second render effect in completely new context
+			const secondRoot = effect_root(() => {
+				render_effect(() => {
+					const value = $.get(result); // Should schedule the desired effect
+					assert.equal(value, 42);
+				});
+			});
+
+			flushSync();
+
+			// The critical test: our fix should have detected missing effects and re-executed
+			// Without the fix: effectLog.length would be 0 (effect never executes)
+			// With the fix: effectLog.length should be 1 (effect executes on reconnection)
+			assert.equal(effectLog.length, 1, 'Effect should execute on reconnection');
+			assert.equal(result.effects?.length, 1, 'Derived should have effects again');
+
+			secondRoot();
+			derivedRoot();
+		};
+	});
 });