From f31e71556965869ecf981438735c28df2e375c47 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 23 Mar 2026 10:52:05 -0400
Subject: [PATCH 001/122] bring tests over from async-blocking-and-merging

---
 .../async-discard-obsolete-batch/_config.js   |   6 +
 .../async-discard-obsolete-batch/main.svelte  |   7 +-
 .../_config.js                                |   2 +-
 .../async-overlap-multiple-1/_config.js       | 107 +++++++++++++++++
 .../async-overlap-multiple-1/main.svelte      |  26 +++++
 .../async-overlap-multiple-2/_config.js       |  81 +++++++++++++
 .../async-overlap-multiple-2/main.svelte      |  26 +++++
 .../async-overlap-multiple-3/_config.js       | 107 +++++++++++++++++
 .../async-overlap-multiple-3/main.svelte      |  26 +++++
 .../async-overlap-multiple-4/_config.js       | 109 ++++++++++++++++++
 .../async-overlap-multiple-4/main.svelte      |  26 +++++
 .../async-overlap-multiple-5/_config.js       |  87 ++++++++++++++
 .../async-overlap-multiple-5/main.svelte      |  23 ++++
 .../async-overlap-multiple-6/_config.js       |  76 ++++++++++++
 .../async-overlap-multiple-6/main.svelte      |  23 ++++
 .../async-overlap-multiple-7/_config.js       |  87 ++++++++++++++
 .../async-overlap-multiple-7/main.svelte      |  23 ++++
 .../async-overlap-multiple-fork-1/_config.js  |  34 ++++++
 .../async-overlap-multiple-fork-1/main.svelte |  27 +++++
 .../async-overlap-multiple-fork-2/_config.js  |  42 +++++++
 .../async-overlap-multiple-fork-2/main.svelte |  31 +++++
 .../async-state-new-branch-1/Child.svelte     |   7 ++
 .../async-state-new-branch-1/_config.js       |  37 ++++++
 .../async-state-new-branch-1/main.svelte      |  28 +++++
 .../async-state-new-branch-2/Child.svelte     |  11 ++
 .../async-state-new-branch-2/_config.js       |  48 ++++++++
 .../async-state-new-branch-2/main.svelte      |  30 +++++
 .../async-state-new-branch-3/Child.svelte     |  11 ++
 .../async-state-new-branch-3/_config.js       |  60 ++++++++++
 .../async-state-new-branch-3/main.svelte      |  34 ++++++
 .../async-state-new-branch-4/Child.svelte     |  11 ++
 .../async-state-new-branch-4/_config.js       |  75 ++++++++++++
 .../async-state-new-branch-4/main.svelte      |  32 +++++
 .../async-state-new-branch-5/Child.svelte     |  11 ++
 .../async-state-new-branch-5/_config.js       |  84 ++++++++++++++
 .../async-state-new-branch-5/main.svelte      |  36 ++++++
 36 files changed, 1489 insertions(+), 2 deletions(-)
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-1/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-1/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-6/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-6/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-1/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-1/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-2/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-2/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/Child.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/Child.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/Child.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/Child.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/main.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/Child.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/main.svelte

diff --git a/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/_config.js b/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/_config.js
index 64e1a4b2b5..bd3b7e6960 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/_config.js
@@ -14,6 +14,7 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>1 = 1</p>
+				<p>hello</p>
 			`
 		);
 
@@ -29,6 +30,7 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>1 = 1</p>
+				<p>hello</p>
 			`
 		);
 
@@ -42,6 +44,7 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>1 = 1</p>
+				<p>hello</p>
 			`
 		);
 
@@ -55,6 +58,7 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>3 = 3</p>
+				<p>goodbye</p>
 			`
 		);
 
@@ -70,6 +74,7 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>3 = 3</p>
+				<p>goodbye</p>
 			`
 		);
 
@@ -83,6 +88,7 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>5 = 5</p>
+				<p>goodbye</p>
 			`
 		);
 	}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/main.svelte
index faa8d139a6..d42b3b545a 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/main.svelte
+++ b/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/main.svelte
@@ -24,9 +24,13 @@
 	}
 
 	let n = $state(1);
+	let message = $state('hello');
 </script>
 
-<button onclick={() => n++}>
+<button onclick={() => {
+	n++;
+	message = 'goodbye';
+}}>
 	{$state.eager(n)}
 </button>
 
@@ -34,3 +38,4 @@
 <button onclick={pop}>pop</button>
 
 <p>{n} = {await push(n)}</p>
+<p>{message}</p>
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-linear-order-same-derived/_config.js b/packages/svelte/tests/runtime-runes/samples/async-linear-order-same-derived/_config.js
index cc7b2756fa..1e0da08eda 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-linear-order-same-derived/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-linear-order-same-derived/_config.js
@@ -18,7 +18,7 @@ export default test({
 		pop.click();
 		await tick();
 
-		assert.htmlEqual(p.innerHTML, '1 + 3 = 4');
+		assert.htmlEqual(p.innerHTML, '2 + 3 = 5');
 
 		pop.click();
 		await tick();
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-1/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-1/_config.js
new file mode 100644
index 0000000000..03d8e49b6f
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-1/_config.js
@@ -0,0 +1,107 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a_b, a_c, b_d, shift, pop] = target.querySelectorAll('button');
+
+		a_b.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		a_c.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		b_d.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 1 | b 1 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 2 | b 1 | c 1 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 2 | b 2 | c 1 | d 1
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-1/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-1/main.svelte
new file mode 100644
index 0000000000..25dbe586ca
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-1/main.svelte
@@ -0,0 +1,26 @@
+<script>
+	let a = $state(0);
+	let b = $state(0);
+	let c = $state(0);
+	let d = $state(0);
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+a {await delay(a)} | b {await delay(b)} | c {c} | d {d}
+<button onclick={() => {a++;b++;}}>
+	a and b
+</button>
+<button onclick={() => {a++;c++;}}>
+	a and c
+</button>
+<button onclick={() => {b++;d++;}}>
+	b and d
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/_config.js
new file mode 100644
index 0000000000..0f422d1797
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/_config.js
@@ -0,0 +1,81 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a_b, a_c, b_d, shift, pop] = target.querySelectorAll('button');
+
+		a_b.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		a_c.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		b_d.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		pop.click(); // second b resolved, blocked on first batch because a still pending
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		for (let i = 0; i < 3; i++) {
+			pop.click(); // second a resolved, first a/b now obsolete; empty queue
+			await tick();
+			assert.htmlEqual(
+				target.innerHTML,
+				`
+				a 2 | b 2 | c 1 | d 1
+				<button>a and b</button>
+				<button>a and c</button>
+				<button>b and d</button>
+				<button>shift</button>
+				<button>pop</button>
+			`
+			);
+		}
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/main.svelte
new file mode 100644
index 0000000000..25dbe586ca
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/main.svelte
@@ -0,0 +1,26 @@
+<script>
+	let a = $state(0);
+	let b = $state(0);
+	let c = $state(0);
+	let d = $state(0);
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+a {await delay(a)} | b {await delay(b)} | c {c} | d {d}
+<button onclick={() => {a++;b++;}}>
+	a and b
+</button>
+<button onclick={() => {a++;c++;}}>
+	a and c
+</button>
+<button onclick={() => {b++;d++;}}>
+	b and d
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/_config.js
new file mode 100644
index 0000000000..011588447f
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/_config.js
@@ -0,0 +1,107 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a_b, a_c, b_d, shift, pop] = target.querySelectorAll('button');
+
+		a_b.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		a_c.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		b_d.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click(); // first a resolved, still pending: [b, a, b]
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		pop.click(); // second b resolved, still pending: [b, a]
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click(); // first b resolved, first + last batch settled, still pending: [a]
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 1 | b 2 | c 0 | d 1
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click(); // all resolved
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 2 | b 2 | c 1 | d 1
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/main.svelte
new file mode 100644
index 0000000000..25dbe586ca
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/main.svelte
@@ -0,0 +1,26 @@
+<script>
+	let a = $state(0);
+	let b = $state(0);
+	let c = $state(0);
+	let d = $state(0);
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+a {await delay(a)} | b {await delay(b)} | c {c} | d {d}
+<button onclick={() => {a++;b++;}}>
+	a and b
+</button>
+<button onclick={() => {a++;c++;}}>
+	a and c
+</button>
+<button onclick={() => {b++;d++;}}>
+	b and d
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/_config.js
new file mode 100644
index 0000000000..2c6226af07
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/_config.js
@@ -0,0 +1,109 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a_b, a_c, b_d, shift, pop] = target.querySelectorAll('button');
+
+		a_b.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		a_c.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		b_d.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click(); // first a resolved, still pending: [b, a, b]
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		pop.click(); // second b resolved, still pending: [b, a]
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		pop.click(); // second a resolved, first a/b now obsolete
+		// TODO would be nice to show final result here already, right now it doesn't because
+		// we have no handle on the already resolved first a anymore
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click(); // queue empty
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 2 | b 2 | c 1 | d 1
+			<button>a and b</button>
+			<button>a and c</button>
+			<button>b and d</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/main.svelte
new file mode 100644
index 0000000000..25dbe586ca
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/main.svelte
@@ -0,0 +1,26 @@
+<script>
+	let a = $state(0);
+	let b = $state(0);
+	let c = $state(0);
+	let d = $state(0);
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+a {await delay(a)} | b {await delay(b)} | c {c} | d {d}
+<button onclick={() => {a++;b++;}}>
+	a and b
+</button>
+<button onclick={() => {a++;c++;}}>
+	a and c
+</button>
+<button onclick={() => {b++;d++;}}>
+	b and d
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/_config.js
new file mode 100644
index 0000000000..f07c86dc0c
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/_config.js
@@ -0,0 +1,87 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a, c, shift, pop] = target.querySelectorAll('button');
+
+		a.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		c.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 1 | b 2 | c 0 | d 2
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 1 | b 2 | c 1 | d 3
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/main.svelte
new file mode 100644
index 0000000000..cf028718c2
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/main.svelte
@@ -0,0 +1,23 @@
+<script>
+	let a = $state(0);
+	let b = $derived(await delay(a * 2));
+	let c = $state(0);
+	let d = $derived(await delay(b + c));
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value; 
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+a {a} | b {b} | c {c} | d {d}
+<button onclick={() => {a++;}}>
+	a++
+</button>
+<button onclick={() => {c++;}}>
+	c++
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-6/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-6/_config.js
new file mode 100644
index 0000000000..27152889a2
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-6/_config.js
@@ -0,0 +1,76 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a, c, shift, pop] = target.querySelectorAll('button');
+
+		a.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		c.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		// Although the second batch is eventually connected to the first one, we can't see that
+		// at this point yet and so the second one flushes right away.
+		pop.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 1 | d 1
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		pop.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 1 | d 1
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		pop.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 1 | b 2 | c 1 | d 3
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-6/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-6/main.svelte
new file mode 100644
index 0000000000..cf028718c2
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-6/main.svelte
@@ -0,0 +1,23 @@
+<script>
+	let a = $state(0);
+	let b = $derived(await delay(a * 2));
+	let c = $state(0);
+	let d = $derived(await delay(b + c));
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value; 
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+a {a} | b {b} | c {c} | d {d}
+<button onclick={() => {a++;}}>
+	a++
+</button>
+<button onclick={() => {c++;}}>
+	c++
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/_config.js
new file mode 100644
index 0000000000..62ba0e3f46
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/_config.js
@@ -0,0 +1,87 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a, c, shift, pop] = target.querySelectorAll('button');
+
+		a.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		c.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click(); // schedules second step of first batch and schedules rerun of second batch
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		pop.click(); // second batch resolves but knows it needs to wait on first batch
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click(); // obsolete second batch promise (already rejected)
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 0 | b 0 | c 0 | d 0
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+
+		shift.click(); // first batch resolves, with it second can now resolve as well
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			a 1 | b 2 | c 1 | d 3
+			<button>a++</button>
+			<button>c++</button>
+			<button>shift</button>
+			<button>pop</button>
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/main.svelte
new file mode 100644
index 0000000000..cf028718c2
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/main.svelte
@@ -0,0 +1,23 @@
+<script>
+	let a = $state(0);
+	let b = $derived(await delay(a * 2));
+	let c = $state(0);
+	let d = $derived(await delay(b + c));
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value; 
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+a {a} | b {b} | c {c} | d {d}
+<button onclick={() => {a++;}}>
+	a++
+</button>
+<button onclick={() => {c++;}}>
+	c++
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-1/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-1/_config.js
new file mode 100644
index 0000000000..07ce7e340f
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-1/_config.js
@@ -0,0 +1,34 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a_b_fork, a_c, shift, pop, commit] = target.querySelectorAll('button');
+		const [p] = target.querySelectorAll('p');
+
+		a_b_fork.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 0 | b 0 | c 0');
+
+		a_c.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 0 | b 0 | c 0');
+
+		pop.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 1 | b 0 | c 1');
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 1 | b 0 | c 1');
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 1 | b 0 | c 1');
+
+		commit.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 1 | b 1 | c 1');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-1/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-1/main.svelte
new file mode 100644
index 0000000000..60ba74fb8e
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-1/main.svelte
@@ -0,0 +1,27 @@
+<script>
+	import { fork } from 'svelte';
+
+	let a = $state(0);
+	let b = $state(0);
+	let c = $state(0);
+	let f;
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+<p>a {await delay(a)} | b {await delay(b)} | c {c}</p>
+
+<button onclick={() => {f = fork(() => {a++;b++;});}}>
+	a and b (fork)
+</button>
+<button onclick={() => {a++;c++;}}>
+	a and c
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
+<button onclick={() => f.commit()}>commit fork</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-2/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-2/_config.js
new file mode 100644
index 0000000000..180a190dae
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-2/_config.js
@@ -0,0 +1,42 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		const [a_b_fork, a_c, b_d, shift, pop, commit] = target.querySelectorAll('button');
+		const [p] = target.querySelectorAll('p');
+
+		a_b_fork.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 0 | b 0 | c 0 | d 0');
+
+		a_c.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 0 | b 0 | c 0 | d 0');
+
+		b_d.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 0 | b 0 | c 0 | d 0');
+
+		pop.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 0 | b 1 | c 0 | d 1');
+
+		pop.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 1 | b 1 | c 1 | d 1');
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 1 | b 1 | c 1 | d 1');
+
+		shift.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 1 | b 1 | c 1 | d 1');
+
+		commit.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, 'a 1 | b 1 | c 1 | d 1');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-2/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-2/main.svelte
new file mode 100644
index 0000000000..6d1c4ab418
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-fork-2/main.svelte
@@ -0,0 +1,31 @@
+<script>
+	import { fork } from 'svelte';
+
+	let a = $state(0);
+	let b = $state(0);
+	let c = $state(0);
+	let d = $state(0);
+	let f;
+
+	const deferred = [];
+
+	function delay(value) {
+		if (!value) return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+<p>a {await delay(a)} | b {await delay(b)} | c {c} | d {d}</p>
+
+<button onclick={() => {f = fork(() => {a++;b++;});}}>
+	a and b (fork)
+</button>
+<button onclick={() => {a++;c++;}}>
+	a and c
+</button>
+<button onclick={() => {b++;d++;}}>
+	b and d
+</button>
+<button onclick={() => deferred.shift()?.()}>shift</button>
+<button onclick={() => deferred.pop()?.()}>pop</button>
+<button onclick={() => f.commit()}>commit fork</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/Child.svelte
new file mode 100644
index 0000000000..6b765526c8
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/Child.svelte
@@ -0,0 +1,7 @@
+<script>
+	let { x } = $props();
+	console.log(x);
+	$effect(() => console.log('$effect: '+ x))
+</script>
+
+{x}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/_config.js
new file mode 100644
index 0000000000..28ce3c9d4f
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/_config.js
@@ -0,0 +1,37 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target, logs }) {
+		const [x, y, resolve] = target.querySelectorAll('button');
+
+		x.click();
+		await tick();
+
+		y.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+		`
+		);
+
+		resolve.click();
+		await tick();
+		assert.deepEqual(logs, ['universe', 'universe', '$effect: universe', '$effect: universe']);
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			universe
+			universe
+			universe
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/main.svelte
new file mode 100644
index 0000000000..8edc718de2
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/main.svelte
@@ -0,0 +1,28 @@
+<script>
+	import Child from './Child.svelte';
+
+	let x = $state('world');
+	let y = $state(0);
+	let deferred = [];
+
+	function delay(s) {
+		const d = Promise.withResolvers();
+		deferred.push(() => d.resolve(s))
+		return d.promise;
+	}
+</script>
+
+<button onclick={() => x = 'universe'}>x</button>
+
+<button onclick={() => y++}>y++</button>
+
+<button onclick={() => deferred.shift()()}>resolve</button>
+
+{#if x === 'universe'}
+	{await delay(x)}
+	<Child {x} />
+{/if}
+
+{#if y > 0}
+	<Child {x} />
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/Child.svelte
new file mode 100644
index 0000000000..f8c01e9efd
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/Child.svelte
@@ -0,0 +1,11 @@
+<script>
+	let { x } = $props();
+</script>
+
+<!-- checks direct source, indirect derived, block effect, async effect -->
+{x}
+{JSON.stringify(x)}
+{#if x === 'universe'}universe{:else}world{/if}
+{#if JSON.stringify(x) === '"universe"'}universe{:else}world{/if}
+{await Promise.resolve(x)}
+{await Promise.resolve(JSON.stringify(x))}
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/_config.js
new file mode 100644
index 0000000000..00b38262e8
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/_config.js
@@ -0,0 +1,48 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		const [x, y, resolve] = target.querySelectorAll('button');
+
+		x.click();
+		await tick();
+
+		y.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<hr>
+		`
+		);
+
+		resolve.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			universe
+			universe
+			"universe"
+			universe
+			universe
+			universe
+			"universe"
+			<hr>
+			universe
+			"universe"
+			universe
+			universe
+			universe
+			"universe"
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/main.svelte
new file mode 100644
index 0000000000..11c4bdf5d1
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/main.svelte
@@ -0,0 +1,30 @@
+<script>
+	import Child from './Child.svelte';
+
+	let x = $state('world');
+	let y = $state(0);
+	let deferred = [];
+
+	function delay(s) {
+		const d = Promise.withResolvers();
+		deferred.push(() => d.resolve(s))
+		return d.promise;
+	}
+</script>
+
+<button onclick={() => x = 'universe'}>x</button>
+
+<button onclick={() => y++}>y++</button>
+
+<button onclick={() => deferred.shift()()}>resolve</button>
+
+{#if x === 'universe'}
+	{await delay(x)}
+	<Child {x} />
+{/if}
+
+<hr>
+
+{#if y > 0}
+	<Child {x} />
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/Child.svelte
new file mode 100644
index 0000000000..f8c01e9efd
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/Child.svelte
@@ -0,0 +1,11 @@
+<script>
+	let { x } = $props();
+</script>
+
+<!-- checks direct source, indirect derived, block effect, async effect -->
+{x}
+{JSON.stringify(x)}
+{#if x === 'universe'}universe{:else}world{/if}
+{#if JSON.stringify(x) === '"universe"'}universe{:else}world{/if}
+{await Promise.resolve(x)}
+{await Promise.resolve(JSON.stringify(x))}
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/_config.js
new file mode 100644
index 0000000000..fe2765e76f
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/_config.js
@@ -0,0 +1,60 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		const [x, y, resolve] = target.querySelectorAll('button');
+
+		x.click();
+		await tick();
+
+		y.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<hr>
+		`
+		);
+
+		resolve.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<hr>
+		`
+		);
+
+		resolve.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			universe
+			universe
+			"universe"
+			universe
+			universe
+			universe
+			"universe"
+			<hr>
+			universe
+			"universe"
+			universe
+			universe
+			universe
+			"universe"
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/main.svelte
new file mode 100644
index 0000000000..b02ab20995
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/main.svelte
@@ -0,0 +1,34 @@
+<script>
+	import Child from './Child.svelte';
+
+	let x = $state('world');
+	let y = $state(0);
+
+	const deferred = [];
+
+	function delay(value) {
+		if (value !== 'universe') return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+
+	function delay2(value) {
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+<button onclick={() => (x = 'universe')}>x</button>
+
+<button onclick={() => y++}>y++</button>
+<button onclick={() => deferred.pop()?.()}>resolve</button>
+
+{#if x === 'universe'}
+	{await delay(x)}
+	<Child {x} />
+{/if}
+
+<hr>
+
+{#if y > 0}
+	<Child x={await delay2(x)} />
+{/if}
+ 
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/Child.svelte
new file mode 100644
index 0000000000..f8c01e9efd
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/Child.svelte
@@ -0,0 +1,11 @@
+<script>
+	let { x } = $props();
+</script>
+
+<!-- checks direct source, indirect derived, block effect, async effect -->
+{x}
+{JSON.stringify(x)}
+{#if x === 'universe'}universe{:else}world{/if}
+{#if JSON.stringify(x) === '"universe"'}universe{:else}world{/if}
+{await Promise.resolve(x)}
+{await Promise.resolve(JSON.stringify(x))}
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/_config.js
new file mode 100644
index 0000000000..a20f8c0ba5
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/_config.js
@@ -0,0 +1,75 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		const [x, y, resolve, commit] = target.querySelectorAll('button');
+
+		x.click();
+		await tick();
+
+		y.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<button>commit</button>
+			<hr>
+			world
+			"world"
+			world
+			world
+			world
+			"world"
+		`
+		);
+
+		commit.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<button>commit</button>
+			<hr>
+			world
+			"world"
+			world
+			world
+			world
+			"world"
+		`
+		);
+
+		resolve.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<button>commit</button>
+			universe
+			universe
+			"universe"
+			universe
+			universe
+			universe
+			"universe"
+			<hr>
+			universe
+			"universe"
+			universe
+			universe
+			universe
+			"universe"
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/main.svelte
new file mode 100644
index 0000000000..5f00fc4dec
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/main.svelte
@@ -0,0 +1,32 @@
+<script>
+	import { fork } from 'svelte';
+	import Child from './Child.svelte';
+
+	let x = $state('world');
+	let y = $state(0);
+	let f;
+
+	const deferred = [];
+
+	function delay(value) {
+		if (value !== 'universe') return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+<button onclick={() => (f = fork(() => {x = 'universe';}))}>x</button>
+
+<button onclick={() => y++}>y++</button>
+<button onclick={() => deferred.pop()?.()}>resolve</button>
+<button onclick={() => f.commit()}>commit</button>
+
+{#if x === 'universe'}
+	{await delay(x)}
+	<Child {x} />
+{/if}
+
+<hr>
+
+{#if y > 0}
+	<Child {x} />
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/Child.svelte
new file mode 100644
index 0000000000..f8c01e9efd
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/Child.svelte
@@ -0,0 +1,11 @@
+<script>
+	let { x } = $props();
+</script>
+
+<!-- checks direct source, indirect derived, block effect, async effect -->
+{x}
+{JSON.stringify(x)}
+{#if x === 'universe'}universe{:else}world{/if}
+{#if JSON.stringify(x) === '"universe"'}universe{:else}world{/if}
+{await Promise.resolve(x)}
+{await Promise.resolve(JSON.stringify(x))}
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/_config.js
new file mode 100644
index 0000000000..e8f16ade3c
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/_config.js
@@ -0,0 +1,84 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		const [x, y, resolve, commit] = target.querySelectorAll('button');
+
+		x.click();
+		await tick();
+
+		y.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<button>commit</button>
+			<hr>
+		`
+		);
+
+		commit.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<button>commit</button>
+			<hr>
+		`
+		);
+
+		resolve.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<button>commit</button>
+			<hr>
+			world
+			"world"
+			world
+			world
+			world
+			"world"
+		`
+		);
+
+		resolve.click();
+		await tick();
+		resolve.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+			<button>x</button>
+			<button>y++</button>
+			<button>resolve</button>
+			<button>commit</button>
+			universe
+			universe
+			"universe"
+			universe
+			universe
+			universe
+			"universe"
+			<hr>
+			universe
+			"universe"
+			universe
+			universe
+			universe
+			"universe"
+		`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/main.svelte
new file mode 100644
index 0000000000..5575e3cbd4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/main.svelte
@@ -0,0 +1,36 @@
+<script>
+	import { fork } from 'svelte';
+	import Child from './Child.svelte';
+
+	let x = $state('world');
+	let y = $state(0);
+	let f;
+
+	const deferred = [];
+
+	function delay(value) {
+		if (value !== 'universe') return value;
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+
+	function delay2(value) {
+		return new Promise((resolve) => deferred.push(() => resolve(value)));
+	}
+</script>
+
+<button onclick={() => (f = fork(() => {x = 'universe';}))}>x</button>
+
+<button onclick={() => y++}>y++</button>
+<button onclick={() => deferred.pop()?.()}>resolve</button>
+<button onclick={() => f.commit()}>commit</button>
+
+{#if x === 'universe'}
+	{await delay(x)}
+	<Child {x} />
+{/if}
+
+<hr>
+
+{#if y > 0}
+	<Child x={await delay2(x)} />
+{/if}

From f48e4e2ec503c9b3f1ca2ea8ac12b549a8e93adc Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 23 Mar 2026 21:11:42 -0400
Subject: [PATCH 002/122] WIP

---
 .../src/internal/client/reactivity/batch.js   |  2 +-
 .../src/internal/client/reactivity/effects.js |  3 ++-
 .../src/internal/client/reactivity/sources.js |  2 +-
 .../src/internal/client/reactivity/status.js  |  2 +-
 .../src/internal/client/reactivity/types.d.ts |  5 ++---
 .../svelte/src/internal/client/runtime.js     | 21 +++++++++++--------
 6 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 3b10d6ebe6..cc00df4a5f 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -39,7 +39,7 @@ import { UNINITIALIZED } from '../../../constants.js';
 import { set_signal_status } from './status.js';
 import { legacy_is_updating_store } from './store.js';
 import { invariant } from '../../shared/dev.js';
-import { log_effect_tree } from '../dev/debug.js';
+import { log_effect_tree, root } from '../dev/debug.js';
 
 /** @type {Set<Batch>} */
 const batches = new Set();
diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js
index 54c8a17d79..bf8ae97ca1 100644
--- a/packages/svelte/src/internal/client/reactivity/effects.js
+++ b/packages/svelte/src/internal/client/reactivity/effects.js
@@ -103,7 +103,7 @@ function create_effect(type, fn) {
 		ctx: component_context,
 		deps: null,
 		nodes: null,
-		f: type | DIRTY | CONNECTED,
+		f: type | CLEAN | CONNECTED,
 		first: null,
 		fn,
 		last: null,
@@ -113,6 +113,7 @@ function create_effect(type, fn) {
 		prev: null,
 		teardown: null,
 		wv: 0,
+		rv: -1,
 		ac: null
 	};
 
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 3ccde0f211..279c0cf465 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -371,7 +371,7 @@ function mark_reactions(signal, status, updated_during_traversal) {
 
 				mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
 			}
-		} else if (not_dirty) {
+		} else {
 			var effect = /** @type {Effect} */ (reaction);
 
 			if ((flags & BLOCK_EFFECT) !== 0 && eager_block_effects !== null) {
diff --git a/packages/svelte/src/internal/client/reactivity/status.js b/packages/svelte/src/internal/client/reactivity/status.js
index 024285e73a..b8d2e23b2f 100644
--- a/packages/svelte/src/internal/client/reactivity/status.js
+++ b/packages/svelte/src/internal/client/reactivity/status.js
@@ -8,7 +8,7 @@ const STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
  * @param {number} status
  */
 export function set_signal_status(signal, status) {
-	signal.f = (signal.f & STATUS_MASK) | status;
+	// signal.f = (signal.f & STATUS_MASK) | status;
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/reactivity/types.d.ts b/packages/svelte/src/internal/client/reactivity/types.d.ts
index 8477917991..546a403434 100644
--- a/packages/svelte/src/internal/client/reactivity/types.d.ts
+++ b/packages/svelte/src/internal/client/reactivity/types.d.ts
@@ -11,6 +11,8 @@ import type { Boundary } from '../dom/blocks/boundary';
 export interface Signal {
 	/** Flags bitmask */
 	f: number;
+	/** Read version */
+	rv: number;
 	/** Write version */
 	wv: number;
 }
@@ -20,11 +22,8 @@ export interface Value<V = unknown> extends Signal {
 	equals: Equals;
 	/** Signals that read from this signal */
 	reactions: null | Reaction[];
-	/** Read version */
-	rv: number;
 	/** The latest value for this signal */
 	v: V;
-
 	// dev-only
 	/** A label (e.g. the `foo` in `let foo = $state(...)`) used for `$inspect.trace()` */
 	label?: string;
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 906d68fbf0..5c8f3875af 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -156,26 +156,25 @@ export function increment_write_version() {
 export function is_dirty(reaction) {
 	var flags = reaction.f;
 
-	if ((flags & DIRTY) !== 0) {
-		return true;
-	}
-
 	if (flags & DERIVED) {
 		reaction.f &= ~WAS_MARKED;
 	}
 
-	if ((flags & MAYBE_DIRTY) !== 0) {
-		var dependencies = /** @type {Value[]} */ (reaction.deps);
+	var dependencies = /** @type {Value[]} */ (reaction.deps);
+
+	if (dependencies !== null) {
 		var length = dependencies.length;
 
 		for (var i = 0; i < length; i++) {
 			var dependency = dependencies[i];
 
-			if (is_dirty(/** @type {Derived} */ (dependency))) {
-				update_derived(/** @type {Derived} */ (dependency));
+			if ((dependency.f & DERIVED) !== 0) {
+				if (is_dirty(/** @type {Derived} */ (dependency))) {
+					update_derived(/** @type {Derived} */ (dependency));
+				}
 			}
 
-			if (dependency.wv > reaction.wv) {
+			if (dependency.wv > reaction.rv) {
 				return true;
 			}
 		}
@@ -190,6 +189,8 @@ export function is_dirty(reaction) {
 		}
 	}
 
+	reaction.rv = write_version;
+
 	return false;
 }
 
@@ -254,6 +255,8 @@ export function update_reaction(reaction) {
 	}
 
 	try {
+		reaction.wv = reaction.rv = write_version;
+
 		reaction.f |= REACTION_IS_UPDATING;
 		var fn = /** @type {Function} */ (reaction.fn);
 		var result = fn();

From 8f2613df670693c39958e69eded33c01e18a3326 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 23 Mar 2026 21:26:40 -0400
Subject: [PATCH 003/122] WIP

---
 .../svelte/src/internal/client/reactivity/deriveds.js |  2 +-
 .../svelte/src/internal/client/reactivity/utils.js    | 11 ++++++-----
 packages/svelte/src/internal/client/runtime.js        |  4 ++++
 3 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 5da0df0670..6d2d1326ae 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -87,7 +87,7 @@ export function derived(fn) {
 		f: flags,
 		fn,
 		reactions: null,
-		rv: 0,
+		rv: -1,
 		v: /** @type {V} */ (UNINITIALIZED),
 		wv: 0,
 		parent: parent_derived ?? active_effect,
diff --git a/packages/svelte/src/internal/client/reactivity/utils.js b/packages/svelte/src/internal/client/reactivity/utils.js
index 0d27cb8b84..1eaa12ff45 100644
--- a/packages/svelte/src/internal/client/reactivity/utils.js
+++ b/packages/svelte/src/internal/client/reactivity/utils.js
@@ -25,11 +25,12 @@ function clear_marked(deps) {
  * @param {Set<Effect>} maybe_dirty_effects
  */
 export function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
-	if ((effect.f & DIRTY) !== 0) {
-		dirty_effects.add(effect);
-	} else if ((effect.f & MAYBE_DIRTY) !== 0) {
-		maybe_dirty_effects.add(effect);
-	}
+	dirty_effects.add(effect);
+
+	// if ((effect.f & DIRTY) !== 0) {
+	// } else if ((effect.f & MAYBE_DIRTY) !== 0) {
+	// 	maybe_dirty_effects.add(effect);
+	// }
 
 	// Since we're not executing these effects now, we need to clear any WAS_MARKED flags
 	// so that other batches can correctly reach these effects during their own traversal
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 5c8f3875af..f9eaf7b4e5 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -156,6 +156,10 @@ export function increment_write_version() {
 export function is_dirty(reaction) {
 	var flags = reaction.f;
 
+	if ((flags & REACTION_RAN) === 0) {
+		return true;
+	}
+
 	if (flags & DERIVED) {
 		reaction.f &= ~WAS_MARKED;
 	}

From b5be33b152a9829ce6ac260a664ed75672af5dcd Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 23 Mar 2026 21:36:07 -0400
Subject: [PATCH 004/122] WIP

---
 packages/svelte/src/internal/client/runtime.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index f9eaf7b4e5..49adb5d0ee 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -326,13 +326,13 @@ export function update_reaction(reaction) {
 			// so that they are not added again
 			if (previous_reaction.deps !== null) {
 				for (let i = 0; i < previous_skipped_deps; i += 1) {
-					previous_reaction.deps[i].rv = read_version;
+					// previous_reaction.deps[i].rv = read_version;
 				}
 			}
 
 			if (previous_deps !== null) {
 				for (const dep of previous_deps) {
-					dep.rv = read_version;
+					// dep.rv = read_version;
 				}
 			}
 
@@ -546,7 +546,7 @@ export function get(signal) {
 			if ((active_reaction.f & REACTION_IS_UPDATING) !== 0) {
 				// we're in the effect init/update cycle
 				if (signal.rv < read_version) {
-					signal.rv = read_version;
+					// signal.rv = read_version;
 
 					// If the signal is accessing the same dependencies in the same
 					// order as it did last time, increment `skipped_deps`

From da2ab64f523f75af0db1f916f3347f593b663e7d Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 23 Mar 2026 22:10:50 -0400
Subject: [PATCH 005/122] WIP

---
 packages/svelte/src/internal/client/reactivity/deriveds.js | 7 +++++--
 packages/svelte/src/internal/client/reactivity/sources.js  | 2 +-
 packages/svelte/src/internal/client/runtime.js             | 7 ++++---
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 6d2d1326ae..6ad7139be2 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -23,7 +23,8 @@ import {
 	push_reaction_value,
 	is_destroying_effect,
 	update_effect,
-	remove_reactions
+	remove_reactions,
+	write_version
 } from '../runtime.js';
 import { equals, safe_equals } from './equality.js';
 import * as e from '../errors.js';
@@ -384,11 +385,13 @@ export function execute_derived(derived) {
  * @returns {void}
  */
 export function update_derived(derived) {
+	derived.rv = write_version;
+
 	var old_value = derived.v;
 	var value = execute_derived(derived);
 
 	if (!derived.equals(value)) {
-		derived.wv = increment_write_version();
+		derived.wv = write_version;
 
 		// in a fork, we don't update the underlying value, just `batch_values`.
 		// the underlying value will be updated when the fork is committed.
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 279c0cf465..8f73c99268 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -238,7 +238,7 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			}
 		}
 
-		source.wv = increment_write_version();
+		source.wv = source.rv = increment_write_version();
 
 		// For debugging, in case you want to know which reactions are being scheduled:
 		// log_reactions(source);
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 49adb5d0ee..56eec8b4f3 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -259,8 +259,6 @@ export function update_reaction(reaction) {
 	}
 
 	try {
-		reaction.wv = reaction.rv = write_version;
-
 		reaction.f |= REACTION_IS_UPDATING;
 		var fn = /** @type {Function} */ (reaction.fn);
 		var result = fn();
@@ -464,10 +462,13 @@ export function update_effect(effect) {
 			destroy_effect_children(effect);
 		}
 
+		effect.rv = write_version;
+
 		execute_effect_teardown(effect);
 		var teardown = update_reaction(effect);
 		effect.teardown = typeof teardown === 'function' ? teardown : null;
-		effect.wv = write_version;
+
+		effect.wv = write_version; // TODO should this be assigned before the update?
 
 		// In DEV, increment versions of any sources that were written to during the effect,
 		// so that they are correctly marked as dirty when the effect re-runs

From 55e722d6904c2385cd6a7dfd4bae41a13c2451fd Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 04:46:00 -0400
Subject: [PATCH 006/122] WIP

---
 .../src/internal/client/reactivity/deriveds.js       |  7 ++++---
 .../svelte/src/internal/client/reactivity/effects.js |  2 +-
 .../svelte/src/internal/client/reactivity/sources.js |  3 ++-
 .../svelte/src/internal/client/reactivity/types.d.ts |  6 ++++--
 packages/svelte/src/internal/client/runtime.js       | 12 ++++++------
 5 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 6ad7139be2..d1a5e2fbfa 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -88,9 +88,10 @@ export function derived(fn) {
 		f: flags,
 		fn,
 		reactions: null,
-		rv: -1,
-		v: /** @type {V} */ (UNINITIALIZED),
+		cv: -1,
+		rv: 0,
 		wv: 0,
+		v: /** @type {V} */ (UNINITIALIZED),
 		parent: parent_derived ?? active_effect,
 		ac: null
 	};
@@ -385,7 +386,7 @@ export function execute_derived(derived) {
  * @returns {void}
  */
 export function update_derived(derived) {
-	derived.rv = write_version;
+	derived.cv = write_version;
 
 	var old_value = derived.v;
 	var value = execute_derived(derived);
diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js
index bf8ae97ca1..0f90d3a012 100644
--- a/packages/svelte/src/internal/client/reactivity/effects.js
+++ b/packages/svelte/src/internal/client/reactivity/effects.js
@@ -113,7 +113,7 @@ function create_effect(type, fn) {
 		prev: null,
 		teardown: null,
 		wv: 0,
-		rv: -1,
+		cv: -1,
 		ac: null
 	};
 
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 8f73c99268..5e7e4594b0 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -79,6 +79,7 @@ export function source(v, stack) {
 		v,
 		reactions: null,
 		equals,
+		cv: 0,
 		rv: 0,
 		wv: 0
 	};
@@ -238,7 +239,7 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			}
 		}
 
-		source.wv = source.rv = increment_write_version();
+		source.wv = source.cv = increment_write_version();
 
 		// For debugging, in case you want to know which reactions are being scheduled:
 		// log_reactions(source);
diff --git a/packages/svelte/src/internal/client/reactivity/types.d.ts b/packages/svelte/src/internal/client/reactivity/types.d.ts
index 546a403434..ab458cbadd 100644
--- a/packages/svelte/src/internal/client/reactivity/types.d.ts
+++ b/packages/svelte/src/internal/client/reactivity/types.d.ts
@@ -11,8 +11,8 @@ import type { Boundary } from '../dom/blocks/boundary';
 export interface Signal {
 	/** Flags bitmask */
 	f: number;
-	/** Read version */
-	rv: number;
+	/** Check version */
+	cv: number;
 	/** Write version */
 	wv: number;
 }
@@ -38,6 +38,8 @@ export interface Value<V = unknown> extends Signal {
 	set_during_effect?: boolean;
 	/** A function that retrieves the underlying source, used for each block item signals */
 	trace?: null | (() => void);
+	/** Read version */
+	rv: number;
 }
 
 export interface Reaction extends Signal {
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 56eec8b4f3..805206b0c9 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -178,7 +178,7 @@ export function is_dirty(reaction) {
 				}
 			}
 
-			if (dependency.wv > reaction.rv) {
+			if (dependency.wv > reaction.cv) {
 				return true;
 			}
 		}
@@ -193,7 +193,7 @@ export function is_dirty(reaction) {
 		}
 	}
 
-	reaction.rv = write_version;
+	reaction.cv = write_version;
 
 	return false;
 }
@@ -324,13 +324,13 @@ export function update_reaction(reaction) {
 			// so that they are not added again
 			if (previous_reaction.deps !== null) {
 				for (let i = 0; i < previous_skipped_deps; i += 1) {
-					// previous_reaction.deps[i].rv = read_version;
+					previous_reaction.deps[i].rv = read_version;
 				}
 			}
 
 			if (previous_deps !== null) {
 				for (const dep of previous_deps) {
-					// dep.rv = read_version;
+					dep.rv = read_version;
 				}
 			}
 
@@ -462,7 +462,7 @@ export function update_effect(effect) {
 			destroy_effect_children(effect);
 		}
 
-		effect.rv = write_version;
+		effect.cv = write_version;
 
 		execute_effect_teardown(effect);
 		var teardown = update_reaction(effect);
@@ -547,7 +547,7 @@ export function get(signal) {
 			if ((active_reaction.f & REACTION_IS_UPDATING) !== 0) {
 				// we're in the effect init/update cycle
 				if (signal.rv < read_version) {
-					// signal.rv = read_version;
+					signal.rv = read_version;
 
 					// If the signal is accessing the same dependencies in the same
 					// order as it did last time, increment `skipped_deps`

From 153ced7725e660564d19bf3c0ed8965193a06d15 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 05:07:56 -0400
Subject: [PATCH 007/122] WIP

---
 packages/svelte/src/internal/client/runtime.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 805206b0c9..03f6d9cd23 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -468,6 +468,10 @@ export function update_effect(effect) {
 		var teardown = update_reaction(effect);
 		effect.teardown = typeof teardown === 'function' ? teardown : null;
 
+		if (!is_runes()) {
+			effect.cv = write_version;
+		}
+
 		effect.wv = write_version; // TODO should this be assigned before the update?
 
 		// In DEV, increment versions of any sources that were written to during the effect,

From 75e333fce734b1b46f60dd2fff3bc7919f73e006 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 06:02:36 -0400
Subject: [PATCH 008/122] all legacy tests passing

---
 packages/svelte/src/internal/client/reactivity/deriveds.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index d1a5e2fbfa..82cb215e75 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -386,11 +386,11 @@ export function execute_derived(derived) {
  * @returns {void}
  */
 export function update_derived(derived) {
-	derived.cv = write_version;
-
 	var old_value = derived.v;
 	var value = execute_derived(derived);
 
+	derived.cv = write_version;
+
 	if (!derived.equals(value)) {
 		derived.wv = write_version;
 

From fa580d895aae89ff1a732287f94d1d3718688f77 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 06:27:40 -0400
Subject: [PATCH 009/122] tweak log_effect_tree

---
 packages/svelte/src/internal/client/dev/debug.js | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/dev/debug.js b/packages/svelte/src/internal/client/dev/debug.js
index 83cc510ae2..464780ec34 100644
--- a/packages/svelte/src/internal/client/dev/debug.js
+++ b/packages/svelte/src/internal/client/dev/debug.js
@@ -19,7 +19,7 @@ import {
 	MANAGED_EFFECT
 } from '#client/constants';
 import { snapshot } from '../../shared/clone.js';
-import { untrack } from '../runtime.js';
+import { is_dirty, untrack } from '../runtime.js';
 
 /**
  *
@@ -77,8 +77,15 @@ export function log_effect_tree(effect, highlighted = [], depth = 0, is_reachabl
 	const flags = effect.f;
 	let label = effect_label(effect);
 
-	let status =
-		(flags & CLEAN) !== 0 ? 'clean' : (flags & MAYBE_DIRTY) !== 0 ? 'maybe dirty' : 'dirty';
+	let status = 'clean';
+
+	if ((flags & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0) {
+		if ((flags & CLEAN) === 0) status = 'dirty';
+	} else {
+		if (is_dirty(effect)) {
+			status = 'dirty';
+		}
+	}
 
 	let styles = [`font-weight: ${status === 'clean' ? 'normal' : 'bold'}`];
 

From 5d5ce8b2774c95fb0e15fe656bcd760be718c72d Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 08:06:00 -0400
Subject: [PATCH 010/122] tidy up

---
 .../internal/client/dom/blocks/boundary.js    |  1 -
 .../src/internal/client/reactivity/batch.js   | 11 --------
 .../internal/client/reactivity/deriveds.js    |  4 ---
 .../src/internal/client/reactivity/effects.js | 11 +-------
 .../src/internal/client/reactivity/sources.js | 20 ---------------
 .../src/internal/client/reactivity/status.js  | 25 -------------------
 .../src/internal/client/reactivity/utils.js   | 11 +-------
 .../svelte/src/internal/client/runtime.js     | 19 --------------
 packages/svelte/src/legacy/legacy-client.js   |  4 +--
 9 files changed, 3 insertions(+), 103 deletions(-)
 delete mode 100644 packages/svelte/src/internal/client/reactivity/status.js

diff --git a/packages/svelte/src/internal/client/dom/blocks/boundary.js b/packages/svelte/src/internal/client/dom/blocks/boundary.js
index b440bb3ba4..5d68eed888 100644
--- a/packages/svelte/src/internal/client/dom/blocks/boundary.js
+++ b/packages/svelte/src/internal/client/dom/blocks/boundary.js
@@ -41,7 +41,6 @@ import { tag } from '../../dev/tracing.js';
 import { createSubscriber } from '../../../../reactivity/create-subscriber.js';
 import { create_text } from '../operations.js';
 import { defer_effect } from '../../reactivity/utils.js';
-import { set_signal_status } from '../../reactivity/status.js';
 
 /**
  * @typedef {{
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index cc00df4a5f..e1457e07dd 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -36,7 +36,6 @@ import { flush_eager_effects, old_values, set_eager_effects, source, update } fr
 import { eager_effect, unlink_effect } from './effects.js';
 import { defer_effect } from './utils.js';
 import { UNINITIALIZED } from '../../../constants.js';
-import { set_signal_status } from './status.js';
 import { legacy_is_updating_store } from './store.js';
 import { invariant } from '../../shared/dev.js';
 import { log_effect_tree, root } from '../dev/debug.js';
@@ -222,12 +221,10 @@ export class Batch {
 			this.#skipped_branches.delete(effect);
 
 			for (var e of tracked.d) {
-				set_signal_status(e, DIRTY);
 				this.schedule(e);
 			}
 
 			for (e of tracked.m) {
-				set_signal_status(e, MAYBE_DIRTY);
 				this.schedule(e);
 			}
 		}
@@ -244,12 +241,10 @@ export class Batch {
 		if (!this.#is_deferred()) {
 			for (const e of this.#dirty_effects) {
 				this.#maybe_dirty_effects.delete(e);
-				set_signal_status(e, DIRTY);
 				this.schedule(e);
 			}
 
 			for (const e of this.#maybe_dirty_effects) {
-				set_signal_status(e, MAYBE_DIRTY);
 				this.schedule(e);
 			}
 		}
@@ -928,7 +923,6 @@ function mark_effects(value, sources, marked, checked) {
 				(flags & DIRTY) === 0 &&
 				depends_on(reaction, sources, checked)
 			) {
-				set_signal_status(reaction, DIRTY);
 				schedule_effect(/** @type {Effect} */ (reaction));
 			}
 		}
@@ -951,7 +945,6 @@ function mark_eager_effects(value, effects) {
 		if ((flags & DERIVED) !== 0) {
 			mark_eager_effects(/** @type {Derived} */ (reaction), effects);
 		} else if ((flags & EAGER_EFFECT) !== 0) {
-			set_signal_status(reaction, DIRTY);
 			effects.add(/** @type {Effect} */ (reaction));
 		}
 	}
@@ -1070,8 +1063,6 @@ function reset_branch(effect, tracked) {
 		tracked.m.push(effect);
 	}
 
-	set_signal_status(effect, CLEAN);
-
 	var e = effect.first;
 	while (e !== null) {
 		reset_branch(e, tracked);
@@ -1084,8 +1075,6 @@ function reset_branch(effect, tracked) {
  * @param {Effect} effect
  */
 function reset_all(effect) {
-	set_signal_status(effect, CLEAN);
-
 	var e = effect.first;
 	while (e !== null) {
 		reset_all(e);
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 82cb215e75..d6804d287c 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -44,7 +44,6 @@ import { UNINITIALIZED } from '../../../constants.js';
 import { batch_values, current_batch } from './batch.js';
 import { increment_pending, unset_context } from './async.js';
 import { deferred, includes, noop } from '../../shared/utils.js';
-import { set_signal_status, update_derived_status } from './status.js';
 
 /**
  * This allows us to track 'reactivity loss' that occurs when signals
@@ -404,7 +403,6 @@ export function update_derived(derived) {
 
 			// deriveds without dependencies should never be recomputed
 			if (derived.deps === null) {
-				set_signal_status(derived, CLEAN);
 				return;
 			}
 		}
@@ -424,8 +422,6 @@ export function update_derived(derived) {
 		if (effect_tracking() || current_batch?.is_fork) {
 			batch_values.set(derived, value);
 		}
-	} else {
-		update_derived_status(derived);
 	}
 }
 
diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js
index 0f90d3a012..7f77b0bf20 100644
--- a/packages/svelte/src/internal/client/reactivity/effects.js
+++ b/packages/svelte/src/internal/client/reactivity/effects.js
@@ -45,7 +45,6 @@ import { component_context, dev_current_component_function, dev_stack } from '..
 import { Batch, collected_effects } from './batch.js';
 import { flatten, increment_pending } from './async.js';
 import { without_reactive_context } from '../dom/elements/bindings/shared.js';
-import { set_signal_status } from './status.js';
 
 /**
  * @param {'$effect' | '$effect.pre' | '$inspect'} rune
@@ -191,7 +190,6 @@ export function effect_tracking() {
  */
 export function teardown(fn) {
 	const effect = create_effect(RENDER_EFFECT, null);
-	set_signal_status(effect, CLEAN);
 	effect.teardown = fn;
 	return effect;
 }
@@ -344,12 +342,6 @@ export function legacy_pre_effect_reset() {
 
 			var effect = token.effect;
 
-			// If the effect is CLEAN, then make it MAYBE_DIRTY. This ensures we traverse through
-			// the effects dependencies and correctly ensure each dependency is up-to-date.
-			if ((effect.f & CLEAN) !== 0 && effect.deps !== null) {
-				set_signal_status(effect, MAYBE_DIRTY);
-			}
-
 			if (is_dirty(effect)) {
 				update_effect(effect);
 			}
@@ -522,7 +514,7 @@ export function destroy_effect(effect, remove_dom = true) {
 		removed = true;
 	}
 
-	set_signal_status(effect, DESTROYING);
+	effect.f |= DESTROYING;
 	destroy_effect_children(effect, remove_dom && !removed);
 	remove_reactions(effect, 0);
 
@@ -689,7 +681,6 @@ function resume_children(effect, local) {
 	// here because we don't want to eagerly recompute a derived like
 	// `{#if foo}{foo.bar()}{/if}` if `foo` is now `undefined
 	if ((effect.f & CLEAN) === 0) {
-		set_signal_status(effect, DIRTY);
 		Batch.ensure().schedule(effect); // Assumption: This happens during the commit phase of the batch, causing another flush, but it's safe
 	}
 
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 5e7e4594b0..3e149937e4 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -44,7 +44,6 @@ import {
 } from './batch.js';
 import { proxy } from '../proxy.js';
 import { execute_derived } from './deriveds.js';
-import { set_signal_status, update_derived_status } from './status.js';
 
 /** @type {Set<any>} */
 export let eager_effects = new Set();
@@ -231,12 +230,6 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			if ((source.f & DIRTY) !== 0) {
 				execute_derived(derived);
 			}
-
-			// During time traveling we don't want to reset the status so that
-			// traversal of the graph in the other batches still happens
-			if (batch_values === null) {
-				update_derived_status(derived);
-			}
 		}
 
 		source.wv = source.cv = increment_write_version();
@@ -274,12 +267,6 @@ export function flush_eager_effects() {
 	eager_effects_deferred = false;
 
 	for (const effect of eager_effects) {
-		// Mark clean inspect-effects as maybe dirty and then check their dirtiness
-		// instead of just updating the effects - this way we avoid overfiring.
-		if ((effect.f & CLEAN) !== 0) {
-			set_signal_status(effect, MAYBE_DIRTY);
-		}
-
 		if (is_dirty(effect)) {
 			update_effect(effect);
 		}
@@ -352,13 +339,6 @@ function mark_reactions(signal, status, updated_during_traversal) {
 			continue;
 		}
 
-		var not_dirty = (flags & DIRTY) === 0;
-
-		// don't set a DIRTY reaction to MAYBE_DIRTY
-		if (not_dirty) {
-			set_signal_status(reaction, status);
-		}
-
 		if ((flags & DERIVED) !== 0) {
 			var derived = /** @type {Derived} */ (reaction);
 
diff --git a/packages/svelte/src/internal/client/reactivity/status.js b/packages/svelte/src/internal/client/reactivity/status.js
deleted file mode 100644
index b8d2e23b2f..0000000000
--- a/packages/svelte/src/internal/client/reactivity/status.js
+++ /dev/null
@@ -1,25 +0,0 @@
-/** @import { Derived, Signal } from '#client' */
-import { CLEAN, CONNECTED, DIRTY, MAYBE_DIRTY } from '#client/constants';
-
-const STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
-
-/**
- * @param {Signal} signal
- * @param {number} status
- */
-export function set_signal_status(signal, status) {
-	// signal.f = (signal.f & STATUS_MASK) | status;
-}
-
-/**
- * Set a derived's status to CLEAN or MAYBE_DIRTY based on its connection state.
- * @param {Derived} derived
- */
-export function update_derived_status(derived) {
-	// Only mark as MAYBE_DIRTY if disconnected and has dependencies.
-	if ((derived.f & CONNECTED) !== 0 || derived.deps === null) {
-		set_signal_status(derived, CLEAN);
-	} else {
-		set_signal_status(derived, MAYBE_DIRTY);
-	}
-}
diff --git a/packages/svelte/src/internal/client/reactivity/utils.js b/packages/svelte/src/internal/client/reactivity/utils.js
index 1eaa12ff45..1d9c99a52c 100644
--- a/packages/svelte/src/internal/client/reactivity/utils.js
+++ b/packages/svelte/src/internal/client/reactivity/utils.js
@@ -1,6 +1,5 @@
 /** @import { Derived, Effect, Value } from '#client' */
-import { CLEAN, DERIVED, DIRTY, MAYBE_DIRTY, WAS_MARKED } from '#client/constants';
-import { set_signal_status } from './status.js';
+import { DERIVED, WAS_MARKED } from '#client/constants';
 
 /**
  * @param {Value[] | null} deps
@@ -27,15 +26,7 @@ function clear_marked(deps) {
 export function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
 	dirty_effects.add(effect);
 
-	// if ((effect.f & DIRTY) !== 0) {
-	// } else if ((effect.f & MAYBE_DIRTY) !== 0) {
-	// 	maybe_dirty_effects.add(effect);
-	// }
-
 	// Since we're not executing these effects now, we need to clear any WAS_MARKED flags
 	// so that other batches can correctly reach these effects during their own traversal
 	clear_marked(effect.deps);
-
-	// mark as clean so they get scheduled if they depend on pending async state
-	set_signal_status(effect, CLEAN);
 }
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 03f6d9cd23..49142b50ce 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -57,7 +57,6 @@ import { handle_error } from './error-handling.js';
 import { UNINITIALIZED } from '../../constants.js';
 import { captured_signals } from './legacy.js';
 import { without_reactive_context } from './dom/elements/bindings/shared.js';
-import { set_signal_status, update_derived_status } from './reactivity/status.js';
 import * as w from './warnings.js';
 
 let is_updating_effect = false;
@@ -182,15 +181,6 @@ export function is_dirty(reaction) {
 				return true;
 			}
 		}
-
-		if (
-			(flags & CONNECTED) !== 0 &&
-			// During time traveling we don't want to reset the status so that
-			// traversal of the graph in the other batches still happens
-			batch_values === null
-		) {
-			set_signal_status(reaction, CLEAN);
-		}
 	}
 
 	reaction.cv = write_version;
@@ -217,11 +207,6 @@ function schedule_possible_effect_self_invalidation(signal, effect, root = true)
 		if ((reaction.f & DERIVED) !== 0) {
 			schedule_possible_effect_self_invalidation(/** @type {Derived} */ (reaction), effect, false);
 		} else if (effect === reaction) {
-			if (root) {
-				set_signal_status(reaction, DIRTY);
-			} else if ((reaction.f & CLEAN) !== 0) {
-				set_signal_status(reaction, MAYBE_DIRTY);
-			}
 			schedule_effect(/** @type {Effect} */ (reaction));
 		}
 	}
@@ -404,8 +389,6 @@ function remove_reaction(signal, dependency) {
 			derived.f &= ~WAS_MARKED;
 		}
 
-		update_derived_status(derived);
-
 		// freeze any effects inside this derived
 		freeze_derived_effects(derived);
 
@@ -439,8 +422,6 @@ export function update_effect(effect) {
 		return;
 	}
 
-	set_signal_status(effect, CLEAN);
-
 	var previous_effect = active_effect;
 	var was_updating_effect = is_updating_effect;
 
diff --git a/packages/svelte/src/legacy/legacy-client.js b/packages/svelte/src/legacy/legacy-client.js
index 801c126b2c..1cf1bda61b 100644
--- a/packages/svelte/src/legacy/legacy-client.js
+++ b/packages/svelte/src/legacy/legacy-client.js
@@ -1,5 +1,5 @@
 /** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
-import { DIRTY, LEGACY_PROPS, MAYBE_DIRTY } from '../internal/client/constants.js';
+import { DIRTY, LEGACY_PROPS } from '../internal/client/constants.js';
 import { user_pre_effect } from '../internal/client/reactivity/effects.js';
 import { mutable_source, set } from '../internal/client/reactivity/sources.js';
 import { hydrate, mount, unmount } from '../internal/client/render.js';
@@ -12,7 +12,6 @@ import { DEV } from 'esm-env';
 import { FILENAME } from '../constants.js';
 import { component_context, dev_current_component_function } from '../internal/client/context.js';
 import { async_mode_flag } from '../internal/flags/index.js';
-import { set_signal_status } from '../internal/client/reactivity/status.js';
 
 /**
  * Takes the same options as a Svelte 4 component and the component function and returns a Svelte 4 compatible component.
@@ -199,7 +198,6 @@ export function run(fn) {
 				filename = dev_current_component_function?.[FILENAME] ?? filename;
 			}
 			w.legacy_recursive_reactive_block(filename);
-			set_signal_status(effect, MAYBE_DIRTY);
 		}
 	});
 }

From 7a70030516ae8808892d5adfd1b687a06f6e6f4f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 13:23:56 -0400
Subject: [PATCH 011/122] WIP

---
 .../src/internal/client/reactivity/batch.js   | 41 +++++++++++++------
 .../internal/client/reactivity/deriveds.js    |  2 +-
 2 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index e1457e07dd..9cb6b04bd3 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -95,10 +95,15 @@ export class Batch {
 	 * The current values of any signals that are updated in this batch.
 	 * Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
 	 * They keys of this map are identical to `this.#previous`
-	 * @type {Map<Value, [any, boolean]>}
+	 * @type {Map<Value, any>}
 	 */
 	current = new Map();
 
+	/**
+	 * @type {Map<Derived, any>}
+	 */
+	current_deriveds = new Map();
+
 	/**
 	 * The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
 	 * They keys of this map are identical to `this.#current`
@@ -418,11 +423,27 @@ export class Batch {
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
 		if ((source.f & ERROR_VALUE) === 0) {
-			this.current.set(source, [source.v, is_derived]);
+			this.current.set(source, source.v);
 			batch_values?.set(source, source.v);
 		}
 	}
 
+	/**
+	 * @param {Derived} derived
+	 * @param {any} value
+	 * @deprecated
+	 */
+	capture_derived(derived, value) {
+		if (derived.v !== UNINITIALIZED && !this.previous.has(derived)) {
+			this.previous.set(derived, derived.v);
+		}
+
+		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
+		if ((derived.f & ERROR_VALUE) === 0) {
+			batch_values?.set(derived, value);
+		}
+	}
+
 	activate() {
 		current_batch = this;
 	}
@@ -478,13 +499,13 @@ export class Batch {
 			/** @type {Source[]} */
 			var sources = [];
 
-			for (const [source, [value, is_derived]] of this.current) {
+			for (const [source, value] of this.current) {
 				if (batch.current.has(source)) {
-					var batch_value = /** @type {[any, boolean]} */ (batch.current.get(source))[0]; // faster than destructuring
+					var batch_value = batch.current.get(source);
 
 					if (is_earlier && value !== batch_value) {
 						// bring the value up to date
-						batch.current.set(source, [value, is_derived]);
+						batch.current.set(source, value);
 					} else {
 						// same value or later batch has more recent value,
 						// no need to re-run these effects
@@ -657,7 +678,7 @@ export class Batch {
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
 		batch_values = new Map();
-		for (const [source, [value]] of this.current) {
+		for (const [source, value] of this.current) {
 			batch_values.set(source, value);
 		}
 
@@ -670,11 +691,7 @@ export class Batch {
 			var differs = false;
 
 			if (batch.id < this.id) {
-				for (const [source, [, is_derived]] of batch.current) {
-					// Derived values don't partake in the blocking mechanism, because a derived could
-					// be triggered in one batch already but not the other one yet, causing a false-positive
-					if (is_derived) continue;
-
+				for (const source of batch.current.keys()) {
 					intersects ||= this.current.has(source);
 					differs ||= !this.current.has(source);
 				}
@@ -1140,7 +1157,7 @@ export function fork(fn) {
 			batch.is_fork = false;
 
 			// apply changes and update write versions so deriveds see the change
-			for (var [source, [value]] of batch.current) {
+			for (var [source, value] of batch.current) {
 				source.v = value;
 				source.wv = increment_write_version();
 			}
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index d6804d287c..42dfcb21ad 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -398,8 +398,8 @@ export function update_derived(derived) {
 		// otherwise, the next time we get here after a 'real world' state
 		// change, `derived.equals` may incorrectly return `true`
 		if (!current_batch?.is_fork || derived.deps === null) {
+			current_batch?.capture_derived(derived, value);
 			derived.v = value;
-			current_batch?.capture(derived, old_value, true);
 
 			// deriveds without dependencies should never be recomputed
 			if (derived.deps === null) {

From de94223003397940a69ed48d8378057a32d291c4 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 13:42:07 -0400
Subject: [PATCH 012/122] always create batch_values, for now

---
 packages/svelte/src/internal/client/reactivity/batch.js   | 3 ++-
 packages/svelte/src/internal/client/reactivity/sources.js | 3 +--
 packages/svelte/src/internal/client/reactivity/types.d.ts | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 9cb6b04bd3..456d98b2f6 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -670,7 +670,8 @@ export class Batch {
 	}
 
 	apply() {
-		if (!async_mode_flag || (!this.is_fork && batches.size === 1)) {
+		if (!async_mode_flag) {
+			// TODO previously we bailed here if there was only one (non-fork) batch... maybe we can reinstate that
 			batch_values = null;
 			return;
 		}
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 3e149937e4..debfb2017a 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -78,7 +78,6 @@ export function source(v, stack) {
 		v,
 		reactions: null,
 		equals,
-		cv: 0,
 		rv: 0,
 		wv: 0
 	};
@@ -232,7 +231,7 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			}
 		}
 
-		source.wv = source.cv = increment_write_version();
+		source.wv = increment_write_version();
 
 		// For debugging, in case you want to know which reactions are being scheduled:
 		// log_reactions(source);
diff --git a/packages/svelte/src/internal/client/reactivity/types.d.ts b/packages/svelte/src/internal/client/reactivity/types.d.ts
index ab458cbadd..fbabf9d51f 100644
--- a/packages/svelte/src/internal/client/reactivity/types.d.ts
+++ b/packages/svelte/src/internal/client/reactivity/types.d.ts
@@ -11,8 +11,6 @@ import type { Boundary } from '../dom/blocks/boundary';
 export interface Signal {
 	/** Flags bitmask */
 	f: number;
-	/** Check version */
-	cv: number;
 	/** Write version */
 	wv: number;
 }
@@ -51,6 +49,8 @@ export interface Reaction extends Signal {
 	deps: null | Value[];
 	/** An AbortController that aborts when the signal is destroyed */
 	ac: null | AbortController;
+	/** Check version */
+	cv: number;
 }
 
 export interface Derived<V = unknown> extends Value<V>, Reaction {

From 12235f0300fc5ddced002016e1c9d8af0128ecef Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 16:10:42 -0400
Subject: [PATCH 013/122] WIP

---
 .../src/internal/client/reactivity/batch.js   | 67 ++++++++++++++++---
 .../internal/client/reactivity/deriveds.js    |  8 +--
 .../src/internal/client/reactivity/effects.js |  1 -
 .../src/internal/client/reactivity/sources.js |  9 +--
 .../src/internal/client/reactivity/types.d.ts |  4 +-
 .../svelte/src/internal/client/runtime.js     | 42 +++++++-----
 6 files changed, 92 insertions(+), 39 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 456d98b2f6..beef0b5fa3 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -26,13 +26,21 @@ import {
 	get,
 	increment_write_version,
 	is_dirty,
-	update_effect
+	update_effect,
+	write_version
 } from '../runtime.js';
 import * as e from '../errors.js';
 import { flush_tasks, queue_micro_task } from '../dom/task.js';
 import { DEV } from 'esm-env';
 import { invoke_error_boundary } from '../error-handling.js';
-import { flush_eager_effects, old_values, set_eager_effects, source, update } from './sources.js';
+import {
+	flush_eager_effects,
+	mark_reactions,
+	old_values,
+	set_eager_effects,
+	source,
+	update
+} from './sources.js';
 import { eager_effect, unlink_effect } from './effects.js';
 import { defer_effect } from './utils.js';
 import { UNINITIALIZED } from '../../../constants.js';
@@ -60,6 +68,16 @@ export let previous_batch = null;
  */
 export let batch_values = null;
 
+/**
+ * @type {Map<Reaction, number> | null}
+ */
+export let batch_cvs = null;
+
+/**
+ * @type {Map<Value, number> | null}
+ */
+export let batch_wvs = null;
+
 /** @type {Effect | null} */
 let last_scheduled_effect = null;
 
@@ -161,6 +179,12 @@ export class Batch {
 	 */
 	#maybe_dirty_effects = new Set();
 
+	/** @type {Map<Value, number>} */
+	wvs = new Map();
+
+	/** @type {Map<Reaction, number>} */
+	cvs = new Map();
+
 	/**
 	 * A map of branches that still exist, but will be destroyed when this batch
 	 * is committed — we skip over these during `process`.
@@ -241,6 +265,10 @@ export class Batch {
 			infinite_loop_guard();
 		}
 
+		for (const source of this.current.keys()) {
+			mark_reactions(source, null);
+		}
+
 		// we only reschedule previously-deferred effects if we expect
 		// to be able to run them after processing the batch
 		if (!this.#is_deferred()) {
@@ -414,9 +442,8 @@ export class Batch {
 	 * batch, noting its previous and current values
 	 * @param {Value} source
 	 * @param {any} old_value
-	 * @param {boolean} [is_derived]
 	 */
-	capture(source, old_value, is_derived = false) {
+	capture(source, old_value) {
 		if (old_value !== UNINITIALIZED && !this.previous.has(source)) {
 			this.previous.set(source, old_value);
 		}
@@ -426,6 +453,11 @@ export class Batch {
 			this.current.set(source, source.v);
 			batch_values?.set(source, source.v);
 		}
+
+		var version = increment_write_version();
+
+		source.wv = version;
+		this.wvs.set(source, version);
 	}
 
 	/**
@@ -450,7 +482,7 @@ export class Batch {
 
 	deactivate() {
 		current_batch = null;
-		batch_values = null;
+		batch_values = batch_cvs = batch_wvs = null;
 	}
 
 	flush() {
@@ -469,7 +501,7 @@ export class Batch {
 			is_processing = false;
 
 			current_batch = null;
-			batch_values = null;
+			batch_values = batch_cvs = batch_wvs = null;
 
 			old_values.clear();
 
@@ -672,7 +704,7 @@ export class Batch {
 	apply() {
 		if (!async_mode_flag) {
 			// TODO previously we bailed here if there was only one (non-fork) batch... maybe we can reinstate that
-			batch_values = null;
+			batch_values = batch_cvs = batch_wvs = null;
 			return;
 		}
 
@@ -683,6 +715,9 @@ export class Batch {
 			batch_values.set(source, value);
 		}
 
+		batch_cvs = this.cvs;
+		batch_wvs = this.wvs;
+
 		// ...and undo changes belonging to other batches unless they block this one
 		for (const batch of batches) {
 			if (batch === this || batch.is_fork) continue;
@@ -717,6 +752,10 @@ export class Batch {
 	schedule(effect) {
 		last_scheduled_effect = effect;
 
+		if (!this.cvs.has(effect)) {
+			this.cvs.set(effect, effect.cv);
+		}
+
 		// defer render effects inside a pending boundary
 		// TODO the `REACTION_RAN` check is only necessary because of legacy `$:` effects AFAICT — we can remove later
 		if (
@@ -1036,12 +1075,16 @@ export function eager(fn) {
 			// the first time this runs, we create an eager effect
 			// that will run eagerly whenever the expression changes
 			var previous_batch_values = batch_values;
+			var previous_batch_cvs = batch_cvs;
+			var previous_batch_wvs = batch_wvs;
 
 			try {
-				batch_values = null;
+				batch_values = batch_cvs = batch_wvs = null;
 				value = fn();
 			} finally {
 				batch_values = previous_batch_values;
+				batch_cvs = previous_batch_cvs;
+				batch_wvs = previous_batch_wvs;
 			}
 
 			return;
@@ -1198,6 +1241,14 @@ export function fork(fn) {
 	};
 }
 
+/**
+ * @param {Reaction} reaction
+ */
+export function set_cv(reaction) {
+	batch_cvs?.set(reaction, write_version);
+	reaction.cv = write_version;
+}
+
 /**
  * Forcibly remove all current batches, to prevent cross-talk between tests
  */
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 42dfcb21ad..aa5f1b8aae 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -41,7 +41,7 @@ import { get_error } from '../../shared/dev.js';
 import { async_mode_flag, tracing_mode_flag } from '../../flags/index.js';
 import { component_context } from '../context.js';
 import { UNINITIALIZED } from '../../../constants.js';
-import { batch_values, current_batch } from './batch.js';
+import { batch_values, batch_wvs, current_batch, set_cv } from './batch.js';
 import { increment_pending, unset_context } from './async.js';
 import { deferred, includes, noop } from '../../shared/utils.js';
 
@@ -120,7 +120,7 @@ export function async_derived(fn, label, location) {
 	var promise = /** @type {Promise<V>} */ (/** @type {unknown} */ (undefined));
 	var signal = source(/** @type {V} */ (UNINITIALIZED));
 
-	if (DEV) signal.label = label;
+	if (DEV) signal.label = label ?? '{await ...}';
 
 	// only suspend in async deriveds created on initialisation
 	var should_suspend = !active_reaction;
@@ -385,12 +385,12 @@ export function execute_derived(derived) {
  * @returns {void}
  */
 export function update_derived(derived) {
-	var old_value = derived.v;
 	var value = execute_derived(derived);
 
-	derived.cv = write_version;
+	set_cv(derived);
 
 	if (!derived.equals(value)) {
+		batch_wvs?.set(derived, write_version);
 		derived.wv = write_version;
 
 		// in a fork, we don't update the underlying value, just `batch_values`.
diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js
index 7f77b0bf20..970cc9a640 100644
--- a/packages/svelte/src/internal/client/reactivity/effects.js
+++ b/packages/svelte/src/internal/client/reactivity/effects.js
@@ -111,7 +111,6 @@ function create_effect(type, fn) {
 		b: parent && parent.b,
 		prev: null,
 		teardown: null,
-		wv: 0,
 		cv: -1,
 		ac: null
 	};
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index debfb2017a..b048f3c5fe 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -231,11 +231,9 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			}
 		}
 
-		source.wv = increment_write_version();
-
 		// For debugging, in case you want to know which reactions are being scheduled:
 		// log_reactions(source);
-		mark_reactions(source, DIRTY, updated_during_traversal);
+		mark_reactions(source, updated_during_traversal);
 
 		// It's possible that the current reaction might not have up-to-date dependencies
 		// whilst it's actively running. So in the case of ensuring it registers the reaction
@@ -314,11 +312,10 @@ export function increment(source) {
 
 /**
  * @param {Value} signal
- * @param {number} status should be DIRTY or MAYBE_DIRTY
  * @param {Effect[] | null} updated_during_traversal
  * @returns {void}
  */
-function mark_reactions(signal, status, updated_during_traversal) {
+export function mark_reactions(signal, updated_during_traversal) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
 
@@ -349,7 +346,7 @@ function mark_reactions(signal, status, updated_during_traversal) {
 					reaction.f |= WAS_MARKED;
 				}
 
-				mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
+				mark_reactions(derived, updated_during_traversal);
 			}
 		} else {
 			var effect = /** @type {Effect} */ (reaction);
diff --git a/packages/svelte/src/internal/client/reactivity/types.d.ts b/packages/svelte/src/internal/client/reactivity/types.d.ts
index fbabf9d51f..fec23c69ff 100644
--- a/packages/svelte/src/internal/client/reactivity/types.d.ts
+++ b/packages/svelte/src/internal/client/reactivity/types.d.ts
@@ -11,8 +11,6 @@ import type { Boundary } from '../dom/blocks/boundary';
 export interface Signal {
 	/** Flags bitmask */
 	f: number;
-	/** Write version */
-	wv: number;
 }
 
 export interface Value<V = unknown> extends Signal {
@@ -36,6 +34,8 @@ export interface Value<V = unknown> extends Signal {
 	set_during_effect?: boolean;
 	/** A function that retrieves the underlying source, used for each block item signals */
 	trace?: null | (() => void);
+	/** Write version */
+	wv: number;
 	/** Read version */
 	rv: number;
 }
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 49142b50ce..19c4fa1ebe 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -48,10 +48,13 @@ import {
 } from './context.js';
 import {
 	Batch,
+	batch_cvs,
 	batch_values,
+	batch_wvs,
 	current_batch,
 	flushSync,
-	schedule_effect
+	schedule_effect,
+	set_cv
 } from './reactivity/batch.js';
 import { handle_error } from './error-handling.js';
 import { UNINITIALIZED } from '../../constants.js';
@@ -165,26 +168,31 @@ export function is_dirty(reaction) {
 
 	var dependencies = /** @type {Value[]} */ (reaction.deps);
 
-	if (dependencies !== null) {
-		var length = dependencies.length;
+	if (dependencies === null) {
+		return false;
+	}
 
-		for (var i = 0; i < length; i++) {
-			var dependency = dependencies[i];
+	var cv = batch_cvs?.get(reaction) ?? reaction.cv;
 
-			if ((dependency.f & DERIVED) !== 0) {
-				if (is_dirty(/** @type {Derived} */ (dependency))) {
-					update_derived(/** @type {Derived} */ (dependency));
-				}
-			}
+	var length = dependencies.length;
 
-			if (dependency.wv > reaction.cv) {
-				return true;
+	for (var i = 0; i < length; i++) {
+		var dependency = dependencies[i];
+
+		if ((dependency.f & DERIVED) !== 0) {
+			if (is_dirty(/** @type {Derived} */ (dependency))) {
+				update_derived(/** @type {Derived} */ (dependency));
 			}
 		}
-	}
 
-	reaction.cv = write_version;
+		var wv = batch_wvs?.get(dependency) ?? dependency.wv;
 
+		if (wv > cv) {
+			return true;
+		}
+	}
+
+	set_cv(reaction);
 	return false;
 }
 
@@ -443,18 +451,16 @@ export function update_effect(effect) {
 			destroy_effect_children(effect);
 		}
 
-		effect.cv = write_version;
+		set_cv(effect);
 
 		execute_effect_teardown(effect);
 		var teardown = update_reaction(effect);
 		effect.teardown = typeof teardown === 'function' ? teardown : null;
 
 		if (!is_runes()) {
-			effect.cv = write_version;
+			set_cv(effect);
 		}
 
-		effect.wv = write_version; // TODO should this be assigned before the update?
-
 		// In DEV, increment versions of any sources that were written to during the effect,
 		// so that they are correctly marked as dirty when the effect re-runs
 		if (DEV && tracing_mode_flag && (effect.f & DIRTY) !== 0 && effect.deps !== null) {

From b40b63af7427b45032ecc0c851e52dd4693cc350 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 19:02:54 -0400
Subject: [PATCH 014/122] WIP

---
 .../src/internal/client/reactivity/batch.js   |  2 +-
 .../internal/client/reactivity/deriveds.js    |  2 +-
 .../src/internal/client/reactivity/sources.js | 31 ++++++++++++-------
 3 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index beef0b5fa3..c929fba7b5 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1245,7 +1245,7 @@ export function fork(fn) {
  * @param {Reaction} reaction
  */
 export function set_cv(reaction) {
-	batch_cvs?.set(reaction, write_version);
+	current_batch?.cvs.set(reaction, write_version);
 	reaction.cv = write_version;
 }
 
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index aa5f1b8aae..058d8ee4c4 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -390,7 +390,7 @@ export function update_derived(derived) {
 	set_cv(derived);
 
 	if (!derived.equals(value)) {
-		batch_wvs?.set(derived, write_version);
+		current_batch?.wvs.set(derived, write_version);
 		derived.wv = write_version;
 
 		// in a fork, we don't update the underlying value, just `batch_values`.
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index b048f3c5fe..fec3100786 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -13,7 +13,8 @@ import {
 	is_dirty,
 	untracking,
 	is_destroying_effect,
-	push_reaction_value
+	push_reaction_value,
+	write_version
 } from '../runtime.js';
 import { equals, safe_equals } from './equality.js';
 import {
@@ -40,10 +41,12 @@ import {
 	batch_values,
 	eager_block_effects,
 	schedule_effect,
-	legacy_updates
+	legacy_updates,
+	set_cv
 } from './batch.js';
 import { proxy } from '../proxy.js';
 import { execute_derived } from './deriveds.js';
+import { UNINITIALIZED } from '../../../constants.js';
 
 /** @type {Set<any>} */
 export let eager_effects = new Set();
@@ -179,6 +182,7 @@ export function set(source, value, should_proxy = false) {
  */
 export function internal_set(source, value, updated_during_traversal = null) {
 	if (!source.equals(value)) {
+		var batch = Batch.ensure();
 		var old_value = source.v;
 
 		if (is_destroying_effect) {
@@ -187,9 +191,21 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			old_values.set(source, old_value);
 		}
 
+		if ((source.f & DERIVED) !== 0) {
+			const derived = /** @type {Derived} */ (source);
+
+			if (derived.v === UNINITIALIZED) {
+				// assigning before first read — execute to track dependencies
+				execute_derived(derived);
+			}
+
+			set_cv(derived);
+			batch.wvs.set(derived, write_version);
+			derived.wv = write_version;
+		}
+
 		source.v = value;
 
-		var batch = Batch.ensure();
 		batch.capture(source, old_value);
 
 		if (DEV) {
@@ -222,15 +238,6 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			}
 		}
 
-		if ((source.f & DERIVED) !== 0) {
-			const derived = /** @type {Derived} */ (source);
-
-			// if we are assigning to a dirty derived we set it to clean/maybe dirty but we also eagerly execute it to track the dependencies
-			if ((source.f & DIRTY) !== 0) {
-				execute_derived(derived);
-			}
-		}
-
 		// For debugging, in case you want to know which reactions are being scheduled:
 		// log_reactions(source);
 		mark_reactions(source, updated_during_traversal);

From 7f181523b1f76b1549a319c326d74f1ffcd1d1d0 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 19:11:50 -0400
Subject: [PATCH 015/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index c929fba7b5..ffd4ddbdf9 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -260,6 +260,8 @@ export class Batch {
 	}
 
 	#process() {
+		current_batch = this;
+
 		if (flush_count++ > 1000) {
 			batches.delete(this);
 			infinite_loop_guard();
@@ -490,8 +492,6 @@ export class Batch {
 
 		try {
 			is_processing = true;
-			current_batch = this;
-
 			this.#process();
 		} finally {
 			flush_count = 0;

From 37b9a964b590e7d34fe3451f485655b8b6d9fd77 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 24 Mar 2026 20:50:38 -0400
Subject: [PATCH 016/122] WIP

---
 .../src/internal/client/reactivity/batch.js   | 30 +++++++++++++++----
 .../internal/client/reactivity/deriveds.js    |  3 +-
 2 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index ffd4ddbdf9..957878dce4 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -185,6 +185,12 @@ export class Batch {
 	/** @type {Map<Reaction, number>} */
 	cvs = new Map();
 
+	/** @type {Map<Value, number>} */
+	previous_wvs = new Map();
+
+	/** @type {Map<Reaction, number>} */
+	previous_cvs = new Map();
+
 	/**
 	 * A map of branches that still exist, but will be destroyed when this batch
 	 * is committed — we skip over these during `process`.
@@ -448,6 +454,7 @@ export class Batch {
 	capture(source, old_value) {
 		if (old_value !== UNINITIALIZED && !this.previous.has(source)) {
 			this.previous.set(source, old_value);
+			this.previous_wvs.set(source, source.wv);
 		}
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
@@ -470,6 +477,7 @@ export class Batch {
 	capture_derived(derived, value) {
 		if (derived.v !== UNINITIALIZED && !this.previous.has(derived)) {
 			this.previous.set(derived, derived.v);
+			this.previous_cvs.set(derived, derived.cv);
 		}
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
@@ -710,13 +718,10 @@ export class Batch {
 
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
-		batch_values = new Map();
-		for (const [source, value] of this.current) {
-			batch_values.set(source, value);
-		}
+		batch_values = new Map(this.current);
 
-		batch_cvs = this.cvs;
-		batch_wvs = this.wvs;
+		batch_cvs = new Map(this.cvs);
+		batch_wvs = new Map(this.wvs);
 
 		// ...and undo changes belonging to other batches unless they block this one
 		for (const batch of batches) {
@@ -741,6 +746,18 @@ export class Batch {
 						batch_values.set(source, previous);
 					}
 				}
+
+				for (const [reaction, cv] of batch.previous_cvs) {
+					if (!batch_cvs.has(reaction)) {
+						batch_cvs.set(reaction, cv);
+					}
+				}
+
+				for (const [value, wv] of batch.previous_wvs) {
+					if (!batch_wvs.has(value)) {
+						batch_wvs.set(value, wv);
+					}
+				}
 			}
 		}
 	}
@@ -1246,6 +1263,7 @@ export function fork(fn) {
  */
 export function set_cv(reaction) {
 	current_batch?.cvs.set(reaction, write_version);
+	batch_cvs?.set(reaction, write_version);
 	reaction.cv = write_version;
 }
 
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 058d8ee4c4..12a853ea4b 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -11,14 +11,12 @@ import {
 	ASYNC,
 	WAS_MARKED,
 	DESTROYED,
-	CLEAN,
 	REACTION_RAN
 } from '#client/constants';
 import {
 	active_reaction,
 	active_effect,
 	update_reaction,
-	increment_write_version,
 	set_active_effect,
 	push_reaction_value,
 	is_destroying_effect,
@@ -391,6 +389,7 @@ export function update_derived(derived) {
 
 	if (!derived.equals(value)) {
 		current_batch?.wvs.set(derived, write_version);
+		batch_wvs?.set(derived, write_version);
 		derived.wv = write_version;
 
 		// in a fork, we don't update the underlying value, just `batch_values`.

From f86bf0d191be00cb0c280387b1519997455c466b Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 25 Mar 2026 05:32:16 -0400
Subject: [PATCH 017/122] WIP

---
 .../src/internal/client/reactivity/batch.js   | 23 +++++++++++++++++++
 .../svelte/src/internal/client/runtime.js     |  1 -
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 957878dce4..20720d5182 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -760,6 +760,29 @@ export class Batch {
 				}
 			}
 		}
+
+		// console.group('batch_values');
+		// for (const [value, v] of batch_values) {
+		// 	console.log(this.current.has(value), value.label, v);
+		// }
+		// console.groupEnd();
+
+		// console.group('batch_cvs');
+		// for (const [reaction, cv] of batch_cvs) {
+		// 	console.log(
+		// 		this.cvs.has(reaction),
+		// 		cv,
+		// 		reaction.deps?.map((d) => d.label),
+		// 		reaction.label ?? reaction.fn
+		// 	);
+		// }
+		// console.groupEnd();
+
+		// console.group('batch_wvs');
+		// for (const [value, wv] of batch_wvs) {
+		// 	console.log(this.wvs.has(value), wv, value.label);
+		// }
+		// console.groupEnd();
 	}
 
 	/**
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 19c4fa1ebe..12206742ec 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -192,7 +192,6 @@ export function is_dirty(reaction) {
 		}
 	}
 
-	set_cv(reaction);
 	return false;
 }
 

From 144611a18c5b80c2ef599352f5c494827edaa95f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 25 Mar 2026 07:05:02 -0400
Subject: [PATCH 018/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 4 ++++
 packages/svelte/src/internal/client/runtime.js          | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 20720d5182..1eb32b8721 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -266,6 +266,8 @@ export class Batch {
 	}
 
 	#process() {
+		// console.group('process', this.id);
+
 		current_batch = this;
 
 		if (flush_count++ > 1000) {
@@ -382,6 +384,8 @@ export class Batch {
 		if (!batches.has(this)) {
 			this.#commit();
 		}
+
+		// console.groupEnd();
 	}
 
 	/**
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 12206742ec..15b955ff6d 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -158,6 +158,10 @@ export function increment_write_version() {
 export function is_dirty(reaction) {
 	var flags = reaction.f;
 
+	if ((flags & REACTION_IS_UPDATING) !== 0) {
+		return false;
+	}
+
 	if ((flags & REACTION_RAN) === 0) {
 		return true;
 	}

From afa5af06c95b740820e05e5d2a5ea84360960ed1 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 25 Mar 2026 07:27:48 -0400
Subject: [PATCH 019/122] WIP

---
 .../svelte/src/internal/client/dev/tracing.js |  3 ++-
 .../src/internal/client/reactivity/batch.js   | 22 +++++++++++++++----
 .../svelte/src/internal/client/runtime.js     | 12 +++++++---
 3 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/packages/svelte/src/internal/client/dev/tracing.js b/packages/svelte/src/internal/client/dev/tracing.js
index c6edfde933..b0bd7a4a8e 100644
--- a/packages/svelte/src/internal/client/dev/tracing.js
+++ b/packages/svelte/src/internal/client/dev/tracing.js
@@ -4,6 +4,7 @@ import { snapshot } from '../../shared/clone.js';
 import { DERIVED, ASYNC, PROXY_PATH_SYMBOL, STATE_SYMBOL } from '#client/constants';
 import { effect_tracking } from '../reactivity/effects.js';
 import { active_reaction, untrack } from '../runtime.js';
+import { get_cv, get_wv } from '../reactivity/batch.js';
 
 /**
  * @typedef {{
@@ -27,7 +28,7 @@ function log_entry(signal, entry) {
 
 	const type = get_type(signal);
 	const current_reaction = /** @type {Reaction} */ (active_reaction);
-	const dirty = signal.wv > current_reaction.wv || current_reaction.wv === 0;
+	const dirty = get_wv(signal) > get_cv(current_reaction);
 	const style = dirty
 		? 'color: CornflowerBlue; font-weight: bold'
 		: 'color: grey; font-weight: normal';
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 1eb32b8721..f0b8d011bc 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1285,13 +1285,27 @@ export function fork(fn) {
 	};
 }
 
+/**
+ * @param {Value} value
+ */
+export function get_wv(value) {
+	return batch_wvs?.get(value) ?? value.wv;
+}
+
+/**
+ * @param {Reaction} reaction
+ */
+export function get_cv(reaction) {
+	return batch_cvs?.get(reaction) ?? reaction.cv;
+}
+
 /**
  * @param {Reaction} reaction
  */
-export function set_cv(reaction) {
-	current_batch?.cvs.set(reaction, write_version);
-	batch_cvs?.set(reaction, write_version);
-	reaction.cv = write_version;
+export function set_cv(reaction, cv = write_version) {
+	current_batch?.cvs.set(reaction, cv);
+	batch_cvs?.set(reaction, cv);
+	reaction.cv = cv;
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 15b955ff6d..8cf03a1ae9 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -53,6 +53,7 @@ import {
 	batch_wvs,
 	current_batch,
 	flushSync,
+	get_cv,
 	schedule_effect,
 	set_cv
 } from './reactivity/batch.js';
@@ -176,7 +177,7 @@ export function is_dirty(reaction) {
 		return false;
 	}
 
-	var cv = batch_cvs?.get(reaction) ?? reaction.cv;
+	var cv = get_cv(reaction);
 
 	var length = dependencies.length;
 
@@ -454,13 +455,18 @@ export function update_effect(effect) {
 			destroy_effect_children(effect);
 		}
 
-		set_cv(effect);
+		// get this now, so that any writes during execution cause a re-run,
+		// but don't set it yet so that `$inspect.trace` works
+		const cv = write_version;
 
 		execute_effect_teardown(effect);
 		var teardown = update_reaction(effect);
 		effect.teardown = typeof teardown === 'function' ? teardown : null;
 
-		if (!is_runes()) {
+		if (is_runes()) {
+			set_cv(effect, cv);
+		} else {
+			// in legacy mode, prevent the effect re-running immediately
 			set_cv(effect);
 		}
 

From d0b8903d9079b533e6dbaab8948b4be8d22661c5 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 25 Mar 2026 10:38:37 -0400
Subject: [PATCH 020/122] WIP

---
 .../internal/client/reactivity/deriveds.js    | 19 ++++++++++---------
 .../svelte/src/internal/client/runtime.js     |  8 +++++++-
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 12a853ea4b..7e3f610d62 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -315,9 +315,9 @@ export function destroy_derived_effects(derived) {
 /**
  * The currently updating deriveds, used to detect infinite recursion
  * in dev mode and provide a nicer error than 'too much recursion'
- * @type {Derived[]}
+ * @type {Derived[] | null}
  */
-let stack = [];
+export let derived_stack = null;
 
 /**
  * @param {Derived} derived
@@ -347,31 +347,32 @@ export function execute_derived(derived) {
 
 	set_active_effect(get_derived_parent_effect(derived));
 
+	derived_stack ??= [];
+
 	if (DEV) {
+		// TODO don't we need eager effects in prod too?
 		let prev_eager_effects = eager_effects;
 		set_eager_effects(new Set());
-		try {
-			if (includes.call(stack, derived)) {
-				e.derived_references_self();
-			}
-
-			stack.push(derived);
 
+		try {
+			derived_stack.push(derived);
 			derived.f &= ~WAS_MARKED;
 			destroy_derived_effects(derived);
 			value = update_reaction(derived);
 		} finally {
 			set_active_effect(prev_active_effect);
 			set_eager_effects(prev_eager_effects);
-			stack.pop();
+			derived_stack.pop();
 		}
 	} else {
 		try {
+			derived_stack.push(derived);
 			derived.f &= ~WAS_MARKED;
 			destroy_derived_effects(derived);
 			value = update_reaction(derived);
 		} finally {
 			set_active_effect(prev_active_effect);
+			derived_stack.pop();
 		}
 	}
 
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 8cf03a1ae9..91e9a4db7a 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -32,7 +32,8 @@ import {
 	freeze_derived_effects,
 	recent_async_deriveds,
 	unfreeze_derived_effects,
-	update_derived
+	update_derived,
+	derived_stack
 } from './reactivity/deriveds.js';
 import { async_mode_flag, tracing_mode_flag } from '../flags/index.js';
 import { tracing_expressions } from './dev/tracing.js';
@@ -62,6 +63,7 @@ import { UNINITIALIZED } from '../../constants.js';
 import { captured_signals } from './legacy.js';
 import { without_reactive_context } from './dom/elements/bindings/shared.js';
 import * as w from './warnings.js';
+import * as e from './errors.js';
 
 let is_updating_effect = false;
 
@@ -634,6 +636,10 @@ export function get(signal) {
 	if (is_derived) {
 		var derived = /** @type {Derived} */ (signal);
 
+		if (derived_stack !== null && includes.call(derived_stack, derived)) {
+			e.derived_references_self();
+		}
+
 		if (is_destroying_effect) {
 			var value = derived.v;
 

From 4bf3ad745f4f3727692651bcdfe37914d89aca4b Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 25 Mar 2026 12:09:43 -0400
Subject: [PATCH 021/122] WIP

---
 .../svelte/src/internal/client/constants.js   |  1 +
 .../svelte/src/internal/client/runtime.js     |  9 ++--
 packages/svelte/src/legacy/legacy-client.js   | 51 +++++++++++++++----
 3 files changed, 46 insertions(+), 15 deletions(-)

diff --git a/packages/svelte/src/internal/client/constants.js b/packages/svelte/src/internal/client/constants.js
index df96f4899b..2c20fe7a7e 100644
--- a/packages/svelte/src/internal/client/constants.js
+++ b/packages/svelte/src/internal/client/constants.js
@@ -31,6 +31,7 @@ export const DESTROYED = 1 << 14;
 export const REACTION_RAN = 1 << 15;
 /** Effect is in the process of getting destroyed. Can be observed in child teardown functions */
 export const DESTROYING = 1 << 25;
+export const EFFECT_LEGACY = 1 << 26;
 
 // Flags exclusive to effects
 /**
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 91e9a4db7a..41fa443c8f 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -23,7 +23,8 @@ import {
 	ERROR_VALUE,
 	WAS_MARKED,
 	MANAGED_EFFECT,
-	REACTION_RAN
+	REACTION_RAN,
+	EFFECT_LEGACY
 } from './constants.js';
 import { old_values } from './reactivity/sources.js';
 import {
@@ -116,9 +117,9 @@ export function push_reaction_value(value) {
  * and until a new dependency is accessed — we track this via `skipped_deps`
  * @type {null | Value[]}
  */
-let new_deps = null;
+export let new_deps = null;
 
-let skipped_deps = 0;
+export let skipped_deps = 0;
 
 /**
  * Tracks writes that the effect it's executed in doesn't listen to yet,
@@ -465,7 +466,7 @@ export function update_effect(effect) {
 		var teardown = update_reaction(effect);
 		effect.teardown = typeof teardown === 'function' ? teardown : null;
 
-		if (is_runes()) {
+		if (is_runes() && (effect.f & EFFECT_LEGACY) === 0) {
 			set_cv(effect, cv);
 		} else {
 			// in legacy mode, prevent the effect re-running immediately
diff --git a/packages/svelte/src/legacy/legacy-client.js b/packages/svelte/src/legacy/legacy-client.js
index 1cf1bda61b..1fdbc1f5c3 100644
--- a/packages/svelte/src/legacy/legacy-client.js
+++ b/packages/svelte/src/legacy/legacy-client.js
@@ -1,10 +1,18 @@
 /** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
-import { DIRTY, LEGACY_PROPS } from '../internal/client/constants.js';
+/** @import { Derived, Value } from '#client' */
+import { DERIVED, DIRTY, EFFECT_LEGACY, LEGACY_PROPS } from '../internal/client/constants.js';
 import { user_pre_effect } from '../internal/client/reactivity/effects.js';
 import { mutable_source, set } from '../internal/client/reactivity/sources.js';
 import { hydrate, mount, unmount } from '../internal/client/render.js';
-import { active_effect, get } from '../internal/client/runtime.js';
-import { flushSync } from '../internal/client/reactivity/batch.js';
+import {
+	active_effect,
+	get,
+	new_deps,
+	skipped_deps,
+	untracked_writes,
+	write_version
+} from '../internal/client/runtime.js';
+import { flushSync, get_cv } from '../internal/client/reactivity/batch.js';
 import { define_property, is_array } from '../internal/shared/utils.js';
 import * as e from '../internal/client/errors.js';
 import * as w from '../internal/client/warnings.js';
@@ -188,16 +196,37 @@ class Svelte4Component {
  */
 export function run(fn) {
 	user_pre_effect(() => {
-		fn();
 		var effect = /** @type {import('#client').Effect} */ (active_effect);
-		// If the effect is immediately made dirty again, mark it as maybe dirty to emulate legacy behaviour
-		if ((effect.f & DIRTY) !== 0) {
-			let filename = "a file (we can't know which one)";
-			if (DEV) {
-				// @ts-ignore
-				filename = dev_current_component_function?.[FILENAME] ?? filename;
+
+		// we need this to prevent it from re-running
+		effect.f |= EFFECT_LEGACY;
+
+		fn();
+
+		if (untracked_writes !== null) {
+			/** @type {Set<Value>} */
+			const all_deps = new Set([...(effect.deps ?? [].slice(skipped_deps)), ...(new_deps ?? [])]);
+
+			/** @param {Value} dep */
+			const add_deps = (dep) => {
+				all_deps.add(dep);
+
+				if ((dep.f & DERIVED) !== 0) {
+					const deps = /** @type {Derived} */ (dep).deps;
+					if (deps !== null) deps.forEach(add_deps);
+				}
+			};
+
+			for (const dep of all_deps) {
+				if (untracked_writes.includes(dep)) {
+					let filename = "a file (we can't know which one)";
+					if (DEV) {
+						// @ts-ignore
+						filename = dev_current_component_function?.[FILENAME] ?? filename;
+					}
+					w.legacy_recursive_reactive_block(filename);
+				}
 			}
-			w.legacy_recursive_reactive_block(filename);
 		}
 	});
 }

From 92ae2c3f885b6b4685c544f1a95091bf67c13678 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 25 Mar 2026 12:46:32 -0400
Subject: [PATCH 022/122] WIP

---
 .../src/internal/client/reactivity/batch.js    | 18 +++++++++++-------
 .../src/internal/client/reactivity/sources.js  |  4 +---
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index f0b8d011bc..f4987c6daa 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -453,24 +453,28 @@ export class Batch {
 	 * Associate a change to a given source with the current
 	 * batch, noting its previous and current values
 	 * @param {Value} source
-	 * @param {any} old_value
+	 * @param {any} value
 	 */
-	capture(source, old_value) {
-		if (old_value !== UNINITIALIZED && !this.previous.has(source)) {
-			this.previous.set(source, old_value);
+	capture(source, value) {
+		if (source.v !== UNINITIALIZED && !this.previous.has(source)) {
+			this.previous.set(source, source.v);
 			this.previous_wvs.set(source, source.wv);
 		}
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
 		if ((source.f & ERROR_VALUE) === 0) {
-			this.current.set(source, source.v);
-			batch_values?.set(source, source.v);
+			this.current.set(source, value);
+			batch_values?.set(source, value);
 		}
 
 		var version = increment_write_version();
 
-		source.wv = version;
 		this.wvs.set(source, version);
+
+		if (!this.is_fork) {
+			source.v = value;
+			source.wv = version;
+		}
 	}
 
 	/**
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index fec3100786..41af83456f 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -204,9 +204,7 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			derived.wv = write_version;
 		}
 
-		source.v = value;
-
-		batch.capture(source, old_value);
+		batch.capture(source, value);
 
 		if (DEV) {
 			if (tracing_mode_flag || active_effect !== null) {

From 4ed6e0656a814d5c56d8a2677dffb7ee42e01cc3 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 25 Mar 2026 13:59:00 -0400
Subject: [PATCH 023/122] WIP

---
 .../src/internal/client/reactivity/batch.js   | 21 ++++++++++---------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index f4987c6daa..72f8ddcb9c 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1221,18 +1221,12 @@ export function fork(fn) {
 
 	var batch = Batch.ensure();
 	batch.is_fork = true;
-	batch_values = new Map();
 
 	var committed = false;
 	var settled = batch.settled();
 
 	flushSync(fn);
 
-	// revert state changes
-	for (var [source, value] of batch.previous) {
-		source.v = value;
-	}
-
 	return {
 		commit: async () => {
 			if (committed) {
@@ -1248,10 +1242,17 @@ export function fork(fn) {
 
 			batch.is_fork = false;
 
-			// apply changes and update write versions so deriveds see the change
-			for (var [source, value] of batch.current) {
-				source.v = value;
-				source.wv = increment_write_version();
+			for (var [reaction, cv] of batch.cvs) {
+				if (cv > reaction.cv) {
+					reaction.cv = cv;
+				}
+			}
+
+			for (var [value, wv] of batch.wvs) {
+				if (wv > value.wv) {
+					value.wv = increment_write_version();
+					value.v = batch.current.get(value);
+				}
 			}
 
 			// trigger any `$state.eager(...)` expressions with the new state.

From fe2fc3fc6a3a0244ae4f778cc69300b7b1851e39 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 25 Mar 2026 13:59:47 -0400
Subject: [PATCH 024/122] note to self

---
 packages/svelte/src/internal/client/reactivity/batch.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 72f8ddcb9c..7cad642e8c 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1260,6 +1260,8 @@ export function fork(fn) {
 			// can't just encounter them during traversal, we need to
 			// proactively flush them
 			// TODO maybe there's a better implementation?
+			// e.g. maybe we can just schedule them so that they run
+			// with everything else during batch.flush?
 			flushSync(() => {
 				/** @type {Set<Effect>} */
 				var eager_effects = new Set();

From 45b123264ebd01328e54d74fa3b60a3a18d59d89 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 26 Mar 2026 11:29:57 -0700
Subject: [PATCH 025/122] fix

---
 packages/svelte/src/internal/client/dom/blocks/each.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packages/svelte/src/internal/client/dom/blocks/each.js b/packages/svelte/src/internal/client/dom/blocks/each.js
index 3acdf80d84..b7674de588 100644
--- a/packages/svelte/src/internal/client/dom/blocks/each.js
+++ b/packages/svelte/src/internal/client/dom/blocks/each.js
@@ -221,6 +221,8 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 			return;
 		}
 
+		var array = get(each_array);
+
 		state.pending.delete(batch);
 
 		state.fallback = fallback;

From 46e1d08e005074140797267d66b1c6f37d305518 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 26 Mar 2026 11:30:06 -0700
Subject: [PATCH 026/122] more debug logging

---
 packages/svelte/src/internal/client/reactivity/batch.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 7cad642e8c..b92d827128 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -332,6 +332,7 @@ export class Batch {
 		legacy_updates = null;
 
 		if (this.#is_deferred() || this.#is_blocked()) {
+			// console.log(this.#is_deferred() ? 'deferred' : 'blocked');
 			this.#defer_effects(render_effects);
 			this.#defer_effects(effects);
 
@@ -339,6 +340,7 @@ export class Batch {
 				reset_branch(e, t);
 			}
 		} else {
+			// console.log('resolved');
 			if (this.#pending.size === 0) {
 				batches.delete(this);
 			}
@@ -348,8 +350,10 @@ export class Batch {
 			this.#maybe_dirty_effects.clear();
 
 			// append/remove branches
+			// console.group('branches');
 			for (const fn of this.#commit_callbacks) fn(this);
 			this.#commit_callbacks.clear();
+			// console.groupEnd();
 
 			previous_batch = this;
 			flush_queued_effects(render_effects);

From 7cd62ff67d05656661842a1944a93e54ea3dbcae Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 27 Mar 2026 08:52:08 -0700
Subject: [PATCH 027/122] WIP

---
 .../src/internal/client/reactivity/batch.js   | 56 ++++++++++---------
 .../src/internal/client/reactivity/effects.js |  4 +-
 2 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index b92d827128..fc3eb25ca7 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -266,7 +266,7 @@ export class Batch {
 	}
 
 	#process() {
-		// console.group('process', this.id);
+		console.group('process', this.id);
 
 		current_batch = this;
 
@@ -332,7 +332,7 @@ export class Batch {
 		legacy_updates = null;
 
 		if (this.#is_deferred() || this.#is_blocked()) {
-			// console.log(this.#is_deferred() ? 'deferred' : 'blocked');
+			console.log(this.#is_deferred() ? 'deferred' : 'blocked');
 			this.#defer_effects(render_effects);
 			this.#defer_effects(effects);
 
@@ -340,7 +340,7 @@ export class Batch {
 				reset_branch(e, t);
 			}
 		} else {
-			// console.log('resolved');
+			console.log('resolved');
 			if (this.#pending.size === 0) {
 				batches.delete(this);
 			}
@@ -389,7 +389,7 @@ export class Batch {
 			this.#commit();
 		}
 
-		// console.groupEnd();
+		console.groupEnd();
 	}
 
 	/**
@@ -773,28 +773,28 @@ export class Batch {
 			}
 		}
 
-		// console.group('batch_values');
-		// for (const [value, v] of batch_values) {
-		// 	console.log(this.current.has(value), value.label, v);
-		// }
-		// console.groupEnd();
-
-		// console.group('batch_cvs');
-		// for (const [reaction, cv] of batch_cvs) {
-		// 	console.log(
-		// 		this.cvs.has(reaction),
-		// 		cv,
-		// 		reaction.deps?.map((d) => d.label),
-		// 		reaction.label ?? reaction.fn
-		// 	);
-		// }
-		// console.groupEnd();
-
-		// console.group('batch_wvs');
-		// for (const [value, wv] of batch_wvs) {
-		// 	console.log(this.wvs.has(value), wv, value.label);
-		// }
-		// console.groupEnd();
+		console.group('batch_values');
+		for (const [value, v] of batch_values) {
+			console.log(this.current.has(value), value.label, v);
+		}
+		console.groupEnd();
+
+		console.group('batch_cvs');
+		for (const [reaction, cv] of batch_cvs) {
+			console.log(
+				this.cvs.has(reaction),
+				cv,
+				reaction.deps?.map((d) => d.label),
+				reaction.label ?? reaction.fn
+			);
+		}
+		console.groupEnd();
+
+		console.group('batch_wvs');
+		for (const [value, wv] of batch_wvs) {
+			console.log(this.wvs.has(value), wv, value.label);
+		}
+		console.groupEnd();
 	}
 
 	/**
@@ -1122,6 +1122,10 @@ export function eager(fn) {
 
 	get(version);
 
+	if (DEV) {
+		version.label = '<eager>';
+	}
+
 	eager_effect(() => {
 		if (initial) {
 			// the first time this runs, we create an eager effect
diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js
index 970cc9a640..2019e610ad 100644
--- a/packages/svelte/src/internal/client/reactivity/effects.js
+++ b/packages/svelte/src/internal/client/reactivity/effects.js
@@ -374,7 +374,9 @@ export function render_effect(fn, flags = 0) {
  */
 export function template_effect(fn, sync = [], async = [], blockers = []) {
 	flatten(blockers, sync, async, (values) => {
-		create_effect(RENDER_EFFECT, () => fn(...values.map(get)));
+		create_effect(RENDER_EFFECT, () => {
+			fn(...values.map(get));
+		});
 	});
 }
 

From 4d1436bb7903b4884849b4f4281fe3f4983d2d4d Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 27 Mar 2026 15:13:11 -0700
Subject: [PATCH 028/122] fix

---
 .../src/internal/client/reactivity/batch.js   | 52 +++++++++----------
 .../svelte/src/internal/client/runtime.js     |  7 +--
 2 files changed, 28 insertions(+), 31 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index fc3eb25ca7..c764e6ed0c 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -266,7 +266,7 @@ export class Batch {
 	}
 
 	#process() {
-		console.group('process', this.id);
+		// console.group('process', this.id);
 
 		current_batch = this;
 
@@ -332,7 +332,7 @@ export class Batch {
 		legacy_updates = null;
 
 		if (this.#is_deferred() || this.#is_blocked()) {
-			console.log(this.#is_deferred() ? 'deferred' : 'blocked');
+			// console.log(this.#is_deferred() ? 'deferred' : 'blocked');
 			this.#defer_effects(render_effects);
 			this.#defer_effects(effects);
 
@@ -340,7 +340,7 @@ export class Batch {
 				reset_branch(e, t);
 			}
 		} else {
-			console.log('resolved');
+			// console.log('resolved');
 			if (this.#pending.size === 0) {
 				batches.delete(this);
 			}
@@ -389,7 +389,7 @@ export class Batch {
 			this.#commit();
 		}
 
-		console.groupEnd();
+		// console.groupEnd();
 	}
 
 	/**
@@ -773,28 +773,28 @@ export class Batch {
 			}
 		}
 
-		console.group('batch_values');
-		for (const [value, v] of batch_values) {
-			console.log(this.current.has(value), value.label, v);
-		}
-		console.groupEnd();
-
-		console.group('batch_cvs');
-		for (const [reaction, cv] of batch_cvs) {
-			console.log(
-				this.cvs.has(reaction),
-				cv,
-				reaction.deps?.map((d) => d.label),
-				reaction.label ?? reaction.fn
-			);
-		}
-		console.groupEnd();
-
-		console.group('batch_wvs');
-		for (const [value, wv] of batch_wvs) {
-			console.log(this.wvs.has(value), wv, value.label);
-		}
-		console.groupEnd();
+		// console.group('batch_values');
+		// for (const [value, v] of batch_values) {
+		// 	console.log(this.current.has(value), value.label, v);
+		// }
+		// console.groupEnd();
+
+		// console.group('batch_cvs');
+		// for (const [reaction, cv] of batch_cvs) {
+		// 	console.log(
+		// 		this.cvs.has(reaction),
+		// 		cv,
+		// 		reaction.deps?.map((d) => d.label),
+		// 		reaction.label ?? reaction.fn
+		// 	);
+		// }
+		// console.groupEnd();
+
+		// console.group('batch_wvs');
+		// for (const [value, wv] of batch_wvs) {
+		// 	console.log(this.wvs.has(value), wv, value.label);
+		// }
+		// console.groupEnd();
 	}
 
 	/**
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 41fa443c8f..b383e736ed 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -645,11 +645,8 @@ export function get(signal) {
 			var value = derived.v;
 
 			// if the derived is dirty and has reactions, or depends on the values that just changed, re-execute
-			// (a derived can be maybe_dirty due to the effect destroy removing its last reaction)
-			if (
-				((derived.f & CLEAN) === 0 && derived.reactions !== null) ||
-				depends_on_old_values(derived)
-			) {
+			// (a derived can be dirty due to the effect destroy removing its last reaction)
+			if ((is_dirty(derived) && derived.reactions !== null) || depends_on_old_values(derived)) {
 				value = execute_derived(derived);
 			}
 

From eae5ccba6117f7117d8ae79b1b061f11635a7a08 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 27 Mar 2026 15:40:23 -0700
Subject: [PATCH 029/122] delete these tests for now

---
 .../async-state-new-branch-4/Child.svelte     | 11 ---
 .../async-state-new-branch-4/_config.js       | 75 -----------------
 .../async-state-new-branch-4/main.svelte      | 32 -------
 .../async-state-new-branch-5/Child.svelte     | 11 ---
 .../async-state-new-branch-5/_config.js       | 84 -------------------
 .../async-state-new-branch-5/main.svelte      | 36 --------
 6 files changed, 249 deletions(-)
 delete mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/Child.svelte
 delete mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/_config.js
 delete mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/main.svelte
 delete mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/Child.svelte
 delete mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/_config.js
 delete mode 100644 packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/main.svelte

diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/Child.svelte
deleted file mode 100644
index f8c01e9efd..0000000000
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/Child.svelte
+++ /dev/null
@@ -1,11 +0,0 @@
-<script>
-	let { x } = $props();
-</script>
-
-<!-- checks direct source, indirect derived, block effect, async effect -->
-{x}
-{JSON.stringify(x)}
-{#if x === 'universe'}universe{:else}world{/if}
-{#if JSON.stringify(x) === '"universe"'}universe{:else}world{/if}
-{await Promise.resolve(x)}
-{await Promise.resolve(JSON.stringify(x))}
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/_config.js
deleted file mode 100644
index a20f8c0ba5..0000000000
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/_config.js
+++ /dev/null
@@ -1,75 +0,0 @@
-import { tick } from 'svelte';
-import { test } from '../../test';
-
-export default test({
-	async test({ assert, target }) {
-		const [x, y, resolve, commit] = target.querySelectorAll('button');
-
-		x.click();
-		await tick();
-
-		y.click();
-		await tick();
-		assert.htmlEqual(
-			target.innerHTML,
-			`
-			<button>x</button>
-			<button>y++</button>
-			<button>resolve</button>
-			<button>commit</button>
-			<hr>
-			world
-			"world"
-			world
-			world
-			world
-			"world"
-		`
-		);
-
-		commit.click();
-		await tick();
-		assert.htmlEqual(
-			target.innerHTML,
-			`
-			<button>x</button>
-			<button>y++</button>
-			<button>resolve</button>
-			<button>commit</button>
-			<hr>
-			world
-			"world"
-			world
-			world
-			world
-			"world"
-		`
-		);
-
-		resolve.click();
-		await tick();
-		assert.htmlEqual(
-			target.innerHTML,
-			`
-			<button>x</button>
-			<button>y++</button>
-			<button>resolve</button>
-			<button>commit</button>
-			universe
-			universe
-			"universe"
-			universe
-			universe
-			universe
-			"universe"
-			<hr>
-			universe
-			"universe"
-			universe
-			universe
-			universe
-			"universe"
-		`
-		);
-	}
-});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/main.svelte
deleted file mode 100644
index 5f00fc4dec..0000000000
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-4/main.svelte
+++ /dev/null
@@ -1,32 +0,0 @@
-<script>
-	import { fork } from 'svelte';
-	import Child from './Child.svelte';
-
-	let x = $state('world');
-	let y = $state(0);
-	let f;
-
-	const deferred = [];
-
-	function delay(value) {
-		if (value !== 'universe') return value;
-		return new Promise((resolve) => deferred.push(() => resolve(value)));
-	}
-</script>
-
-<button onclick={() => (f = fork(() => {x = 'universe';}))}>x</button>
-
-<button onclick={() => y++}>y++</button>
-<button onclick={() => deferred.pop()?.()}>resolve</button>
-<button onclick={() => f.commit()}>commit</button>
-
-{#if x === 'universe'}
-	{await delay(x)}
-	<Child {x} />
-{/if}
-
-<hr>
-
-{#if y > 0}
-	<Child {x} />
-{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/Child.svelte
deleted file mode 100644
index f8c01e9efd..0000000000
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/Child.svelte
+++ /dev/null
@@ -1,11 +0,0 @@
-<script>
-	let { x } = $props();
-</script>
-
-<!-- checks direct source, indirect derived, block effect, async effect -->
-{x}
-{JSON.stringify(x)}
-{#if x === 'universe'}universe{:else}world{/if}
-{#if JSON.stringify(x) === '"universe"'}universe{:else}world{/if}
-{await Promise.resolve(x)}
-{await Promise.resolve(JSON.stringify(x))}
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/_config.js
deleted file mode 100644
index e8f16ade3c..0000000000
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/_config.js
+++ /dev/null
@@ -1,84 +0,0 @@
-import { tick } from 'svelte';
-import { test } from '../../test';
-
-export default test({
-	async test({ assert, target }) {
-		const [x, y, resolve, commit] = target.querySelectorAll('button');
-
-		x.click();
-		await tick();
-
-		y.click();
-		await tick();
-		assert.htmlEqual(
-			target.innerHTML,
-			`
-			<button>x</button>
-			<button>y++</button>
-			<button>resolve</button>
-			<button>commit</button>
-			<hr>
-		`
-		);
-
-		commit.click();
-		await tick();
-		assert.htmlEqual(
-			target.innerHTML,
-			`
-			<button>x</button>
-			<button>y++</button>
-			<button>resolve</button>
-			<button>commit</button>
-			<hr>
-		`
-		);
-
-		resolve.click();
-		await tick();
-		assert.htmlEqual(
-			target.innerHTML,
-			`
-			<button>x</button>
-			<button>y++</button>
-			<button>resolve</button>
-			<button>commit</button>
-			<hr>
-			world
-			"world"
-			world
-			world
-			world
-			"world"
-		`
-		);
-
-		resolve.click();
-		await tick();
-		resolve.click();
-		await tick();
-		assert.htmlEqual(
-			target.innerHTML,
-			`
-			<button>x</button>
-			<button>y++</button>
-			<button>resolve</button>
-			<button>commit</button>
-			universe
-			universe
-			"universe"
-			universe
-			universe
-			universe
-			"universe"
-			<hr>
-			universe
-			"universe"
-			universe
-			universe
-			universe
-			"universe"
-		`
-		);
-	}
-});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/main.svelte
deleted file mode 100644
index 5575e3cbd4..0000000000
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-5/main.svelte
+++ /dev/null
@@ -1,36 +0,0 @@
-<script>
-	import { fork } from 'svelte';
-	import Child from './Child.svelte';
-
-	let x = $state('world');
-	let y = $state(0);
-	let f;
-
-	const deferred = [];
-
-	function delay(value) {
-		if (value !== 'universe') return value;
-		return new Promise((resolve) => deferred.push(() => resolve(value)));
-	}
-
-	function delay2(value) {
-		return new Promise((resolve) => deferred.push(() => resolve(value)));
-	}
-</script>
-
-<button onclick={() => (f = fork(() => {x = 'universe';}))}>x</button>
-
-<button onclick={() => y++}>y++</button>
-<button onclick={() => deferred.pop()?.()}>resolve</button>
-<button onclick={() => f.commit()}>commit</button>
-
-{#if x === 'universe'}
-	{await delay(x)}
-	<Child {x} />
-{/if}
-
-<hr>
-
-{#if y > 0}
-	<Child x={await delay2(x)} />
-{/if}

From 930076dcd64fcf5078f2268a40eb2d2a671f865f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 27 Mar 2026 15:41:05 -0700
Subject: [PATCH 030/122] match main

---
 .../async-discard-obsolete-batch/_config.js   |  6 --
 .../async-discard-obsolete-batch/main.svelte  |  7 +--
 .../_config.js                                |  2 +-
 .../async-overlap-multiple-2/_config.js       |  1 +
 .../async-overlap-multiple-3/_config.js       |  1 +
 .../async-overlap-multiple-4/_config.js       |  1 +
 .../async-overlap-multiple-5/_config.js       | 55 +++++++++++++++----
 .../async-overlap-multiple-7/_config.js       | 50 +++++++++++++++--
 .../async-state-new-branch-1/_config.js       |  3 +-
 .../async-state-new-branch-2/_config.js       |  3 +-
 .../async-state-new-branch-3/_config.js       |  3 +-
 11 files changed, 100 insertions(+), 32 deletions(-)

diff --git a/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/_config.js b/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/_config.js
index bd3b7e6960..64e1a4b2b5 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/_config.js
@@ -14,7 +14,6 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>1 = 1</p>
-				<p>hello</p>
 			`
 		);
 
@@ -30,7 +29,6 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>1 = 1</p>
-				<p>hello</p>
 			`
 		);
 
@@ -44,7 +42,6 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>1 = 1</p>
-				<p>hello</p>
 			`
 		);
 
@@ -58,7 +55,6 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>3 = 3</p>
-				<p>goodbye</p>
 			`
 		);
 
@@ -74,7 +70,6 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>3 = 3</p>
-				<p>goodbye</p>
 			`
 		);
 
@@ -88,7 +83,6 @@ export default test({
 				<button>shift</button>
 				<button>pop</button>
 				<p>5 = 5</p>
-				<p>goodbye</p>
 			`
 		);
 	}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/main.svelte
index d42b3b545a..faa8d139a6 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/main.svelte
+++ b/packages/svelte/tests/runtime-runes/samples/async-discard-obsolete-batch/main.svelte
@@ -24,13 +24,9 @@
 	}
 
 	let n = $state(1);
-	let message = $state('hello');
 </script>
 
-<button onclick={() => {
-	n++;
-	message = 'goodbye';
-}}>
+<button onclick={() => n++}>
 	{$state.eager(n)}
 </button>
 
@@ -38,4 +34,3 @@
 <button onclick={pop}>pop</button>
 
 <p>{n} = {await push(n)}</p>
-<p>{message}</p>
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/async-linear-order-same-derived/_config.js b/packages/svelte/tests/runtime-runes/samples/async-linear-order-same-derived/_config.js
index 1e0da08eda..cc7b2756fa 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-linear-order-same-derived/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-linear-order-same-derived/_config.js
@@ -18,7 +18,7 @@ export default test({
 		pop.click();
 		await tick();
 
-		assert.htmlEqual(p.innerHTML, '2 + 3 = 5');
+		assert.htmlEqual(p.innerHTML, '1 + 3 = 4');
 
 		pop.click();
 		await tick();
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/_config.js
index 0f422d1797..f4aff83aad 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-2/_config.js
@@ -2,6 +2,7 @@ import { tick } from 'svelte';
 import { test } from '../../test';
 
 export default test({
+	skip: true, // TODO works on https://github.com/sveltejs/svelte/pull/17971
 	async test({ assert, target }) {
 		await tick();
 		const [a_b, a_c, b_d, shift, pop] = target.querySelectorAll('button');
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/_config.js
index 011588447f..c9e7513b22 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-3/_config.js
@@ -2,6 +2,7 @@ import { tick } from 'svelte';
 import { test } from '../../test';
 
 export default test({
+	skip: true, // TODO works on https://github.com/sveltejs/svelte/pull/17971
 	async test({ assert, target }) {
 		await tick();
 		const [a_b, a_c, b_d, shift, pop] = target.querySelectorAll('button');
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/_config.js
index 2c6226af07..472a3ebcaf 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-4/_config.js
@@ -2,6 +2,7 @@ import { tick } from 'svelte';
 import { test } from '../../test';
 
 export default test({
+	skip: true, // TODO works on https://github.com/sveltejs/svelte/pull/17971
 	async test({ assert, target }) {
 		await tick();
 		const [a_b, a_c, b_d, shift, pop] = target.querySelectorAll('button');
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/_config.js
index f07c86dc0c..d03f3cfbb8 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-5/_config.js
@@ -45,12 +45,14 @@ export default test({
 		`
 		);
 
+		// how it's on main
+
 		shift.click();
 		await tick();
 		assert.htmlEqual(
 			target.innerHTML,
 			`
-			a 0 | b 0 | c 0 | d 0
+			a 0 | b 0 | c 1 | d 1
 			<button>a++</button>
 			<button>c++</button>
 			<button>shift</button>
@@ -60,17 +62,6 @@ export default test({
 
 		shift.click();
 		await tick();
-		assert.htmlEqual(
-			target.innerHTML,
-			`
-			a 1 | b 2 | c 0 | d 2
-			<button>a++</button>
-			<button>c++</button>
-			<button>shift</button>
-			<button>pop</button>
-		`
-		);
-
 		shift.click();
 		await tick();
 		assert.htmlEqual(
@@ -83,5 +74,45 @@ export default test({
 			<button>pop</button>
 		`
 		);
+
+		// how it's on https://github.com/sveltejs/svelte/pull/17971
+		// shift.click();
+		// await tick();
+		// assert.htmlEqual(
+		// 	target.innerHTML,
+		// 	`
+		// 	a 0 | b 0 | c 0 | d 0
+		// 	<button>a++</button>
+		// 	<button>c++</button>
+		// 	<button>shift</button>
+		// 	<button>pop</button>
+		// `
+		// );
+
+		// shift.click();
+		// await tick();
+		// assert.htmlEqual(
+		// 	target.innerHTML,
+		// 	`
+		// 	a 1 | b 2 | c 0 | d 2
+		// 	<button>a++</button>
+		// 	<button>c++</button>
+		// 	<button>shift</button>
+		// 	<button>pop</button>
+		// `
+		// );
+
+		// shift.click();
+		// await tick();
+		// assert.htmlEqual(
+		// 	target.innerHTML,
+		// 	`
+		// 	a 1 | b 2 | c 1 | d 3
+		// 	<button>a++</button>
+		// 	<button>c++</button>
+		// 	<button>shift</button>
+		// 	<button>pop</button>
+		// `
+		// );
 	}
 });
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/_config.js
index 62ba0e3f46..b1bf53a2fc 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlap-multiple-7/_config.js
@@ -45,12 +45,14 @@ export default test({
 		`
 		);
 
-		pop.click(); // second batch resolves but knows it needs to wait on first batch
+		// how it's on main
+
+		pop.click();
 		await tick();
 		assert.htmlEqual(
 			target.innerHTML,
 			`
-			a 0 | b 0 | c 0 | d 0
+			a 1 | b 2 | c 0 | d 2
 			<button>a++</button>
 			<button>c++</button>
 			<button>shift</button>
@@ -63,7 +65,7 @@ export default test({
 		assert.htmlEqual(
 			target.innerHTML,
 			`
-			a 0 | b 0 | c 0 | d 0
+			a 1 | b 2 | c 0 | d 2
 			<button>a++</button>
 			<button>c++</button>
 			<button>shift</button>
@@ -71,7 +73,7 @@ export default test({
 		`
 		);
 
-		shift.click(); // first batch resolves, with it second can now resolve as well
+		shift.click(); // first batch resolves
 		await tick();
 		assert.htmlEqual(
 			target.innerHTML,
@@ -83,5 +85,45 @@ export default test({
 			<button>pop</button>
 		`
 		);
+
+		// how it's on https://github.com/sveltejs/svelte/pull/17971
+		// pop.click(); // second batch resolves but knows it needs to wait on first batch
+		// await tick();
+		// assert.htmlEqual(
+		// 	target.innerHTML,
+		// 	`
+		// 	a 0 | b 0 | c 0 | d 0
+		// 	<button>a++</button>
+		// 	<button>c++</button>
+		// 	<button>shift</button>
+		// 	<button>pop</button>
+		// `
+		// );
+
+		// shift.click(); // obsolete second batch promise (already rejected)
+		// await tick();
+		// assert.htmlEqual(
+		// 	target.innerHTML,
+		// 	`
+		// 	a 0 | b 0 | c 0 | d 0
+		// 	<button>a++</button>
+		// 	<button>c++</button>
+		// 	<button>shift</button>
+		// 	<button>pop</button>
+		// `
+		// );
+
+		// shift.click(); // first batch resolves, with it second can now resolve as well
+		// await tick();
+		// assert.htmlEqual(
+		// 	target.innerHTML,
+		// 	`
+		// 	a 1 | b 2 | c 1 | d 3
+		// 	<button>a++</button>
+		// 	<button>c++</button>
+		// 	<button>shift</button>
+		// 	<button>pop</button>
+		// `
+		// );
 	}
 });
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/_config.js
index 28ce3c9d4f..0af275009c 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-1/_config.js
@@ -2,6 +2,7 @@ import { tick } from 'svelte';
 import { test } from '../../test';
 
 export default test({
+	skip: true, // TODO works on https://github.com/sveltejs/svelte/pull/17971
 	async test({ assert, target, logs }) {
 		const [x, y, resolve] = target.querySelectorAll('button');
 
@@ -16,7 +17,7 @@ export default test({
 			<button>x</button>
 			<button>y++</button>
 			<button>resolve</button>
-		`
+		` // if this shows world world - that would also be ok
 		);
 
 		resolve.click();
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/_config.js
index 00b38262e8..035616dfb6 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-2/_config.js
@@ -2,6 +2,7 @@ import { tick } from 'svelte';
 import { test } from '../../test';
 
 export default test({
+	skip: true, // TODO works on https://github.com/sveltejs/svelte/pull/17971
 	async test({ assert, target }) {
 		const [x, y, resolve] = target.querySelectorAll('button');
 
@@ -17,7 +18,7 @@ export default test({
 			<button>y++</button>
 			<button>resolve</button>
 			<hr>
-		`
+		` // if this shows world world "world" world world world "world" - then this would also be ok
 		);
 
 		resolve.click();
diff --git a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/_config.js b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/_config.js
index fe2765e76f..a2d615b6e5 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-state-new-branch-3/_config.js
@@ -2,6 +2,7 @@ import { tick } from 'svelte';
 import { test } from '../../test';
 
 export default test({
+	skip: true, // TODO works on https://github.com/sveltejs/svelte/pull/17971
 	async test({ assert, target }) {
 		const [x, y, resolve] = target.querySelectorAll('button');
 
@@ -29,7 +30,7 @@ export default test({
 			<button>y++</button>
 			<button>resolve</button>
 			<hr>
-		`
+		` // if this shows world world "world" world world world "world" - then this would also be ok
 		);
 
 		resolve.click();

From 2660c7f87efb870dc3895b841d0d81eeda1632f0 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 27 Mar 2026 16:24:33 -0700
Subject: [PATCH 031/122] fix

---
 .../svelte/src/internal/client/reactivity/batch.js | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index c764e6ed0c..ca23800dc1 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1170,14 +1170,12 @@ export function eager(fn) {
  */
 function reset_branch(effect, tracked) {
 	// clean branch = nothing dirty inside, no need to traverse further
-	if ((effect.f & BRANCH_EFFECT) !== 0 && (effect.f & CLEAN) !== 0) {
-		return;
-	}
-
-	if ((effect.f & DIRTY) !== 0) {
-		tracked.d.push(effect);
-	} else if ((effect.f & MAYBE_DIRTY) !== 0) {
-		tracked.m.push(effect);
+	if ((effect.f & BRANCH_EFFECT) !== 0) {
+		if ((effect.f & CLEAN) === 0) {
+			effect.f ^= CLEAN;
+		} else {
+			return;
+		}
 	}
 
 	var e = effect.first;

From 41d2de109a497b7e6999e7993bb62f8c70964fa0 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 27 Mar 2026 16:53:43 -0700
Subject: [PATCH 032/122] WIP

---
 .../svelte/src/internal/client/reactivity/batch.js    | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 75c135429f..cff85910d2 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -607,9 +607,11 @@ export class Batch {
 				}
 
 				checked = new Map();
-				var current_unequal = [...batch.current.keys()].filter((c) =>
-					this.current.has(c) ? /** @type {[any, boolean]} */ (this.current.get(c))[0] !== c : true
-				);
+				var current_unequal = [
+					...[...batch.current.keys()].filter((c) =>
+						this.current.has(c) ? /** @type {any} */ (this.current.get(c)) !== c : true
+					)
+				];
 
 				for (const effect of this.#new_effects) {
 					if (
@@ -617,11 +619,12 @@ export class Batch {
 						depends_on(effect, current_unequal, checked)
 					) {
 						if ((effect.f & (ASYNC | BLOCK_EFFECT)) !== 0) {
-							set_signal_status(effect, DIRTY);
 							batch.schedule(effect);
 						} else {
 							batch.#dirty_effects.add(effect);
 						}
+
+						batch.cvs.set(effect, -1);
 					}
 				}
 

From a22611a60ef1c859abe3f793cbcac5bfd1755ef0 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 17:47:51 -0400
Subject: [PATCH 033/122] fix

---
 packages/svelte/src/internal/client/reactivity/deriveds.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 7e3f610d62..dc4f52080c 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -253,8 +253,8 @@ export function async_derived(fn, label, location) {
 	return new Promise((fulfil) => {
 		/** @param {Promise<V>} p */
 		function next(p) {
-			function go() {
-				if (p === promise) {
+			function go(v) {
+				if (p === promise || v !== STALE_REACTION) {
 					fulfil(signal);
 				} else {
 					// if the effect re-runs before the initial promise

From 66507b88b407ec261ecd89eb12641cce5bc34070 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 18:39:17 -0400
Subject: [PATCH 034/122] fix

---
 .../src/internal/client/reactivity/batch.js   | 22 +++++++++++++++++--
 .../internal/client/reactivity/deriveds.js    |  2 ++
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index cff85910d2..e3cc6c1ef1 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -173,6 +173,12 @@ export class Batch {
 	 */
 	#new_effects = [];
 
+	/**
+	 * Deriveds created while this batch was active.
+	 * @type {Derived[]}
+	 */
+	#new_deriveds = [];
+
 	/**
 	 * Deferred effects (which run after async work has completed) that are DIRTY
 	 * @type {Set<Effect>}
@@ -362,6 +368,7 @@ export class Batch {
 			// console.groupEnd();
 
 			previous_batch = this;
+
 			flush_queued_effects(render_effects);
 			flush_queued_effects(effects);
 			previous_batch = null;
@@ -553,6 +560,13 @@ export class Batch {
 		this.#new_effects.push(effect);
 	}
 
+	/**
+	 * @param {Derived} derived
+	 */
+	register_created_derived(derived) {
+		this.#new_deriveds.push(derived);
+	}
+
 	#commit() {
 		// If there are other pending batches, they now need to be 'rebased' —
 		// in other words, we re-run block/async effects with the newly
@@ -628,6 +642,10 @@ export class Batch {
 					}
 				}
 
+				for (const derived of this.#new_deriveds) {
+					batch.cvs.set(derived, -1);
+				}
+
 				// Only apply and traverse when we know we triggered async work with marking the effects
 				if (batch.#roots.length > 0) {
 					batch.apply();
@@ -819,7 +837,7 @@ export class Batch {
 		// 	console.log(
 		// 		this.cvs.has(reaction),
 		// 		cv,
-		// 		reaction.deps?.map((d) => d.label),
+		// 		reaction.deps?.map((d) => d.label ?? batch_values?.get(d)),
 		// 		reaction.label ?? reaction.fn
 		// 	);
 		// }
@@ -827,7 +845,7 @@ export class Batch {
 
 		// console.group('batch_wvs');
 		// for (const [value, wv] of batch_wvs) {
-		// 	console.log(this.wvs.has(value), wv, value.label);
+		// 	console.log(this.wvs.has(value), wv, value.label ?? value.v);
 		// }
 		// console.groupEnd();
 	}
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index dc4f52080c..892d6c613e 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -97,6 +97,8 @@ export function derived(fn) {
 		signal.created = get_error('created at');
 	}
 
+	current_batch?.register_created_derived(signal);
+
 	return signal;
 }
 

From 315b4043caccb730e2b121c226d540988dc995e7 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 20:10:03 -0400
Subject: [PATCH 035/122] apparently we need to get rid of this now?

---
 .editorconfig | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.editorconfig b/.editorconfig
index 2f52d9993f..900cdf7cdc 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -4,7 +4,6 @@ root = true
 end_of_line = lf
 insert_final_newline = true
 indent_style = tab
-indent_size = 2
 charset = utf-8
 trim_trailing_whitespace = true
 

From 59f0fa1cd83146da1ccac17f620b8c39fa8a738c Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 21:16:51 -0400
Subject: [PATCH 036/122] fix

---
 .../src/internal/client/reactivity/async.js       | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/async.js b/packages/svelte/src/internal/client/reactivity/async.js
index 7b0b108e4c..3a0569bcdd 100644
--- a/packages/svelte/src/internal/client/reactivity/async.js
+++ b/packages/svelte/src/internal/client/reactivity/async.js
@@ -1,4 +1,4 @@
-/** @import { Blocker, Effect, Value } from '#client' */
+/** @import { Blocker, Effect, Source, Value } from '#client' */
 import { DESTROYED, STALE_REACTION } from '#client/constants';
 import { DEV } from 'esm-env';
 import {
@@ -53,12 +53,15 @@ export function flatten(blockers, sync, async, fn) {
 				? Promise.all(pending.map((b) => b.promise))
 				: null;
 
-	/** @param {Value[]} values */
-	function finish(values) {
+	/**
+	 * @param {Array<() => any>} sync
+	 * @param {Source[]} async
+	 */
+	function finish(sync, async) {
 		restore();
 
 		try {
-			fn(values);
+			fn([...sync.map(d), ...async]);
 		} catch (error) {
 			if ((parent.f & DESTROYED) === 0) {
 				invoke_error_boundary(error, parent);
@@ -70,7 +73,7 @@ export function flatten(blockers, sync, async, fn) {
 
 	// Fast path: blockers but no async expressions
 	if (async.length === 0) {
-		/** @type {Promise<any>} */ (blocker_promise).then(() => finish(sync.map(d)));
+		/** @type {Promise<any>} */ (blocker_promise).then(() => finish(sync, []));
 		return;
 	}
 
@@ -79,7 +82,7 @@ export function flatten(blockers, sync, async, fn) {
 	// Full path: has async expressions
 	function run() {
 		Promise.all(async.map((expression) => async_derived(expression)))
-			.then((result) => finish([...sync.map(d), ...result]))
+			.then((result) => finish(sync, result))
 			.catch((error) => invoke_error_boundary(error, parent))
 			.finally(() => decrement_pending());
 	}

From 92c5b817184671d3d700af0d3c7d5b75e401f4ba Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 21:27:49 -0400
Subject: [PATCH 037/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index e3cc6c1ef1..cbc8778405 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -568,6 +568,8 @@ export class Batch {
 	}
 
 	#commit() {
+		// console.group('commit', this.id);
+
 		// If there are other pending batches, they now need to be 'rebased' —
 		// in other words, we re-run block/async effects with the newly
 		// committed state, unless the batch in question has a more
@@ -671,6 +673,8 @@ export class Batch {
 				}
 			}
 		}
+
+		// console.groupEnd();
 	}
 
 	/**

From ce6cbd13db2b3069cde4a6dae739ee0aee9fa425 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 22:02:38 -0400
Subject: [PATCH 038/122] WIP

---
 .../svelte/src/internal/client/reactivity/batch.js     | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index cbc8778405..a530859624 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -618,8 +618,10 @@ export class Batch {
 				/** @type {Map<Reaction, boolean>} */
 				var checked = new Map();
 
+				var scheduled = [];
+
 				for (var source of sources) {
-					mark_effects(source, others, marked, checked);
+					mark_effects(source, others, marked, checked, scheduled);
 				}
 
 				checked = new Map();
@@ -1074,7 +1076,7 @@ function flush_queued_effects(effects) {
  * @param {Set<Value>} marked
  * @param {Map<Reaction, boolean>} checked
  */
-function mark_effects(value, sources, marked, checked) {
+function mark_effects(value, sources, marked, checked, scheduled = []) {
 	if (marked.has(value)) return;
 	marked.add(value);
 
@@ -1083,13 +1085,15 @@ function mark_effects(value, sources, marked, checked) {
 			const flags = reaction.f;
 
 			if ((flags & DERIVED) !== 0) {
-				mark_effects(/** @type {Derived} */ (reaction), sources, marked, checked);
+				mark_effects(/** @type {Derived} */ (reaction), sources, marked, checked, scheduled);
 			} else if (
 				(flags & (ASYNC | BLOCK_EFFECT)) !== 0 &&
 				(flags & DIRTY) === 0 &&
 				depends_on(reaction, sources, checked)
 			) {
+				scheduled.push(reaction);
 				schedule_effect(/** @type {Effect} */ (reaction));
+				current_batch?.cvs.set(reaction, -1);
 			}
 		}
 	}

From e6b37592bd5a46f96d0055be36edefd24299cf30 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 22:06:51 -0400
Subject: [PATCH 039/122] tidy

---
 .../src/internal/client/reactivity/batch.js   | 21 +++++++------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index a530859624..8b6e169969 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -618,10 +618,8 @@ export class Batch {
 				/** @type {Map<Reaction, boolean>} */
 				var checked = new Map();
 
-				var scheduled = [];
-
 				for (var source of sources) {
-					mark_effects(source, others, marked, checked, scheduled);
+					mark_effects(batch, source, others, marked, checked);
 				}
 
 				checked = new Map();
@@ -636,12 +634,7 @@ export class Batch {
 						(effect.f & (DESTROYED | INERT | EAGER_EFFECT)) === 0 &&
 						depends_on(effect, current_unequal, checked)
 					) {
-						if ((effect.f & (ASYNC | BLOCK_EFFECT)) !== 0) {
-							batch.schedule(effect);
-						} else {
-							batch.#dirty_effects.add(effect);
-						}
-
+						batch.schedule(effect);
 						batch.cvs.set(effect, -1);
 					}
 				}
@@ -1071,12 +1064,13 @@ function flush_queued_effects(effects) {
  * This is similar to `mark_reactions`, but it only marks async/block effects
  * depending on `value` and at least one of the other `sources`, so that
  * these effects can re-run after another batch has been committed
+ * @param {Batch} batch
  * @param {Value} value
  * @param {Source[]} sources
  * @param {Set<Value>} marked
  * @param {Map<Reaction, boolean>} checked
  */
-function mark_effects(value, sources, marked, checked, scheduled = []) {
+function mark_effects(batch, value, sources, marked, checked) {
 	if (marked.has(value)) return;
 	marked.add(value);
 
@@ -1085,15 +1079,14 @@ function mark_effects(value, sources, marked, checked, scheduled = []) {
 			const flags = reaction.f;
 
 			if ((flags & DERIVED) !== 0) {
-				mark_effects(/** @type {Derived} */ (reaction), sources, marked, checked, scheduled);
+				mark_effects(batch, /** @type {Derived} */ (reaction), sources, marked, checked);
 			} else if (
 				(flags & (ASYNC | BLOCK_EFFECT)) !== 0 &&
 				(flags & DIRTY) === 0 &&
 				depends_on(reaction, sources, checked)
 			) {
-				scheduled.push(reaction);
-				schedule_effect(/** @type {Effect} */ (reaction));
-				current_batch?.cvs.set(reaction, -1);
+				batch.schedule(/** @type {Effect} */ (reaction));
+				batch.cvs.set(reaction, -1);
 			}
 		}
 	}

From 5f21efe7dc32c805f3532b315cef2204adb1503c Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 22:34:36 -0400
Subject: [PATCH 040/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 8b6e169969..f74ebc2edc 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -783,9 +783,8 @@ export class Batch {
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
 		batch_values = new Map(this.current);
-
-		batch_cvs = new Map(this.cvs);
-		batch_wvs = new Map(this.wvs);
+		batch_cvs = this.cvs;
+		batch_wvs = this.wvs;
 
 		// ...and undo changes belonging to other batches unless they block this one
 		for (const batch of batches) {

From 25adfd15c34d93d8e0c8cfc58980f011bff76b4f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Sun, 29 Mar 2026 23:14:18 -0400
Subject: [PATCH 041/122] note to self

---
 packages/svelte/src/internal/client/reactivity/batch.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index f74ebc2edc..d5a0b2c2d8 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1309,8 +1309,8 @@ export function fork(fn) {
 
 			for (var [value, wv] of batch.wvs) {
 				if (wv > value.wv) {
-					value.wv = increment_write_version();
 					value.v = batch.current.get(value);
+					value.wv = increment_write_version(); // TODO this causes async-fork-derived-writable to fail, because `d` should _not_ be recomputed
 				}
 			}
 

From b02c7f7bcd5f94e0df0ccc9566330ff761cf5985 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 10:16:45 -0400
Subject: [PATCH 042/122] fix

---
 packages/svelte/src/internal/client/reactivity/batch.js | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index d5a0b2c2d8..71c0074346 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -486,6 +486,7 @@ export class Batch {
 
 		var version = increment_write_version();
 
+		this.wvs.delete(source); // order must be preserved
 		this.wvs.set(source, version);
 
 		if (!this.is_fork) {
@@ -1310,7 +1311,11 @@ export function fork(fn) {
 			for (var [value, wv] of batch.wvs) {
 				if (wv > value.wv) {
 					value.v = batch.current.get(value);
-					value.wv = increment_write_version(); // TODO this causes async-fork-derived-writable to fail, because `d` should _not_ be recomputed
+					value.wv = increment_write_version();
+
+					if ((value.f & DERIVED) !== 0) {
+						/** @type {Derived} */ (value).cv = value.wv;
+					}
 				}
 			}
 

From e11871867c482a6ba5ec257c574d307cfb1cb74f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 10:51:20 -0400
Subject: [PATCH 043/122] simplify

---
 .../src/internal/client/reactivity/batch.js   |  5 +++
 .../internal/client/reactivity/deriveds.js    | 35 +++----------------
 2 files changed, 10 insertions(+), 30 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 71c0074346..ca6d9f8e51 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -510,6 +510,11 @@ export class Batch {
 		if ((derived.f & ERROR_VALUE) === 0) {
 			batch_values?.set(derived, value);
 		}
+
+		if (!this.is_fork || derived.deps === null) {
+			derived.v = value;
+			derived.wv = write_version;
+		}
 	}
 
 	activate() {
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 892d6c613e..5565c7384d 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -391,38 +391,13 @@ export function update_derived(derived) {
 	set_cv(derived);
 
 	if (!derived.equals(value)) {
-		current_batch?.wvs.set(derived, write_version);
 		batch_wvs?.set(derived, write_version);
-		derived.wv = write_version;
-
-		// in a fork, we don't update the underlying value, just `batch_values`.
-		// the underlying value will be updated when the fork is committed.
-		// otherwise, the next time we get here after a 'real world' state
-		// change, `derived.equals` may incorrectly return `true`
-		if (!current_batch?.is_fork || derived.deps === null) {
-			current_batch?.capture_derived(derived, value);
-			derived.v = value;
 
-			// deriveds without dependencies should never be recomputed
-			if (derived.deps === null) {
-				return;
-			}
-		}
-	}
-
-	// don't mark derived clean if we're reading it inside a
-	// cleanup function, or it will cache a stale value
-	if (is_destroying_effect) {
-		return;
-	}
-
-	// During time traveling we don't want to reset the status so that
-	// traversal of the graph in the other batches still happens
-	if (batch_values !== null) {
-		// only cache the value if we're in a tracking context, otherwise we won't
-		// clear the cache in `mark_reactions` when dependencies are updated
-		if (effect_tracking() || current_batch?.is_fork) {
-			batch_values.set(derived, value);
+		if (current_batch !== null) {
+			current_batch.capture_derived(derived, value);
+		} else {
+			derived.v = value;
+			derived.wv = write_version;
 		}
 	}
 }

From cfc16cae59fa7f9647a05514b7bcc9812ae862ee Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 13:36:23 -0400
Subject: [PATCH 044/122] WIP

---
 .../src/internal/client/reactivity/batch.js   | 33 ++++++++++---------
 .../internal/client/reactivity/deriveds.js    |  4 +--
 2 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index ca6d9f8e51..435c621118 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1205,14 +1205,18 @@ export function eager(fn) {
 			return;
 		}
 
-		// the second time this effect runs, it's to schedule a
-		// `version` update. since this will recreate the effect,
-		// we don't need to evaluate the expression here
-		if (eager_versions.length === 0) {
-			queue_micro_task(eager_flush);
-		}
+		if (!current_batch?.is_fork) {
+			// the second time this effect runs, it's to schedule a
+			// `version` update. since this will recreate the effect,
+			// we don't need to evaluate the expression here
+			if (eager_versions.length === 0) {
+				queue_micro_task(eager_flush);
+			}
 
-		eager_versions.push(version);
+			eager_versions.push(version);
+		} else {
+			fn();
+		}
 	});
 
 	initial = false;
@@ -1314,14 +1318,8 @@ export function fork(fn) {
 			}
 
 			for (var [value, wv] of batch.wvs) {
-				if (wv > value.wv) {
-					value.v = batch.current.get(value);
-					value.wv = increment_write_version();
-
-					if ((value.f & DERIVED) !== 0) {
-						/** @type {Derived} */ (value).cv = value.wv;
-					}
-				}
+				value.v = batch.current.get(value);
+				value.wv = wv;
 			}
 
 			// trigger any `$state.eager(...)` expressions with the new state.
@@ -1381,7 +1379,10 @@ export function get_cv(reaction) {
 export function set_cv(reaction, cv = write_version) {
 	current_batch?.cvs.set(reaction, cv);
 	batch_cvs?.set(reaction, cv);
-	reaction.cv = cv;
+
+	if (!current_batch?.is_fork) {
+		reaction.cv = cv;
+	}
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 5565c7384d..3d7acb3fc7 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -39,7 +39,7 @@ import { get_error } from '../../shared/dev.js';
 import { async_mode_flag, tracing_mode_flag } from '../../flags/index.js';
 import { component_context } from '../context.js';
 import { UNINITIALIZED } from '../../../constants.js';
-import { batch_values, batch_wvs, current_batch, set_cv } from './batch.js';
+import { batch_values, batch_wvs, current_batch, get_wv, set_cv } from './batch.js';
 import { increment_pending, unset_context } from './async.js';
 import { deferred, includes, noop } from '../../shared/utils.js';
 
@@ -388,7 +388,7 @@ export function execute_derived(derived) {
 export function update_derived(derived) {
 	var value = execute_derived(derived);
 
-	set_cv(derived);
+	set_cv(derived, derived.deps === null ? Infinity : Math.max(...derived.deps.map(get_wv)));
 
 	if (!derived.equals(value)) {
 		batch_wvs?.set(derived, write_version);

From ae3ed1b9c95be2dfa2c08f84c82f5aeffe268b57 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 13:48:16 -0400
Subject: [PATCH 045/122] WIP

---
 packages/svelte/src/internal/client/runtime.js | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index b383e736ed..ca8fc4e1a0 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -466,11 +466,13 @@ export function update_effect(effect) {
 		var teardown = update_reaction(effect);
 		effect.teardown = typeof teardown === 'function' ? teardown : null;
 
-		if (is_runes() && (effect.f & EFFECT_LEGACY) === 0) {
-			set_cv(effect, cv);
-		} else {
-			// in legacy mode, prevent the effect re-running immediately
-			set_cv(effect);
+		if (effect.deps !== null) {
+			if (is_runes() && (effect.f & EFFECT_LEGACY) === 0) {
+				set_cv(effect, cv);
+			} else {
+				// in legacy mode, prevent the effect re-running immediately
+				set_cv(effect);
+			}
 		}
 
 		// In DEV, increment versions of any sources that were written to during the effect,

From ef44fbe18988a2d74f75b24a289144c831a597ca Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 14:19:12 -0400
Subject: [PATCH 046/122] more commented logs

---
 packages/svelte/src/internal/client/reactivity/batch.js | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 435c621118..ca59cd3f9a 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -786,6 +786,12 @@ export class Batch {
 			return;
 		}
 
+		// console.group('apply', this.id);
+
+		// console.groupCollapsed('trace');
+		// console.trace();
+		// console.groupEnd();
+
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
 		batch_values = new Map(this.current);
@@ -852,6 +858,8 @@ export class Batch {
 		// 	console.log(this.wvs.has(value), wv, value.label ?? value.v);
 		// }
 		// console.groupEnd();
+
+		// console.groupEnd();
 	}
 
 	/**

From 494f06aad156bf663c75a205f1e780aa2a8bc1b3 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 14:20:51 -0400
Subject: [PATCH 047/122] WIP

---
 .../src/internal/client/reactivity/async.js   | 25 ++++++++++++++-----
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/async.js b/packages/svelte/src/internal/client/reactivity/async.js
index 3a0569bcdd..b5a5989fac 100644
--- a/packages/svelte/src/internal/client/reactivity/async.js
+++ b/packages/svelte/src/internal/client/reactivity/async.js
@@ -38,8 +38,22 @@ export function flatten(blockers, sync, async, fn) {
 	// Filter out already-settled blockers - no need to wait for them
 	var pending = blockers.filter((b) => !b.settled);
 
+	var deriveds = sync.map(d);
+
+	if (DEV) {
+		deriveds.forEach((d, i) => {
+			// TODO this is kinda useful for debugging but a lousy implementation —
+			// maybe the compiler could pass through the template string
+			d.label = sync[i]
+				.toString()
+				.replace('() => ', '')
+				.replaceAll('$.eager(() => ', '$state.eager(')
+				.replace(/\$\.get\((.+?)\)/g, (_, id) => id);
+		});
+	}
+
 	if (async.length === 0 && pending.length === 0) {
-		fn(sync.map(d));
+		fn(deriveds);
 		return;
 	}
 
@@ -54,14 +68,13 @@ export function flatten(blockers, sync, async, fn) {
 				: null;
 
 	/**
-	 * @param {Array<() => any>} sync
 	 * @param {Source[]} async
 	 */
-	function finish(sync, async) {
+	function finish(async) {
 		restore();
 
 		try {
-			fn([...sync.map(d), ...async]);
+			fn([...deriveds, ...async]);
 		} catch (error) {
 			if ((parent.f & DESTROYED) === 0) {
 				invoke_error_boundary(error, parent);
@@ -73,7 +86,7 @@ export function flatten(blockers, sync, async, fn) {
 
 	// Fast path: blockers but no async expressions
 	if (async.length === 0) {
-		/** @type {Promise<any>} */ (blocker_promise).then(() => finish(sync, []));
+		/** @type {Promise<any>} */ (blocker_promise).then(() => finish([]));
 		return;
 	}
 
@@ -82,7 +95,7 @@ export function flatten(blockers, sync, async, fn) {
 	// Full path: has async expressions
 	function run() {
 		Promise.all(async.map((expression) => async_derived(expression)))
-			.then((result) => finish(sync, result))
+			.then(finish)
 			.catch((error) => invoke_error_boundary(error, parent))
 			.finally(() => decrement_pending());
 	}

From 4826a279bf689a0d07b7dc5caba710b92fc02772 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 17:27:55 -0400
Subject: [PATCH 048/122] fix

---
 packages/svelte/src/internal/client/reactivity/batch.js  | 9 ++++++++-
 .../svelte/src/internal/client/reactivity/sources.js     | 4 +---
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index ca59cd3f9a..58c5d0ebfa 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -369,8 +369,10 @@ export class Batch {
 
 			previous_batch = this;
 
+			// console.group('flush effects');
 			flush_queued_effects(render_effects);
 			flush_queued_effects(effects);
+			// console.groupEnd();
 			previous_batch = null;
 
 			this.#deferred?.resolve();
@@ -1164,6 +1166,8 @@ export function schedule_effect(effect) {
 /** @type {Source<number>[]} */
 let eager_versions = [];
 
+let running_eager_effect = false;
+
 function eager_flush() {
 	try {
 		flushSync(() => {
@@ -1200,14 +1204,17 @@ export function eager(fn) {
 			var previous_batch_values = batch_values;
 			var previous_batch_cvs = batch_cvs;
 			var previous_batch_wvs = batch_wvs;
+			var previous_running_eager_effect = running_eager_effect;
 
 			try {
+				running_eager_effect = true;
 				batch_values = batch_cvs = batch_wvs = null;
 				value = fn();
 			} finally {
 				batch_values = previous_batch_values;
 				batch_cvs = previous_batch_cvs;
 				batch_wvs = previous_batch_wvs;
+				running_eager_effect = previous_running_eager_effect;
 			}
 
 			return;
@@ -1388,7 +1395,7 @@ export function set_cv(reaction, cv = write_version) {
 	current_batch?.cvs.set(reaction, cv);
 	batch_cvs?.set(reaction, cv);
 
-	if (!current_batch?.is_fork) {
+	if (!current_batch?.is_fork && !running_eager_effect) {
 		reaction.cv = cv;
 	}
 }
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 41af83456f..7504615b4c 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -269,9 +269,7 @@ export function flush_eager_effects() {
 	eager_effects_deferred = false;
 
 	for (const effect of eager_effects) {
-		if (is_dirty(effect)) {
-			update_effect(effect);
-		}
+		update_effect(effect);
 	}
 
 	eager_effects.clear();

From a2c39c10b19911a7d71ee9c20c31fc21338ad889 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 18:02:05 -0400
Subject: [PATCH 049/122] shrug

---
 packages/svelte/src/internal/client/reactivity/batch.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 58c5d0ebfa..1679ef0bed 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -575,7 +575,13 @@ export class Batch {
 		this.#new_deriveds.push(derived);
 	}
 
+	#committed = false;
+
 	#commit() {
+		// TODO seems like a bug that we can end up here more than once
+		if (this.#committed) return;
+		this.#committed = true;
+
 		// console.group('commit', this.id);
 
 		// If there are other pending batches, they now need to be 'rebased' —

From 6a96f64c5cdc68c678dcfa62c9746ca34b1819aa Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 18:04:49 -0400
Subject: [PATCH 050/122] more shrug

---
 packages/svelte/src/internal/client/reactivity/batch.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 1679ef0bed..6e9599e7e1 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -278,6 +278,8 @@ export class Batch {
 	}
 
 	#process() {
+		if (this.#committed) return;
+
 		// console.group('process', this.id);
 
 		current_batch = this;

From 0d959199787e4daad113e65d8478805925217e75 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 19:55:32 -0400
Subject: [PATCH 051/122] all async tests passing

---
 packages/svelte/src/internal/client/reactivity/batch.js    | 5 +++--
 packages/svelte/src/internal/client/reactivity/equality.js | 4 +++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 6e9599e7e1..9f0f200e0a 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -512,6 +512,7 @@ export class Batch {
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
 		if ((derived.f & ERROR_VALUE) === 0) {
+			this.current.set(derived, value);
 			batch_values?.set(derived, value);
 		}
 
@@ -848,7 +849,7 @@ export class Batch {
 
 		// console.group('batch_values');
 		// for (const [value, v] of batch_values) {
-		// 	console.log(this.current.has(value), value.label, v);
+		// 	console.log(this.current.has(value), value.label, snapshot(v, true));
 		// }
 		// console.groupEnd();
 
@@ -865,7 +866,7 @@ export class Batch {
 
 		// console.group('batch_wvs');
 		// for (const [value, wv] of batch_wvs) {
-		// 	console.log(this.wvs.has(value), wv, value.label ?? value.v);
+		// 	console.log(this.wvs.has(value), wv, value.label ?? snapshot(value.v, true));
 		// }
 		// console.groupEnd();
 
diff --git a/packages/svelte/src/internal/client/reactivity/equality.js b/packages/svelte/src/internal/client/reactivity/equality.js
index 1041238573..a035f80af0 100644
--- a/packages/svelte/src/internal/client/reactivity/equality.js
+++ b/packages/svelte/src/internal/client/reactivity/equality.js
@@ -1,8 +1,10 @@
 /** @import { Equals } from '#client' */
 
+import { batch_values } from './batch.js';
+
 /** @type {Equals} */
 export function equals(value) {
-	return value === this.v;
+	return value === (batch_values?.get(this) ?? this.v);
 }
 
 /**

From db7cce904b61b2fbc3d1f8aec36480c588c4e0eb Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 20:10:50 -0400
Subject: [PATCH 052/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 9f0f200e0a..c6b6da5ffc 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -16,7 +16,8 @@ import {
 	EAGER_EFFECT,
 	ERROR_VALUE,
 	MANAGED_EFFECT,
-	REACTION_RAN
+	REACTION_RAN,
+	CONNECTED
 } from '#client/constants';
 import { async_mode_flag } from '../../flags/index.js';
 import { deferred, define_property, includes } from '../../shared/utils.js';
@@ -512,7 +513,11 @@ export class Batch {
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
 		if ((derived.f & ERROR_VALUE) === 0) {
-			this.current.set(derived, value);
+			// TODO not totally sure about the CONNECTED condition, seems like it should be irrelevant
+			if ((derived.f & CONNECTED) !== 0) {
+				this.current.set(derived, value);
+			}
+
 			batch_values?.set(derived, value);
 		}
 

From 38a47384be56e8a86b1c2db035a845a23bd4678d Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 22:18:25 -0400
Subject: [PATCH 053/122] fix

---
 packages/svelte/src/internal/client/render.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/render.js b/packages/svelte/src/internal/client/render.js
index cb152ed9c1..5c1be92633 100644
--- a/packages/svelte/src/internal/client/render.js
+++ b/packages/svelte/src/internal/client/render.js
@@ -173,13 +173,14 @@ function _mount(
 	var unmount = component_root(() => {
 		var anchor_node = anchor ?? target.appendChild(create_text());
 
+		push({});
+
 		boundary(
 			/** @type {TemplateNode} */ (anchor_node),
 			{
 				pending: () => {}
 			},
 			(anchor_node) => {
-				push({});
 				var ctx = /** @type {ComponentContext} */ (component_context);
 				if (context) ctx.c = context;
 
@@ -209,12 +210,12 @@ function _mount(
 						throw HYDRATION_ERROR;
 					}
 				}
-
-				pop();
 			},
 			transformError
 		);
 
+		pop();
+
 		// Setup event delegation _after_ component is mounted - if an error would happen during mount, it would otherwise not be cleaned up
 		/** @type {Set<string>} */
 		var registered_events = new Set();

From e0f3dae6f7a081c33c3387c31882b7c22a9a0717 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 22:18:55 -0400
Subject: [PATCH 054/122] fix

---
 packages/svelte/src/internal/client/reactivity/batch.js   | 1 +
 packages/svelte/src/internal/client/reactivity/sources.js | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index c6b6da5ffc..a091a5dcbb 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1323,6 +1323,7 @@ export function fork(fn) {
 	var committed = false;
 	var settled = batch.settled();
 
+	batch.apply();
 	flushSync(fn);
 
 	return {
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 7504615b4c..41af83456f 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -269,7 +269,9 @@ export function flush_eager_effects() {
 	eager_effects_deferred = false;
 
 	for (const effect of eager_effects) {
-		update_effect(effect);
+		if (is_dirty(effect)) {
+			update_effect(effect);
+		}
 	}
 
 	eager_effects.clear();

From a0fe4975ada34091a9d2202ae3860b605dbc42ea Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 30 Mar 2026 22:47:19 -0400
Subject: [PATCH 055/122] fix

---
 packages/svelte/src/internal/client/context.js         | 10 +++++++++-
 .../src/internal/client/dom/elements/bindings/input.js |  1 -
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/context.js b/packages/svelte/src/internal/client/context.js
index 0baef5c63e..50ff2584bd 100644
--- a/packages/svelte/src/internal/client/context.js
+++ b/packages/svelte/src/internal/client/context.js
@@ -227,7 +227,15 @@ export function pop(component) {
 
 /** @returns {boolean} */
 export function is_runes() {
-	return !legacy_mode_flag || (component_context !== null && component_context.l === null);
+	if (!legacy_mode_flag) {
+		return true;
+	}
+
+	// TODO feels like we could probably simplify this a bit. no tests fail without
+	// the first part, though would like to better understand usage before deleting
+	const context = component_context ?? active_reaction?.ctx ?? active_effect?.ctx;
+
+	return context?.l === null;
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/dom/elements/bindings/input.js b/packages/svelte/src/internal/client/dom/elements/bindings/input.js
index 55e61c3774..dadcac369c 100644
--- a/packages/svelte/src/internal/client/dom/elements/bindings/input.js
+++ b/packages/svelte/src/internal/client/dom/elements/bindings/input.js
@@ -7,7 +7,6 @@ import { is } from '../../../proxy.js';
 import { queue_micro_task } from '../../task.js';
 import { hydrating } from '../../hydration.js';
 import { tick, untrack } from '../../../runtime.js';
-import { is_runes } from '../../../context.js';
 import { current_batch, previous_batch } from '../../../reactivity/batch.js';
 import { async_mode_flag } from '../../../../flags/index.js';
 

From edd398900dee6dadf66bd5987b9521e85dc8ff76 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 31 Mar 2026 10:50:56 -0400
Subject: [PATCH 056/122] this test was just wrong?

---
 packages/svelte/tests/signals/test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/svelte/tests/signals/test.ts b/packages/svelte/tests/signals/test.ts
index 5486ccdb45..9c61a18c75 100644
--- a/packages/svelte/tests/signals/test.ts
+++ b/packages/svelte/tests/signals/test.ts
@@ -599,7 +599,7 @@ describe('signals', () => {
 
 		return () => {
 			flushSync();
-			assert.deepEqual(log, [20]);
+			assert.deepEqual(log, [20, 20]);
 		};
 	});
 

From 2beb9eaf8ff6fa78aa2dfad5bbeb31c9caf3c8ee Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 31 Mar 2026 11:10:43 -0400
Subject: [PATCH 057/122] slightly hacky fix. all tests passing

---
 packages/svelte/src/internal/client/constants.js         | 1 +
 packages/svelte/src/internal/client/reactivity/batch.js  | 9 +++++++--
 .../svelte/src/internal/client/reactivity/sources.js     | 5 +++--
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/packages/svelte/src/internal/client/constants.js b/packages/svelte/src/internal/client/constants.js
index 2c20fe7a7e..e5b2137491 100644
--- a/packages/svelte/src/internal/client/constants.js
+++ b/packages/svelte/src/internal/client/constants.js
@@ -44,6 +44,7 @@ export const HEAD_EFFECT = 1 << 18;
 export const EFFECT_PRESERVED = 1 << 19;
 export const USER_EFFECT = 1 << 20;
 export const EFFECT_OFFSCREEN = 1 << 25;
+export const STATE_EAGER_EFFECT = 1 << 27;
 
 // Flags exclusive to deriveds
 /**
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index a091a5dcbb..a97bb40e53 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -17,7 +17,8 @@ import {
 	ERROR_VALUE,
 	MANAGED_EFFECT,
 	REACTION_RAN,
-	CONNECTED
+	CONNECTED,
+	STATE_EAGER_EFFECT
 } from '#client/constants';
 import { async_mode_flag } from '../../flags/index.js';
 import { deferred, define_property, includes } from '../../shared/utils.js';
@@ -1211,7 +1212,7 @@ export function eager(fn) {
 		version.label = '<eager>';
 	}
 
-	eager_effect(() => {
+	var effect = eager_effect(() => {
 		if (initial) {
 			// the first time this runs, we create an eager effect
 			// that will run eagerly whenever the expression changes
@@ -1248,6 +1249,10 @@ export function eager(fn) {
 		}
 	});
 
+	// TODO ideally this wouldn't be necessary. I haven't figured out a way for these
+	// effects to correctly be marked dirty when `$state.eager(...)` arguments change
+	effect.f |= STATE_EAGER_EFFECT;
+
 	initial = false;
 
 	return value;
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 41af83456f..b55783f3ad 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -28,7 +28,8 @@ import {
 	ROOT_EFFECT,
 	ASYNC,
 	WAS_MARKED,
-	CONNECTED
+	CONNECTED,
+	STATE_EAGER_EFFECT
 } from '#client/constants';
 import * as e from '../errors.js';
 import { legacy_mode_flag, tracing_mode_flag } from '../../flags/index.js';
@@ -269,7 +270,7 @@ export function flush_eager_effects() {
 	eager_effects_deferred = false;
 
 	for (const effect of eager_effects) {
-		if (is_dirty(effect)) {
+		if ((effect.f & STATE_EAGER_EFFECT) !== 0 || is_dirty(effect)) {
 			update_effect(effect);
 		}
 	}

From 9d48444c5078cb7041e70d3be69bb7496ef2ee2d Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 31 Mar 2026 11:16:24 -0400
Subject: [PATCH 058/122] tidy up

---
 packages/svelte/src/internal/client/constants.js         | 1 -
 packages/svelte/src/internal/client/dev/debug.js         | 9 ++-------
 .../svelte/src/internal/client/dom/blocks/boundary.js    | 8 +-------
 packages/svelte/src/internal/client/reactivity/batch.js  | 6 ++----
 .../svelte/src/internal/client/reactivity/effects.js     | 2 --
 .../svelte/src/internal/client/reactivity/sources.js     | 3 ---
 packages/svelte/src/internal/client/runtime.js           | 8 ++------
 7 files changed, 7 insertions(+), 30 deletions(-)

diff --git a/packages/svelte/src/internal/client/constants.js b/packages/svelte/src/internal/client/constants.js
index e5b2137491..97c5fe55a1 100644
--- a/packages/svelte/src/internal/client/constants.js
+++ b/packages/svelte/src/internal/client/constants.js
@@ -24,7 +24,6 @@ export const BOUNDARY_EFFECT = 1 << 7;
 export const CONNECTED = 1 << 9;
 export const CLEAN = 1 << 10;
 export const DIRTY = 1 << 11;
-export const MAYBE_DIRTY = 1 << 12;
 export const INERT = 1 << 13;
 export const DESTROYED = 1 << 14;
 /** Set once a reaction has run for the first time */
diff --git a/packages/svelte/src/internal/client/dev/debug.js b/packages/svelte/src/internal/client/dev/debug.js
index 464780ec34..56dcbf497b 100644
--- a/packages/svelte/src/internal/client/dev/debug.js
+++ b/packages/svelte/src/internal/client/dev/debug.js
@@ -7,12 +7,10 @@ import {
 	CLEAN,
 	CONNECTED,
 	DERIVED,
-	DIRTY,
 	EFFECT,
 	ASYNC,
 	DESTROYED,
 	INERT,
-	MAYBE_DIRTY,
 	RENDER_EFFECT,
 	ROOT_EFFECT,
 	WAS_MARKED,
@@ -208,8 +206,6 @@ export function log_reactions(signal) {
 		const names = [];
 
 		if ((flags & CLEAN) !== 0) names.push('CLEAN');
-		if ((flags & DIRTY) !== 0) names.push('DIRTY');
-		if ((flags & MAYBE_DIRTY) !== 0) names.push('MAYBE_DIRTY');
 		if ((flags & CONNECTED) !== 0) names.push('CONNECTED');
 		if ((flags & WAS_MARKED) !== 0) names.push('WAS_MARKED');
 		if ((flags & INERT) !== 0) names.push('INERT');
@@ -266,7 +262,7 @@ export function log_reactions(signal) {
 				} else {
 					// It's an effect
 					const label = effect_label(/** @type {Effect} */ (reaction), true);
-					const status = (flags & MAYBE_DIRTY) !== 0 ? 'maybe dirty' : 'dirty';
+					const status = is_dirty(reaction) ? 'dirty' : 'clean';
 
 					// Collect parent statuses
 					/** @type {string[]} */
@@ -387,8 +383,7 @@ export function log_inconsistent_branches(effect) {
 		const is_branch = (flags & BRANCH_EFFECT) !== 0;
 
 		if (is_branch) {
-			const status =
-				(flags & CLEAN) !== 0 ? 'clean' : (flags & MAYBE_DIRTY) !== 0 ? 'maybe dirty' : 'dirty';
+			const status = (flags & CLEAN) !== 0 ? 'clean' : 'dirty';
 
 			/** @type {BranchInfo[]} */
 			const child_branches = [];
diff --git a/packages/svelte/src/internal/client/dom/blocks/boundary.js b/packages/svelte/src/internal/client/dom/blocks/boundary.js
index 5d68eed888..63c0e83241 100644
--- a/packages/svelte/src/internal/client/dom/blocks/boundary.js
+++ b/packages/svelte/src/internal/client/dom/blocks/boundary.js
@@ -1,11 +1,5 @@
 /** @import { Effect, Source, TemplateNode, } from '#client' */
-import {
-	BOUNDARY_EFFECT,
-	DIRTY,
-	EFFECT_PRESERVED,
-	EFFECT_TRANSPARENT,
-	MAYBE_DIRTY
-} from '#client/constants';
+import { BOUNDARY_EFFECT, EFFECT_PRESERVED, EFFECT_TRANSPARENT } from '#client/constants';
 import { HYDRATION_START_ELSE, HYDRATION_START_FAILED } from '../../../../constants.js';
 import { component_context, set_component_context } from '../../context.js';
 import { handle_error, invoke_error_boundary } from '../../error-handling.js';
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index a97bb40e53..8a7619a892 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -11,7 +11,6 @@ import {
 	INERT,
 	RENDER_EFFECT,
 	ROOT_EFFECT,
-	MAYBE_DIRTY,
 	DERIVED,
 	EAGER_EFFECT,
 	ERROR_VALUE,
@@ -1380,9 +1379,8 @@ export function fork(fn) {
 			await settled;
 		},
 		discard: () => {
-			// cause any MAYBE_DIRTY deriveds to update
-			// if they depend on things thath changed
-			// inside the discarded fork
+			// cause any deriveds to update if they depend on
+			// things that changed inside the discarded fork
 			for (var source of batch.current.keys()) {
 				source.wv = increment_write_version();
 			}
diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js
index a2b35a03a1..65a00688b5 100644
--- a/packages/svelte/src/internal/client/reactivity/effects.js
+++ b/packages/svelte/src/internal/client/reactivity/effects.js
@@ -14,7 +14,6 @@ import {
 	set_active_effect
 } from '../runtime.js';
 import {
-	DIRTY,
 	BRANCH_EFFECT,
 	RENDER_EFFECT,
 	EFFECT,
@@ -28,7 +27,6 @@ import {
 	CLEAN,
 	EAGER_EFFECT,
 	HEAD_EFFECT,
-	MAYBE_DIRTY,
 	EFFECT_PRESERVED,
 	STALE_REACTION,
 	USER_EFFECT,
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index b55783f3ad..074f9b4388 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -7,7 +7,6 @@ import {
 	get,
 	set_untracked_writes,
 	untrack,
-	increment_write_version,
 	update_effect,
 	current_sources,
 	is_dirty,
@@ -20,10 +19,8 @@ import { equals, safe_equals } from './equality.js';
 import {
 	CLEAN,
 	DERIVED,
-	DIRTY,
 	BRANCH_EFFECT,
 	EAGER_EFFECT,
-	MAYBE_DIRTY,
 	BLOCK_EFFECT,
 	ROOT_EFFECT,
 	ASYNC,
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index ca8fc4e1a0..2104e5e183 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -9,8 +9,6 @@ import {
 } from './reactivity/effects.js';
 import {
 	DIRTY,
-	MAYBE_DIRTY,
-	CLEAN,
 	DERIVED,
 	DESTROYED,
 	BRANCH_EFFECT,
@@ -50,7 +48,6 @@ import {
 } from './context.js';
 import {
 	Batch,
-	batch_cvs,
 	batch_values,
 	batch_wvs,
 	current_batch,
@@ -154,8 +151,7 @@ export function increment_write_version() {
 }
 
 /**
- * Determines whether a derived or effect is dirty.
- * If it is MAYBE_DIRTY, will set the status to CLEAN
+ * Determines whether a reaction is dirty
  * @param {Reaction} reaction
  * @returns {boolean}
  */
@@ -303,7 +299,7 @@ export function update_reaction(reaction) {
 			untracked_writes !== null &&
 			!untracking &&
 			deps !== null &&
-			(reaction.f & (DERIVED | MAYBE_DIRTY | DIRTY)) === 0
+			(reaction.f & (DERIVED | DIRTY)) === 0
 		) {
 			for (i = 0; i < /** @type {Source[]} */ (untracked_writes).length; i++) {
 				schedule_possible_effect_self_invalidation(

From 033573dbb36e3dc4b7746091a10665546ceee232 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 31 Mar 2026 11:17:47 -0400
Subject: [PATCH 059/122] no longer need whatever this nonsense was

---
 packages/svelte/src/internal/client/dom/blocks/each.js | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/packages/svelte/src/internal/client/dom/blocks/each.js b/packages/svelte/src/internal/client/dom/blocks/each.js
index b7674de588..ef67f60817 100644
--- a/packages/svelte/src/internal/client/dom/blocks/each.js
+++ b/packages/svelte/src/internal/client/dom/blocks/each.js
@@ -378,14 +378,6 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 			// continue in hydration mode
 			set_hydrating(true);
 		}
-
-		// When we mount the each block for the first time, the collection won't be
-		// connected to this effect as the effect hasn't finished running yet and its deps
-		// won't be assigned. However, it's possible that when reconciling the each block
-		// that a mutation occurred and it's made the collection MAYBE_DIRTY, so reading the
-		// collection again can provide consistency to the reactive graph again as the deriveds
-		// will now be `CLEAN`.
-		get(each_array);
 	});
 
 	/** @type {EachState} */

From ac238fb6434fe1c7dba2e65e00ce15595f5c482a Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 31 Mar 2026 11:23:53 -0400
Subject: [PATCH 060/122] remove maybe_dirty_effects

---
 .../internal/client/dom/blocks/boundary.js    |  7 ++----
 .../src/internal/client/reactivity/batch.js   | 23 ++-----------------
 .../src/internal/client/reactivity/utils.js   |  3 +--
 3 files changed, 5 insertions(+), 28 deletions(-)

diff --git a/packages/svelte/src/internal/client/dom/blocks/boundary.js b/packages/svelte/src/internal/client/dom/blocks/boundary.js
index 63c0e83241..8a9ffccc18 100644
--- a/packages/svelte/src/internal/client/dom/blocks/boundary.js
+++ b/packages/svelte/src/internal/client/dom/blocks/boundary.js
@@ -104,9 +104,6 @@ export class Boundary {
 	/** @type {Set<Effect>} */
 	#dirty_effects = new Set();
 
-	/** @type {Set<Effect>} */
-	#maybe_dirty_effects = new Set();
-
 	/**
 	 * A source containing the number of pending async deriveds/expressions.
 	 * Only created if `$effect.pending()` is used inside the boundary,
@@ -266,7 +263,7 @@ export class Boundary {
 
 		// any effects that were previously deferred should be transferred
 		// to the batch, which will flush in the next microtask
-		batch.transfer_effects(this.#dirty_effects, this.#maybe_dirty_effects);
+		batch.transfer_effects(this.#dirty_effects);
 	}
 
 	/**
@@ -274,7 +271,7 @@ export class Boundary {
 	 * @param {Effect} effect
 	 */
 	defer_effect(effect) {
-		defer_effect(effect, this.#dirty_effects, this.#maybe_dirty_effects);
+		defer_effect(effect, this.#dirty_effects);
 	}
 
 	/**
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 8a7619a892..78334539ca 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -186,12 +186,6 @@ export class Batch {
 	 */
 	#dirty_effects = new Set();
 
-	/**
-	 * Deferred effects that are MAYBE_DIRTY
-	 * @type {Set<Effect>}
-	 */
-	#maybe_dirty_effects = new Set();
-
 	/** @type {Map<Value, number>} */
 	wvs = new Map();
 
@@ -298,11 +292,6 @@ export class Batch {
 		// to be able to run them after processing the batch
 		if (!this.#is_deferred()) {
 			for (const e of this.#dirty_effects) {
-				this.#maybe_dirty_effects.delete(e);
-				this.schedule(e);
-			}
-
-			for (const e of this.#maybe_dirty_effects) {
 				this.schedule(e);
 			}
 		}
@@ -362,7 +351,6 @@ export class Batch {
 
 			// clear effects. Those that are still needed will be rescheduled through unskipping the skipped branches.
 			this.#dirty_effects.clear();
-			this.#maybe_dirty_effects.clear();
 
 			// append/remove branches
 			// console.group('branches');
@@ -437,7 +425,6 @@ export class Batch {
 				} else if (async_mode_flag && (flags & (RENDER_EFFECT | MANAGED_EFFECT)) !== 0) {
 					render_effects.push(effect);
 				} else if (is_dirty(effect)) {
-					if ((flags & BLOCK_EFFECT) !== 0) this.#maybe_dirty_effects.add(effect);
 					update_effect(effect);
 				}
 
@@ -467,7 +454,7 @@ export class Batch {
 	 */
 	#defer_effects(effects) {
 		for (var i = 0; i < effects.length; i += 1) {
-			defer_effect(effects[i], this.#dirty_effects, this.#maybe_dirty_effects);
+			defer_effect(effects[i], this.#dirty_effects);
 		}
 	}
 
@@ -743,19 +730,13 @@ export class Batch {
 
 	/**
 	 * @param {Set<Effect>} dirty_effects
-	 * @param {Set<Effect>} maybe_dirty_effects
 	 */
-	transfer_effects(dirty_effects, maybe_dirty_effects) {
+	transfer_effects(dirty_effects) {
 		for (const e of dirty_effects) {
 			this.#dirty_effects.add(e);
 		}
 
-		for (const e of maybe_dirty_effects) {
-			this.#maybe_dirty_effects.add(e);
-		}
-
 		dirty_effects.clear();
-		maybe_dirty_effects.clear();
 	}
 
 	/** @param {(batch: Batch) => void} fn */
diff --git a/packages/svelte/src/internal/client/reactivity/utils.js b/packages/svelte/src/internal/client/reactivity/utils.js
index 1d9c99a52c..daf29204ea 100644
--- a/packages/svelte/src/internal/client/reactivity/utils.js
+++ b/packages/svelte/src/internal/client/reactivity/utils.js
@@ -21,9 +21,8 @@ function clear_marked(deps) {
 /**
  * @param {Effect} effect
  * @param {Set<Effect>} dirty_effects
- * @param {Set<Effect>} maybe_dirty_effects
  */
-export function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
+export function defer_effect(effect, dirty_effects) {
 	dirty_effects.add(effect);
 
 	// Since we're not executing these effects now, we need to clear any WAS_MARKED flags

From d697d5066eb143834fd9bcbb0061e2637fbe4477 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 31 Mar 2026 11:27:10 -0400
Subject: [PATCH 061/122] remove some logging

---
 .../src/internal/client/reactivity/batch.js   | 45 -------------------
 1 file changed, 45 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 78334539ca..134ee6f6b7 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -275,8 +275,6 @@ export class Batch {
 	#process() {
 		if (this.#committed) return;
 
-		// console.group('process', this.id);
-
 		current_batch = this;
 
 		if (flush_count++ > 1000) {
@@ -336,7 +334,6 @@ export class Batch {
 		legacy_updates = null;
 
 		if (this.#is_deferred() || this.#is_blocked()) {
-			// console.log(this.#is_deferred() ? 'deferred' : 'blocked');
 			this.#defer_effects(render_effects);
 			this.#defer_effects(effects);
 
@@ -344,7 +341,6 @@ export class Batch {
 				reset_branch(e, t);
 			}
 		} else {
-			// console.log('resolved');
 			if (this.#pending.size === 0) {
 				batches.delete(this);
 			}
@@ -353,17 +349,13 @@ export class Batch {
 			this.#dirty_effects.clear();
 
 			// append/remove branches
-			// console.group('branches');
 			for (const fn of this.#commit_callbacks) fn(this);
 			this.#commit_callbacks.clear();
-			// console.groupEnd();
 
 			previous_batch = this;
 
-			// console.group('flush effects');
 			flush_queued_effects(render_effects);
 			flush_queued_effects(effects);
-			// console.groupEnd();
 			previous_batch = null;
 
 			this.#deferred?.resolve();
@@ -394,8 +386,6 @@ export class Batch {
 		if (!batches.has(this)) {
 			this.#commit();
 		}
-
-		// console.groupEnd();
 	}
 
 	/**
@@ -577,8 +567,6 @@ export class Batch {
 		if (this.#committed) return;
 		this.#committed = true;
 
-		// console.group('commit', this.id);
-
 		// If there are other pending batches, they now need to be 'rebased' —
 		// in other words, we re-run block/async effects with the newly
 		// committed state, unless the batch in question has a more
@@ -677,8 +665,6 @@ export class Batch {
 				}
 			}
 		}
-
-		// console.groupEnd();
 	}
 
 	/**
@@ -783,12 +769,6 @@ export class Batch {
 			return;
 		}
 
-		// console.group('apply', this.id);
-
-		// console.groupCollapsed('trace');
-		// console.trace();
-		// console.groupEnd();
-
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
 		batch_values = new Map(this.current);
@@ -832,31 +812,6 @@ export class Batch {
 				}
 			}
 		}
-
-		// console.group('batch_values');
-		// for (const [value, v] of batch_values) {
-		// 	console.log(this.current.has(value), value.label, snapshot(v, true));
-		// }
-		// console.groupEnd();
-
-		// console.group('batch_cvs');
-		// for (const [reaction, cv] of batch_cvs) {
-		// 	console.log(
-		// 		this.cvs.has(reaction),
-		// 		cv,
-		// 		reaction.deps?.map((d) => d.label ?? batch_values?.get(d)),
-		// 		reaction.label ?? reaction.fn
-		// 	);
-		// }
-		// console.groupEnd();
-
-		// console.group('batch_wvs');
-		// for (const [value, wv] of batch_wvs) {
-		// 	console.log(this.wvs.has(value), wv, value.label ?? snapshot(value.v, true));
-		// }
-		// console.groupEnd();
-
-		// console.groupEnd();
 	}
 
 	/**

From e9a418f78a1f0755632e03b1d18e254cd2804727 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 31 Mar 2026 11:27:46 -0400
Subject: [PATCH 062/122] unused

---
 packages/svelte/src/internal/client/reactivity/batch.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 134ee6f6b7..8f16e44b88 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -47,7 +47,6 @@ import { defer_effect } from './utils.js';
 import { UNINITIALIZED } from '../../../constants.js';
 import { legacy_is_updating_store } from './store.js';
 import { invariant } from '../../shared/dev.js';
-import { log_effect_tree, root } from '../dev/debug.js';
 
 /** @type {Set<Batch>} */
 const batches = new Set();

From 3413d3d5ff2601167f03827ea028437918cf87d6 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 31 Mar 2026 11:36:39 -0400
Subject: [PATCH 063/122] tidy up

---
 .../svelte/src/internal/client/constants.js     |  1 -
 .../src/internal/client/reactivity/batch.js     |  9 ++-------
 .../src/internal/client/reactivity/deriveds.js  | 17 ++++-------------
 packages/svelte/src/internal/client/runtime.js  |  5 ++---
 packages/svelte/src/legacy/legacy-client.js     |  7 +++----
 5 files changed, 11 insertions(+), 28 deletions(-)

diff --git a/packages/svelte/src/internal/client/constants.js b/packages/svelte/src/internal/client/constants.js
index 97c5fe55a1..3fcea0e1e2 100644
--- a/packages/svelte/src/internal/client/constants.js
+++ b/packages/svelte/src/internal/client/constants.js
@@ -23,7 +23,6 @@ export const BOUNDARY_EFFECT = 1 << 7;
  */
 export const CONNECTED = 1 << 9;
 export const CLEAN = 1 << 10;
-export const DIRTY = 1 << 11;
 export const INERT = 1 << 13;
 export const DESTROYED = 1 << 14;
 /** Set once a reaction has run for the first time */
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 8f16e44b88..4f97f3fb9b 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -5,7 +5,6 @@ import {
 	BRANCH_EFFECT,
 	CLEAN,
 	DESTROYED,
-	DIRTY,
 	EFFECT,
 	ASYNC,
 	INERT,
@@ -180,7 +179,7 @@ export class Batch {
 	#new_deriveds = [];
 
 	/**
-	 * Deferred effects (which run after async work has completed) that are DIRTY
+	 * Deferred effects (which run after async work has completed) that are dirty
 	 * @type {Set<Effect>}
 	 */
 	#dirty_effects = new Set();
@@ -1044,11 +1043,7 @@ function mark_effects(batch, value, sources, marked, checked) {
 
 			if ((flags & DERIVED) !== 0) {
 				mark_effects(batch, /** @type {Derived} */ (reaction), sources, marked, checked);
-			} else if (
-				(flags & (ASYNC | BLOCK_EFFECT)) !== 0 &&
-				(flags & DIRTY) === 0 &&
-				depends_on(reaction, sources, checked)
-			) {
+			} else if ((flags & (ASYNC | BLOCK_EFFECT)) !== 0 && depends_on(reaction, sources, checked)) {
 				batch.schedule(/** @type {Effect} */ (reaction));
 				batch.cvs.set(reaction, -1);
 			}
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 3d7acb3fc7..7a683ff9cc 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -5,7 +5,6 @@ import { DEV } from 'esm-env';
 import {
 	ERROR_VALUE,
 	DERIVED,
-	DIRTY,
 	EFFECT_PRESERVED,
 	STALE_REACTION,
 	ASYNC,
@@ -19,7 +18,6 @@ import {
 	update_reaction,
 	set_active_effect,
 	push_reaction_value,
-	is_destroying_effect,
 	update_effect,
 	remove_reactions,
 	write_version
@@ -27,21 +25,15 @@ import {
 import { equals, safe_equals } from './equality.js';
 import * as e from '../errors.js';
 import * as w from '../warnings.js';
-import {
-	async_effect,
-	destroy_effect,
-	destroy_effect_children,
-	effect_tracking,
-	teardown
-} from './effects.js';
+import { async_effect, destroy_effect, destroy_effect_children, teardown } from './effects.js';
 import { eager_effects, internal_set, set_eager_effects, source } from './sources.js';
 import { get_error } from '../../shared/dev.js';
 import { async_mode_flag, tracing_mode_flag } from '../../flags/index.js';
 import { component_context } from '../context.js';
 import { UNINITIALIZED } from '../../../constants.js';
-import { batch_values, batch_wvs, current_batch, get_wv, set_cv } from './batch.js';
+import { batch_wvs, current_batch, get_wv, set_cv } from './batch.js';
 import { increment_pending, unset_context } from './async.js';
-import { deferred, includes, noop } from '../../shared/utils.js';
+import { deferred, noop } from '../../shared/utils.js';
 
 /**
  * This allows us to track 'reactivity loss' that occurs when signals
@@ -64,7 +56,6 @@ export const recent_async_deriveds = new Set();
  */
 /*#__NO_SIDE_EFFECTS__*/
 export function derived(fn) {
-	var flags = DERIVED | DIRTY;
 	var parent_derived =
 		active_reaction !== null && (active_reaction.f & DERIVED) !== 0
 			? /** @type {Derived} */ (active_reaction)
@@ -82,7 +73,7 @@ export function derived(fn) {
 		deps: null,
 		effects: null,
 		equals,
-		f: flags,
+		f: DERIVED,
 		fn,
 		reactions: null,
 		cv: -1,
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 2104e5e183..3833193914 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -8,7 +8,6 @@ import {
 	execute_effect_teardown
 } from './reactivity/effects.js';
 import {
-	DIRTY,
 	DERIVED,
 	DESTROYED,
 	BRANCH_EFFECT,
@@ -299,7 +298,7 @@ export function update_reaction(reaction) {
 			untracked_writes !== null &&
 			!untracking &&
 			deps !== null &&
-			(reaction.f & (DERIVED | DIRTY)) === 0
+			(reaction.f & DERIVED) === 0
 		) {
 			for (i = 0; i < /** @type {Source[]} */ (untracked_writes).length; i++) {
 				schedule_possible_effect_self_invalidation(
@@ -473,7 +472,7 @@ export function update_effect(effect) {
 
 		// In DEV, increment versions of any sources that were written to during the effect,
 		// so that they are correctly marked as dirty when the effect re-runs
-		if (DEV && tracing_mode_flag && (effect.f & DIRTY) !== 0 && effect.deps !== null) {
+		if (DEV && tracing_mode_flag && effect.deps !== null) {
 			for (var dep of effect.deps) {
 				if (dep.set_during_effect) {
 					dep.wv = increment_write_version();
diff --git a/packages/svelte/src/legacy/legacy-client.js b/packages/svelte/src/legacy/legacy-client.js
index 1fdbc1f5c3..adf11eb988 100644
--- a/packages/svelte/src/legacy/legacy-client.js
+++ b/packages/svelte/src/legacy/legacy-client.js
@@ -1,6 +1,6 @@
 /** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
 /** @import { Derived, Value } from '#client' */
-import { DERIVED, DIRTY, EFFECT_LEGACY, LEGACY_PROPS } from '../internal/client/constants.js';
+import { DERIVED, EFFECT_LEGACY, LEGACY_PROPS } from '../internal/client/constants.js';
 import { user_pre_effect } from '../internal/client/reactivity/effects.js';
 import { mutable_source, set } from '../internal/client/reactivity/sources.js';
 import { hydrate, mount, unmount } from '../internal/client/render.js';
@@ -9,10 +9,9 @@ import {
 	get,
 	new_deps,
 	skipped_deps,
-	untracked_writes,
-	write_version
+	untracked_writes
 } from '../internal/client/runtime.js';
-import { flushSync, get_cv } from '../internal/client/reactivity/batch.js';
+import { flushSync } from '../internal/client/reactivity/batch.js';
 import { define_property, is_array } from '../internal/shared/utils.js';
 import * as e from '../internal/client/errors.js';
 import * as w from '../internal/client/warnings.js';

From c5377d3e81f22d6e2edac818ce3aba0733b2b248 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 1 Apr 2026 13:02:50 -0400
Subject: [PATCH 064/122] apparently unnecessary?

---
 .../src/internal/client/reactivity/batch.js     | 17 -----------------
 .../src/internal/client/reactivity/deriveds.js  |  2 --
 2 files changed, 19 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 4f97f3fb9b..f895b01faf 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -172,12 +172,6 @@ export class Batch {
 	 */
 	#new_effects = [];
 
-	/**
-	 * Deriveds created while this batch was active.
-	 * @type {Derived[]}
-	 */
-	#new_deriveds = [];
-
 	/**
 	 * Deferred effects (which run after async work has completed) that are dirty
 	 * @type {Set<Effect>}
@@ -551,13 +545,6 @@ export class Batch {
 		this.#new_effects.push(effect);
 	}
 
-	/**
-	 * @param {Derived} derived
-	 */
-	register_created_derived(derived) {
-		this.#new_deriveds.push(derived);
-	}
-
 	#committed = false;
 
 	#commit() {
@@ -634,10 +621,6 @@ export class Batch {
 					}
 				}
 
-				for (const derived of this.#new_deriveds) {
-					batch.cvs.set(derived, -1);
-				}
-
 				// Only apply and traverse when we know we triggered async work with marking the effects
 				if (batch.#roots.length > 0) {
 					batch.apply();
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 7a683ff9cc..0b89f91a0d 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -88,8 +88,6 @@ export function derived(fn) {
 		signal.created = get_error('created at');
 	}
 
-	current_batch?.register_created_derived(signal);
-
 	return signal;
 }
 

From ce6e3e3ee75faf109ef5a68232a27b44084be207 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 1 Apr 2026 13:51:48 -0400
Subject: [PATCH 065/122] chore: generate markdown files from CPU profiles for
 agent-driven investigations

---
 benchmarking/utils.js | 257 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 255 insertions(+), 2 deletions(-)

diff --git a/benchmarking/utils.js b/benchmarking/utils.js
index b363576963..4266611474 100644
--- a/benchmarking/utils.js
+++ b/benchmarking/utils.js
@@ -49,6 +49,253 @@ function safe(name) {
 	return name.replace(/[^a-z0-9._-]+/gi, '_');
 }
 
+/**
+ * @param {unknown} value
+ */
+function format_markdown_value(value) {
+	if (value === null || value === undefined) return '';
+	if (Array.isArray(value)) return value.map((item) => String(item)).join(', ');
+	if (typeof value === 'object') return JSON.stringify(value);
+	return String(value);
+}
+
+/**
+ * @param {string} text
+ */
+function escape_markdown_cell(text) {
+	return text.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+
+/**
+ * @param {string} value
+ */
+function normalize_profile_url(value) {
+	if (!value) return '';
+
+	if (value.startsWith('file://')) {
+		try {
+			const pathname = decodeURIComponent(new URL(value).pathname);
+			const relative = path.relative(process.cwd(), pathname);
+			if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) return relative;
+			return pathname;
+		} catch {
+			return value;
+		}
+	}
+
+	if (path.isAbsolute(value)) {
+		const relative = path.relative(process.cwd(), value);
+		if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) return relative;
+	}
+
+	return value;
+}
+
+/**
+ * @param {string} function_name
+ */
+function is_special_runtime_node(function_name) {
+	return function_name === '(idle)' || function_name === '(garbage collector)';
+}
+
+/**
+ * @param {string} normalized_url
+ */
+function is_svelte_source_url(normalized_url) {
+	return normalized_url.startsWith('packages/svelte/');
+}
+
+/**
+ * @param {Record<string, unknown>} profile
+ */
+function profile_to_markdown(profile) {
+	/** @type {string[]} */
+	const lines = ['# CPU profile'];
+
+	const metadata = Object.entries(profile).filter(
+		([key]) => key !== 'nodes' && key !== 'samples' && key !== 'timeDeltas'
+	);
+
+	if (metadata.length > 0) {
+		lines.push('', '## Metadata', '| Field | Value |', '| --- | --- |');
+		for (const [key, value] of metadata) {
+			lines.push(
+				`| ${escape_markdown_cell(key)} | ${escape_markdown_cell(format_markdown_value(value))} |`
+			);
+		}
+	}
+
+	const nodes = Array.isArray(profile.nodes) ? profile.nodes : [];
+	const samples = Array.isArray(profile.samples) ? profile.samples : [];
+	const timeDeltas = Array.isArray(profile.timeDeltas) ? profile.timeDeltas : [];
+	/** @type {Set<number>} */
+	const included_node_ids = new Set();
+
+	if (nodes.length > 0) {
+		/** @type {Map<number, Record<string, unknown>>} */
+		const nodes_by_id = new Map();
+
+		/** @type {Map<number, number>} */
+		const parent_by_id = new Map();
+
+		for (const node of nodes) {
+			if (!node || typeof node !== 'object') continue;
+			if (typeof node.id !== 'number') continue;
+			nodes_by_id.set(node.id, node);
+			const children = Array.isArray(node.children) ? node.children : [];
+			for (const child of children) {
+				if (typeof child === 'number') {
+					parent_by_id.set(child, node.id);
+				}
+			}
+
+			const callFrame =
+				node.callFrame && typeof node.callFrame === 'object'
+					? /** @type {Record<string, unknown>} */ (node.callFrame)
+					: /** @type {Record<string, unknown>} */ ({});
+			const functionName =
+				typeof callFrame.functionName === 'string' ? callFrame.functionName : '(anonymous)';
+			const normalizedUrl =
+				typeof callFrame.url === 'string' ? normalize_profile_url(callFrame.url) : '';
+
+			if (is_special_runtime_node(functionName) || is_svelte_source_url(normalizedUrl)) {
+				included_node_ids.add(node.id);
+			}
+		}
+
+		/** @type {Map<number, number>} */
+		const self_sample_count = new Map();
+		for (const sample of samples) {
+			if (typeof sample !== 'number') continue;
+			if (!included_node_ids.has(sample)) continue;
+			self_sample_count.set(sample, (self_sample_count.get(sample) ?? 0) + 1);
+		}
+
+		/** @type {Map<number, number>} */
+		const inclusive_sample_count = new Map();
+		/** @type {Set<number>} */
+		const stack = new Set();
+
+		/** @param {number} node_id */
+		const get_inclusive_count = (node_id) => {
+			const cached = inclusive_sample_count.get(node_id);
+			if (cached !== undefined) return cached;
+			if (stack.has(node_id)) return self_sample_count.get(node_id) ?? 0;
+
+			stack.add(node_id);
+			const node = nodes_by_id.get(node_id);
+			const children = node && Array.isArray(node.children) ? node.children : [];
+			let total = self_sample_count.get(node_id) ?? 0;
+
+			for (const child of children) {
+				if (typeof child !== 'number') continue;
+				total += get_inclusive_count(child);
+			}
+
+			stack.delete(node_id);
+			inclusive_sample_count.set(node_id, total);
+			return total;
+		};
+
+		for (const node_id of included_node_ids) {
+			get_inclusive_count(node_id);
+		}
+
+		const total_samples = [...self_sample_count.values()].reduce((sum, count) => sum + count, 0);
+		if (total_samples > 0) {
+			const hotspot_rows = [...included_node_ids]
+				.map((id) => nodes_by_id.get(id))
+				.filter((node) => !!node)
+				.map((node) => {
+					const id = /** @type {number} */ (node.id);
+					const callFrame =
+						node.callFrame && typeof node.callFrame === 'object'
+							? /** @type {Record<string, unknown>} */ (node.callFrame)
+							: /** @type {Record<string, unknown>} */ ({});
+					const functionName =
+						typeof callFrame.functionName === 'string' && callFrame.functionName.length > 0
+							? callFrame.functionName
+							: '(anonymous)';
+					const selfCount = self_sample_count.get(id) ?? 0;
+					const inclusiveCount = inclusive_sample_count.get(id) ?? selfCount;
+					return { id, functionName, selfCount, inclusiveCount };
+				})
+				.filter((row) => row.selfCount > 0 || row.inclusiveCount > 0)
+				.sort(
+					(a, b) =>
+						b.inclusiveCount - a.inclusiveCount ||
+						b.selfCount - a.selfCount ||
+						String(a.id).localeCompare(String(b.id))
+				)
+				.slice(0, 25);
+
+			if (hotspot_rows.length > 0) {
+				lines.push(
+					'',
+					'## Top hotspots',
+					'| Rank | Node ID | Function | Self samples | Self % | Inclusive samples | Inclusive % |',
+					'| --- | --- | --- | --- | --- | --- | --- |'
+				);
+
+				for (let i = 0; i < hotspot_rows.length; i += 1) {
+					const row = hotspot_rows[i];
+					const selfPct = ((row.selfCount / total_samples) * 100).toFixed(2);
+					const inclusivePct = ((row.inclusiveCount / total_samples) * 100).toFixed(2);
+					lines.push(
+						`| ${i + 1} | ${row.id} | ${escape_markdown_cell(row.functionName)} | ${row.selfCount} | ${selfPct}% | ${row.inclusiveCount} | ${inclusivePct}% |`
+					);
+				}
+			}
+		}
+
+		lines.push(
+			'',
+			'## Nodes',
+			'| ID | Parent ID | Function | URL | Line | Column | Hit count | Children | Deopt reason |',
+			'| --- | --- | --- | --- | --- | --- | --- | --- | --- |'
+		);
+
+		for (const node of nodes) {
+			if (!node || typeof node !== 'object') continue;
+			if (typeof node.id !== 'number') continue;
+			if (!included_node_ids.has(node.id)) continue;
+
+			const callFrame =
+				node.callFrame && typeof node.callFrame === 'object'
+					? /** @type {Record<string, unknown>} */ (node.callFrame)
+					: /** @type {Record<string, unknown>} */ ({});
+
+			const id = typeof node.id === 'number' ? node.id : '';
+			const parentId =
+				typeof id === 'number' && included_node_ids.has(parent_by_id.get(id) ?? NaN)
+					? parent_by_id.get(id) ?? ''
+					: '';
+			const functionName =
+				typeof callFrame.functionName === 'string' && callFrame.functionName.length > 0
+					? callFrame.functionName
+					: '(anonymous)';
+			const url = typeof callFrame.url === 'string' ? normalize_profile_url(callFrame.url) : '';
+			const lineNumber =
+				typeof callFrame.lineNumber === 'number' ? String(callFrame.lineNumber + 1) : '';
+			const columnNumber =
+				typeof callFrame.columnNumber === 'number' ? String(callFrame.columnNumber + 1) : '';
+			const hitCount = typeof node.hitCount === 'number' ? node.hitCount : '';
+			const children = Array.isArray(node.children)
+				? node.children
+						.filter((child) => typeof child === 'number' && included_node_ids.has(child))
+						.join(', ')
+				: '';
+			const deoptReason = typeof node.deoptReason === 'string' ? node.deoptReason : '';
+
+			lines.push(
+				`| ${escape_markdown_cell(String(id))} | ${escape_markdown_cell(String(parentId))} | ${escape_markdown_cell(functionName)} | ${escape_markdown_cell(url)} | ${escape_markdown_cell(lineNumber)} | ${escape_markdown_cell(columnNumber)} | ${escape_markdown_cell(String(hitCount))} | ${escape_markdown_cell(children)} | ${escape_markdown_cell(deoptReason)} |`
+			);
+		}
+	}
+
+	return `${lines.join('\n')}\n`;
+}
+
 /**
  * @template T
  * @param {string | null} profile_dir
@@ -73,8 +320,14 @@ export async function with_cpu_profile(profile_dir, profile_name, fn) {
 		return await fn();
 	} finally {
 		const { profile } = /** @type {{ profile: object }} */ (await session.post('Profiler.stop'));
-		const file = path.join(profile_dir, `${safe(profile_name)}.cpuprofile`);
-		fs.writeFileSync(file, JSON.stringify(profile));
+		const safe_profile_name = safe(profile_name);
+		const profile_file = path.join(profile_dir, `${safe_profile_name}.cpuprofile`);
+		const markdown_file = path.join(profile_dir, `${safe_profile_name}.md`);
+		fs.writeFileSync(profile_file, JSON.stringify(profile));
+		fs.writeFileSync(
+			markdown_file,
+			profile_to_markdown(/** @type {Record<string, unknown>} */ (profile))
+		);
 		session.disconnect();
 	}
 }

From 71e49016253026025974a77baa24a3df7f3882de Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 16:20:57 -0400
Subject: [PATCH 066/122] avoid allocation

---
 .../src/internal/client/reactivity/deriveds.js     | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index bf9aab2205..d574f8100a 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -378,7 +378,19 @@ export function execute_derived(derived) {
 export function update_derived(derived) {
 	var value = execute_derived(derived);
 
-	set_cv(derived, derived.deps === null ? Infinity : Math.max(...derived.deps.map(get_wv)));
+	var deps = derived.deps;
+	var cv = Infinity;
+
+	if (deps !== null) {
+		cv = -Infinity;
+
+		for (var i = 0; i < deps.length; i++) {
+			var dep_wv = get_wv(deps[i]);
+			if (dep_wv > cv) cv = dep_wv;
+		}
+	}
+
+	set_cv(derived, cv);
 
 	if (!derived.equals(value)) {
 		batch_wvs?.set(derived, write_version);

From e6206ce4824db907f30787a7fcf0d361c42e62a4 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 16:39:07 -0400
Subject: [PATCH 067/122] bail out of mark_reactions if wv > cv

---
 .../src/internal/client/reactivity/batch.js   |  4 ++--
 .../src/internal/client/reactivity/sources.js | 22 +++++++++++--------
 2 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index f895b01faf..9219f23b45 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -274,8 +274,8 @@ export class Batch {
 			infinite_loop_guard();
 		}
 
-		for (const source of this.current.keys()) {
-			mark_reactions(source, null);
+		for (const [source, wv] of this.wvs) {
+			mark_reactions(source, wv, null);
 		}
 
 		// we only reschedule previously-deferred effects if we expect
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 1a7cbca886..ae837b9bd7 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -40,7 +40,8 @@ import {
 	eager_block_effects,
 	schedule_effect,
 	legacy_updates,
-	set_cv
+	set_cv,
+	get_cv
 } from './batch.js';
 import { proxy } from '../proxy.js';
 import { execute_derived } from './deriveds.js';
@@ -231,7 +232,7 @@ export function internal_set(source, value, updated_during_traversal = null) {
 
 		// For debugging, in case you want to know which reactions are being scheduled:
 		// log_reactions(source);
-		mark_reactions(source, updated_during_traversal);
+		mark_reactions(source, write_version, updated_during_traversal);
 
 		// It's possible that the current reaction might not have up-to-date dependencies
 		// whilst it's actively running. So in the case of ensuring it registers the reaction
@@ -310,10 +311,11 @@ export function increment(source) {
 
 /**
  * @param {Value} signal
+ * @param {number} wv
  * @param {Effect[] | null} updated_during_traversal
  * @returns {void}
  */
-export function mark_reactions(signal, updated_during_traversal) {
+export function mark_reactions(signal, wv, updated_during_traversal) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
 
@@ -338,13 +340,15 @@ export function mark_reactions(signal, updated_during_traversal) {
 
 			batch_values?.delete(derived);
 
-			if ((flags & WAS_MARKED) === 0) {
-				// Only connected deriveds can be reliably unmarked right away
-				if (flags & CONNECTED) {
-					reaction.f |= WAS_MARKED;
-				}
+			if (wv > get_cv(derived)) {
+				if ((flags & WAS_MARKED) === 0) {
+					// Only connected deriveds can be reliably unmarked right away
+					if (flags & CONNECTED) {
+						reaction.f |= WAS_MARKED;
+					}
 
-				mark_reactions(derived, updated_during_traversal);
+					mark_reactions(derived, wv, updated_during_traversal);
+				}
 			}
 		} else {
 			var effect = /** @type {Effect} */ (reaction);

From 0c5083ce2bbb5914df6724fc7310a442b12c92e9 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 17:05:40 -0400
Subject: [PATCH 068/122] note to self

---
 packages/svelte/src/internal/client/reactivity/batch.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 9219f23b45..557d3f9789 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -274,6 +274,7 @@ export class Batch {
 			infinite_loop_guard();
 		}
 
+		// TODO we only need to do this for re-runs
 		for (const [source, wv] of this.wvs) {
 			mark_reactions(source, wv, null);
 		}

From e12ac55b579e2c614b08785260c77dab52fb0c39 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 20:07:24 -0400
Subject: [PATCH 069/122] i don't think we need this

---
 .../svelte/src/internal/client/reactivity/batch.js     | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 557d3f9789..b3161c16fc 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -187,9 +187,6 @@ export class Batch {
 	/** @type {Map<Value, number>} */
 	previous_wvs = new Map();
 
-	/** @type {Map<Reaction, number>} */
-	previous_cvs = new Map();
-
 	/**
 	 * A map of branches that still exist, but will be destroyed when this batch
 	 * is committed — we skip over these during `process`.
@@ -478,7 +475,6 @@ export class Batch {
 	capture_derived(derived, value) {
 		if (derived.v !== UNINITIALIZED && !this.previous.has(derived)) {
 			this.previous.set(derived, derived.v);
-			this.previous_cvs.set(derived, derived.cv);
 		}
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
@@ -781,12 +777,6 @@ export class Batch {
 					}
 				}
 
-				for (const [reaction, cv] of batch.previous_cvs) {
-					if (!batch_cvs.has(reaction)) {
-						batch_cvs.set(reaction, cv);
-					}
-				}
-
 				for (const [value, wv] of batch.previous_wvs) {
 					if (!batch_wvs.has(value)) {
 						batch_wvs.set(value, wv);

From 04f773ea0e5cb62fde9900a2d240c930b6d5f3ba Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 20:13:44 -0400
Subject: [PATCH 070/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index b3161c16fc..50d0406096 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -475,6 +475,7 @@ export class Batch {
 	capture_derived(derived, value) {
 		if (derived.v !== UNINITIALIZED && !this.previous.has(derived)) {
 			this.previous.set(derived, derived.v);
+			this.previous_wvs.set(derived, derived.wv);
 		}
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`

From ef744bea463a61865a3a0e4e49a2779f8518a2a5 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 20:18:35 -0400
Subject: [PATCH 071/122] combine previous and previous_wvs

---
 .../src/internal/client/reactivity/batch.js   | 26 ++++++-------------
 .../src/internal/client/reactivity/types.d.ts |  5 ++++
 2 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 50d0406096..3e7422a780 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1,5 +1,5 @@
 /** @import { Fork } from 'svelte' */
-/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
+/** @import { Derived, Effect, Reaction, Source, Value, ValueSnapshot } from '#client' */
 import {
 	BLOCK_EFFECT,
 	BRANCH_EFFECT,
@@ -124,7 +124,7 @@ export class Batch {
 	/**
 	 * The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
 	 * They keys of this map are identical to `this.#current`
-	 * @type {Map<Value, any>}
+	 * @type {Map<Value, ValueSnapshot>}
 	 */
 	previous = new Map();
 
@@ -184,9 +184,6 @@ export class Batch {
 	/** @type {Map<Reaction, number>} */
 	cvs = new Map();
 
-	/** @type {Map<Value, number>} */
-	previous_wvs = new Map();
-
 	/**
 	 * A map of branches that still exist, but will be destroyed when this batch
 	 * is committed — we skip over these during `process`.
@@ -446,8 +443,7 @@ export class Batch {
 	 */
 	capture(source, value) {
 		if (source.v !== UNINITIALIZED && !this.previous.has(source)) {
-			this.previous.set(source, source.v);
-			this.previous_wvs.set(source, source.wv);
+			this.previous.set(source, { v: source.v, wv: source.wv });
 		}
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
@@ -474,8 +470,7 @@ export class Batch {
 	 */
 	capture_derived(derived, value) {
 		if (derived.v !== UNINITIALIZED && !this.previous.has(derived)) {
-			this.previous.set(derived, derived.v);
-			this.previous_wvs.set(derived, derived.wv);
+			this.previous.set(derived, { v: derived.v, wv: derived.wv });
 		}
 
 		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
@@ -772,15 +767,10 @@ export class Batch {
 			if (intersects && differs) {
 				this.#blockers.add(batch);
 			} else {
-				for (const [source, previous] of batch.previous) {
-					if (!batch_values.has(source)) {
-						batch_values.set(source, previous);
-					}
-				}
-
-				for (const [value, wv] of batch.previous_wvs) {
-					if (!batch_wvs.has(value)) {
-						batch_wvs.set(value, wv);
+				for (const [value, snapshot] of batch.previous) {
+					if (!batch_values.has(value)) {
+						batch_values.set(value, snapshot.v);
+						batch_wvs.set(value, snapshot.wv);
 					}
 				}
 			}
diff --git a/packages/svelte/src/internal/client/reactivity/types.d.ts b/packages/svelte/src/internal/client/reactivity/types.d.ts
index fec23c69ff..5cde587830 100644
--- a/packages/svelte/src/internal/client/reactivity/types.d.ts
+++ b/packages/svelte/src/internal/client/reactivity/types.d.ts
@@ -109,3 +109,8 @@ export interface Blocker {
 	promise: Promise<any>;
 	settled: boolean;
 }
+
+export interface ValueSnapshot<T = any> {
+	v: T;
+	wv: number;
+}

From eca510c6bf7f079241a9bf5da883f55c1669fb2f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 20:22:02 -0400
Subject: [PATCH 072/122] unused

---
 packages/svelte/src/internal/client/reactivity/batch.js | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 3e7422a780..4c6efad89c 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -116,11 +116,6 @@ export class Batch {
 	 */
 	current = new Map();
 
-	/**
-	 * @type {Map<Derived, any>}
-	 */
-	current_deriveds = new Map();
-
 	/**
 	 * The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
 	 * They keys of this map are identical to `this.#current`

From 6beb6c634640b46e177b83d19238589c2b261cc7 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 20:51:00 -0400
Subject: [PATCH 073/122] redundant

---
 packages/svelte/src/internal/client/reactivity/sources.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index ae837b9bd7..95a1b3bc24 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -194,8 +194,6 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			}
 
 			set_cv(derived);
-			batch.wvs.set(derived, write_version);
-			derived.wv = write_version;
 		}
 
 		batch.capture(source, value);

From 18479217a736e51fa570b13cf1a4ae035c84e2ff Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 21:52:08 -0400
Subject: [PATCH 074/122] create new active_batch concept

---
 .../svelte/src/internal/client/reactivity/batch.js | 14 ++++++++++++++
 .../src/internal/client/reactivity/deriveds.js     |  9 ++++-----
 packages/svelte/src/internal/client/runtime.js     |  3 ++-
 3 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 4c6efad89c..47e55bb2fc 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -53,6 +53,15 @@ const batches = new Set();
 /** @type {Batch | null} */
 export let current_batch = null;
 
+/**
+ * The batch that is currently applied. May not be the same as `current_batch`, since we
+ * null that out when flushing effects in case they set state, resulting in a new
+ * batch being created. Effects always run inside an active_batch.
+ * TODO most occurrences of `current_batch` should be this
+ * @type {Batch | null}
+ **/
+export let active_batch = null;
+
 /**
  * This is needed to avoid overwriting inputs
  * @type {Batch | null}
@@ -353,6 +362,8 @@ export class Batch {
 			batch.#roots.push(...this.#roots.filter((r) => !batch.#roots.includes(r)));
 		}
 
+		active_batch = null;
+
 		if (next_batch !== null) {
 			batches.add(next_batch);
 
@@ -507,6 +518,7 @@ export class Batch {
 			is_processing = false;
 
 			current_batch = null;
+			active_batch = null;
 			batch_values = batch_cvs = batch_wvs = null;
 
 			old_values.clear();
@@ -738,6 +750,8 @@ export class Batch {
 			return;
 		}
 
+		active_batch = this;
+
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
 		batch_values = new Map(this.current);
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index d574f8100a..dc88ef70eb 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -31,7 +31,7 @@ import { get_error } from '../../shared/dev.js';
 import { async_mode_flag, tracing_mode_flag } from '../../flags/index.js';
 import { component_context } from '../context.js';
 import { UNINITIALIZED } from '../../../constants.js';
-import { batch_wvs, current_batch, get_wv, set_cv } from './batch.js';
+import { current_batch, get_wv, active_batch, set_cv } from './batch.js';
 import { increment_pending, unset_context } from './async.js';
 import { deferred, noop } from '../../shared/utils.js';
 
@@ -393,10 +393,9 @@ export function update_derived(derived) {
 	set_cv(derived, cv);
 
 	if (!derived.equals(value)) {
-		batch_wvs?.set(derived, write_version);
-
-		if (current_batch !== null) {
-			current_batch.capture_derived(derived, value);
+		if (active_batch !== null) {
+			active_batch.capture_derived(derived, value);
+			active_batch.wvs.set(derived, write_version);
 		} else {
 			derived.v = value;
 			derived.wv = write_version;
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 3833193914..e278976975 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -52,6 +52,7 @@ import {
 	current_batch,
 	flushSync,
 	get_cv,
+	active_batch,
 	schedule_effect,
 	set_cv
 } from './reactivity/batch.js';
@@ -188,7 +189,7 @@ export function is_dirty(reaction) {
 			}
 		}
 
-		var wv = batch_wvs?.get(dependency) ?? dependency.wv;
+		var wv = active_batch?.wvs.get(dependency) ?? dependency.wv;
 
 		if (wv > cv) {
 			return true;

From ac3afefcde1d1405706957cdf0090014c3079e3c Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 21:55:50 -0400
Subject: [PATCH 075/122] get rid of batch_wvs

---
 .../src/internal/client/reactivity/batch.js   | 20 ++++++-------------
 .../svelte/src/internal/client/runtime.js     |  1 -
 2 files changed, 6 insertions(+), 15 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 47e55bb2fc..ac9c4fdfc5 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -81,11 +81,6 @@ export let batch_values = null;
  */
 export let batch_cvs = null;
 
-/**
- * @type {Map<Value, number> | null}
- */
-export let batch_wvs = null;
-
 /** @type {Effect | null} */
 let last_scheduled_effect = null;
 
@@ -501,7 +496,7 @@ export class Batch {
 
 	deactivate() {
 		current_batch = null;
-		batch_values = batch_cvs = batch_wvs = null;
+		batch_values = batch_cvs = null;
 	}
 
 	flush() {
@@ -519,7 +514,7 @@ export class Batch {
 
 			current_batch = null;
 			active_batch = null;
-			batch_values = batch_cvs = batch_wvs = null;
+			batch_values = batch_cvs = null;
 
 			old_values.clear();
 
@@ -746,7 +741,7 @@ export class Batch {
 	apply() {
 		if (!async_mode_flag) {
 			// TODO previously we bailed here if there was only one (non-fork) batch... maybe we can reinstate that
-			batch_values = batch_cvs = batch_wvs = null;
+			batch_values = batch_cvs = null;
 			return;
 		}
 
@@ -756,7 +751,6 @@ export class Batch {
 		// we need to override values with the ones in this batch...
 		batch_values = new Map(this.current);
 		batch_cvs = this.cvs;
-		batch_wvs = this.wvs;
 
 		// ...and undo changes belonging to other batches unless they block this one
 		for (const batch of batches) {
@@ -779,7 +773,7 @@ export class Batch {
 				for (const [value, snapshot] of batch.previous) {
 					if (!batch_values.has(value)) {
 						batch_values.set(value, snapshot.v);
-						batch_wvs.set(value, snapshot.wv);
+						this.wvs.set(value, snapshot.wv);
 					}
 				}
 			}
@@ -1121,17 +1115,15 @@ export function eager(fn) {
 			// that will run eagerly whenever the expression changes
 			var previous_batch_values = batch_values;
 			var previous_batch_cvs = batch_cvs;
-			var previous_batch_wvs = batch_wvs;
 			var previous_running_eager_effect = running_eager_effect;
 
 			try {
 				running_eager_effect = true;
-				batch_values = batch_cvs = batch_wvs = null;
+				batch_values = batch_cvs = null;
 				value = fn();
 			} finally {
 				batch_values = previous_batch_values;
 				batch_cvs = previous_batch_cvs;
-				batch_wvs = previous_batch_wvs;
 				running_eager_effect = previous_running_eager_effect;
 			}
 
@@ -1300,7 +1292,7 @@ export function fork(fn) {
  * @param {Value} value
  */
 export function get_wv(value) {
-	return batch_wvs?.get(value) ?? value.wv;
+	return active_batch?.wvs.get(value) ?? value.wv;
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index e278976975..026dfd7c79 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -48,7 +48,6 @@ import {
 import {
 	Batch,
 	batch_values,
-	batch_wvs,
 	current_batch,
 	flushSync,
 	get_cv,

From 8308cb86b615d6f123a6abc74f65318f96e46100 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 22:00:51 -0400
Subject: [PATCH 076/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index ac9c4fdfc5..c087b6212a 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1299,7 +1299,7 @@ export function get_wv(value) {
  * @param {Reaction} reaction
  */
 export function get_cv(reaction) {
-	return batch_cvs?.get(reaction) ?? reaction.cv;
+	return active_batch?.cvs.get(reaction) ?? reaction.cv;
 }
 
 /**

From 05688df7197fc04ffa938f5ef8bf6f259bca3c63 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 22:06:28 -0400
Subject: [PATCH 077/122] get rid of batch_cvs

---
 .../src/internal/client/reactivity/batch.js   | 21 +++++++------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index c087b6212a..a9d9bf27cd 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -76,11 +76,6 @@ export let previous_batch = null;
  */
 export let batch_values = null;
 
-/**
- * @type {Map<Reaction, number> | null}
- */
-export let batch_cvs = null;
-
 /** @type {Effect | null} */
 let last_scheduled_effect = null;
 
@@ -496,7 +491,7 @@ export class Batch {
 
 	deactivate() {
 		current_batch = null;
-		batch_values = batch_cvs = null;
+		batch_values = null;
 	}
 
 	flush() {
@@ -514,7 +509,7 @@ export class Batch {
 
 			current_batch = null;
 			active_batch = null;
-			batch_values = batch_cvs = null;
+			batch_values = null;
 
 			old_values.clear();
 
@@ -741,7 +736,7 @@ export class Batch {
 	apply() {
 		if (!async_mode_flag) {
 			// TODO previously we bailed here if there was only one (non-fork) batch... maybe we can reinstate that
-			batch_values = batch_cvs = null;
+			batch_values = null;
 			return;
 		}
 
@@ -750,7 +745,6 @@ export class Batch {
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
 		batch_values = new Map(this.current);
-		batch_cvs = this.cvs;
 
 		// ...and undo changes belonging to other batches unless they block this one
 		for (const batch of batches) {
@@ -1114,16 +1108,16 @@ export function eager(fn) {
 			// the first time this runs, we create an eager effect
 			// that will run eagerly whenever the expression changes
 			var previous_batch_values = batch_values;
-			var previous_batch_cvs = batch_cvs;
+			var previous_batch = active_batch;
 			var previous_running_eager_effect = running_eager_effect;
 
 			try {
 				running_eager_effect = true;
-				batch_values = batch_cvs = null;
+				batch_values = active_batch = null;
 				value = fn();
 			} finally {
 				batch_values = previous_batch_values;
-				batch_cvs = previous_batch_cvs;
+				active_batch = previous_batch;
 				running_eager_effect = previous_running_eager_effect;
 			}
 
@@ -1306,8 +1300,9 @@ export function get_cv(reaction) {
  * @param {Reaction} reaction
  */
 export function set_cv(reaction, cv = write_version) {
+	// TODO seems weird to have both of these
 	current_batch?.cvs.set(reaction, cv);
-	batch_cvs?.set(reaction, cv);
+	active_batch?.cvs.set(reaction, cv);
 
 	if (!current_batch?.is_fork && !running_eager_effect) {
 		reaction.cv = cv;

From e95b77cf81264f5506c974b4119d4996bec0850c Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 22:32:44 -0400
Subject: [PATCH 078/122] WIP

---
 .../svelte/src/internal/client/reactivity/batch.js    | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index a9d9bf27cd..87a8057e65 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -122,6 +122,12 @@ export class Batch {
 	 */
 	previous = new Map();
 
+	/**
+	 * The combination of this batch's `current` and other batches' `previous` values
+	 * @type {Map<Value, any> | null}
+	 */
+	values = null;
+
 	/**
 	 * When the batch is committed (and the DOM is updated), we need to remove old branches
 	 * and append new ones by calling the functions added inside (if/each/key/etc) blocks
@@ -491,6 +497,7 @@ export class Batch {
 
 	deactivate() {
 		current_batch = null;
+		active_batch = null;
 		batch_values = null;
 	}
 
@@ -736,7 +743,6 @@ export class Batch {
 	apply() {
 		if (!async_mode_flag) {
 			// TODO previously we bailed here if there was only one (non-fork) batch... maybe we can reinstate that
-			batch_values = null;
 			return;
 		}
 
@@ -744,7 +750,8 @@ export class Batch {
 
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
-		batch_values = new Map(this.current);
+		this.values = new Map(this.current);
+		batch_values = this.values;
 
 		// ...and undo changes belonging to other batches unless they block this one
 		for (const batch of batches) {

From 9702a307e11f531aac5686ec3dc20694587ee0f9 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 22:42:26 -0400
Subject: [PATCH 079/122] WIP

---
 packages/svelte/src/internal/client/reactivity/sources.js | 6 +++---
 packages/svelte/src/internal/client/runtime.js            | 5 ++---
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 95a1b3bc24..0d5e1e5ede 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -36,12 +36,12 @@ import { get_error } from '../../shared/dev.js';
 import { component_context, is_runes } from '../context.js';
 import {
 	Batch,
-	batch_values,
 	eager_block_effects,
 	schedule_effect,
 	legacy_updates,
 	set_cv,
-	get_cv
+	get_cv,
+	active_batch
 } from './batch.js';
 import { proxy } from '../proxy.js';
 import { execute_derived } from './deriveds.js';
@@ -336,7 +336,7 @@ export function mark_reactions(signal, wv, updated_during_traversal) {
 		if ((flags & DERIVED) !== 0) {
 			var derived = /** @type {Derived} */ (reaction);
 
-			batch_values?.delete(derived);
+			active_batch?.values?.delete(derived);
 
 			if (wv > get_cv(derived)) {
 				if ((flags & WAS_MARKED) === 0) {
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 026dfd7c79..c2c8fe9470 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -47,7 +47,6 @@ import {
 } from './context.js';
 import {
 	Batch,
-	batch_values,
 	current_batch,
 	flushSync,
 	get_cv,
@@ -678,8 +677,8 @@ export function get(signal) {
 		}
 	}
 
-	if (batch_values?.has(signal)) {
-		return batch_values.get(signal);
+	if (active_batch?.values?.has(signal)) {
+		return active_batch.values.get(signal);
 	}
 
 	if ((signal.f & ERROR_VALUE) !== 0) {

From 92642f0150557f43552a23cdcf0bfd38313bb68a Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 22:44:33 -0400
Subject: [PATCH 080/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 87a8057e65..37ccb077cf 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -74,7 +74,7 @@ export let previous_batch = null;
  * signals in favour of their values within the batch
  * @type {Map<Value, any> | null}
  */
-export let batch_values = null;
+let batch_values = null;
 
 /** @type {Effect | null} */
 let last_scheduled_effect = null;
@@ -123,7 +123,10 @@ export class Batch {
 	previous = new Map();
 
 	/**
-	 * The combination of this batch's `current` and other batches' `previous` values
+	 * The combination of this batch's `current` and other batches' `previous` values,
+	 * When time travelling (i.e. working in one batch, while other batches
+	 * still have ongoing work), we ignore the real values of affected
+	 * signals in favour of their values within the batch
 	 * @type {Map<Value, any> | null}
 	 */
 	values = null;

From 314ad262dfa14a8108ab137ba8064948cf8ddbe6 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 22:47:43 -0400
Subject: [PATCH 081/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 37ccb077cf..51c01d9f1b 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -775,8 +775,8 @@ export class Batch {
 				this.#blockers.add(batch);
 			} else {
 				for (const [value, snapshot] of batch.previous) {
-					if (!batch_values.has(value)) {
-						batch_values.set(value, snapshot.v);
+					if (!this.values.has(value)) {
+						this.values.set(value, snapshot.v);
 						this.wvs.set(value, snapshot.wv);
 					}
 				}

From 84a8996ee0b11b35adfb3aff718a098c63731aeb Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 23:05:46 -0400
Subject: [PATCH 082/122] WIP

---
 packages/svelte/src/internal/client/reactivity/batch.js    | 1 +
 packages/svelte/src/internal/client/reactivity/equality.js | 5 ++---
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 51c01d9f1b..f5d566a551 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -362,6 +362,7 @@ export class Batch {
 		}
 
 		active_batch = null;
+		batch_values = null;
 
 		if (next_batch !== null) {
 			batches.add(next_batch);
diff --git a/packages/svelte/src/internal/client/reactivity/equality.js b/packages/svelte/src/internal/client/reactivity/equality.js
index a035f80af0..dbff1686d7 100644
--- a/packages/svelte/src/internal/client/reactivity/equality.js
+++ b/packages/svelte/src/internal/client/reactivity/equality.js
@@ -1,10 +1,9 @@
 /** @import { Equals } from '#client' */
-
-import { batch_values } from './batch.js';
+import { active_batch } from './batch.js';
 
 /** @type {Equals} */
 export function equals(value) {
-	return value === (batch_values?.get(this) ?? this.v);
+	return value === (active_batch?.values?.get(this) ?? this.v);
 }
 
 /**

From bc32eb369de13ee506160e68195050bacd5e1b00 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 23:16:59 -0400
Subject: [PATCH 083/122] no more batch_values

---
 .../src/internal/client/reactivity/batch.js   | 24 ++++---------------
 1 file changed, 5 insertions(+), 19 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index f5d566a551..0eee9701ae 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -68,14 +68,6 @@ export let active_batch = null;
  */
 export let previous_batch = null;
 
-/**
- * When time travelling (i.e. working in one batch, while other batches
- * still have ongoing work), we ignore the real values of affected
- * signals in favour of their values within the batch
- * @type {Map<Value, any> | null}
- */
-let batch_values = null;
-
 /** @type {Effect | null} */
 let last_scheduled_effect = null;
 
@@ -362,7 +354,6 @@ export class Batch {
 		}
 
 		active_batch = null;
-		batch_values = null;
 
 		if (next_batch !== null) {
 			batches.add(next_batch);
@@ -452,10 +443,10 @@ export class Batch {
 			this.previous.set(source, { v: source.v, wv: source.wv });
 		}
 
-		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
+		// Don't save errors or they won't be thrown in `runtime.js#get`
 		if ((source.f & ERROR_VALUE) === 0) {
 			this.current.set(source, value);
-			batch_values?.set(source, value);
+			active_batch?.values?.set(source, value);
 		}
 
 		var version = increment_write_version();
@@ -479,14 +470,14 @@ export class Batch {
 			this.previous.set(derived, { v: derived.v, wv: derived.wv });
 		}
 
-		// Don't save errors in `batch_values`, or they won't be thrown in `runtime.js#get`
+		// Don't save errors or they won't be thrown in `runtime.js#get`
 		if ((derived.f & ERROR_VALUE) === 0) {
 			// TODO not totally sure about the CONNECTED condition, seems like it should be irrelevant
 			if ((derived.f & CONNECTED) !== 0) {
 				this.current.set(derived, value);
 			}
 
-			batch_values?.set(derived, value);
+			active_batch?.values?.set(derived, value);
 		}
 
 		if (!this.is_fork || derived.deps === null) {
@@ -502,7 +493,6 @@ export class Batch {
 	deactivate() {
 		current_batch = null;
 		active_batch = null;
-		batch_values = null;
 	}
 
 	flush() {
@@ -520,7 +510,6 @@ export class Batch {
 
 			current_batch = null;
 			active_batch = null;
-			batch_values = null;
 
 			old_values.clear();
 
@@ -755,7 +744,6 @@ export class Batch {
 		// if there are multiple batches, we are 'time travelling' —
 		// we need to override values with the ones in this batch...
 		this.values = new Map(this.current);
-		batch_values = this.values;
 
 		// ...and undo changes belonging to other batches unless they block this one
 		for (const batch of batches) {
@@ -1118,16 +1106,14 @@ export function eager(fn) {
 		if (initial) {
 			// the first time this runs, we create an eager effect
 			// that will run eagerly whenever the expression changes
-			var previous_batch_values = batch_values;
 			var previous_batch = active_batch;
 			var previous_running_eager_effect = running_eager_effect;
 
 			try {
 				running_eager_effect = true;
-				batch_values = active_batch = null;
+				active_batch = null;
 				value = fn();
 			} finally {
-				batch_values = previous_batch_values;
 				active_batch = previous_batch;
 				running_eager_effect = previous_running_eager_effect;
 			}

From 18da3a361fb1ed0ac90ebca429e47204abc670de Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 2 Apr 2026 23:18:12 -0400
Subject: [PATCH 084/122] prevent double apply

---
 packages/svelte/src/internal/client/reactivity/batch.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 0eee9701ae..b9d9b316dc 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -739,6 +739,7 @@ export class Batch {
 			return;
 		}
 
+		if (active_batch === this) return;
 		active_batch = this;
 
 		// if there are multiple batches, we are 'time travelling' —

From 6bec42033cc280465cf516fdeaeafce96e92a7ca Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 00:02:15 -0400
Subject: [PATCH 085/122] tweak

---
 packages/svelte/src/internal/client/reactivity/batch.js    | 2 ++
 packages/svelte/src/internal/client/reactivity/deriveds.js | 1 -
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index b9d9b316dc..e3b10fd561 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -480,6 +480,8 @@ export class Batch {
 			active_batch?.values?.set(derived, value);
 		}
 
+		this.wvs.set(derived, write_version);
+
 		if (!this.is_fork || derived.deps === null) {
 			derived.v = value;
 			derived.wv = write_version;
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index dc88ef70eb..fa9c37d832 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -395,7 +395,6 @@ export function update_derived(derived) {
 	if (!derived.equals(value)) {
 		if (active_batch !== null) {
 			active_batch.capture_derived(derived, value);
-			active_batch.wvs.set(derived, write_version);
 		} else {
 			derived.v = value;
 			derived.wv = write_version;

From cf730f63f83a1102668a9fd9ecfbc2d2b1bece0a Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 00:07:54 -0400
Subject: [PATCH 086/122] tweak

---
 packages/svelte/src/internal/client/runtime.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index c2c8fe9470..96f32b8ae8 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -52,7 +52,8 @@ import {
 	get_cv,
 	active_batch,
 	schedule_effect,
-	set_cv
+	set_cv,
+	get_wv
 } from './reactivity/batch.js';
 import { handle_error } from './error-handling.js';
 import { UNINITIALIZED } from '../../constants.js';
@@ -187,9 +188,7 @@ export function is_dirty(reaction) {
 			}
 		}
 
-		var wv = active_batch?.wvs.get(dependency) ?? dependency.wv;
-
-		if (wv > cv) {
+		if (get_wv(dependency) > cv) {
 			return true;
 		}
 	}

From 3ede5c475c771cbf211dec48f0c972a7f64e5b53 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 00:23:46 -0400
Subject: [PATCH 087/122] tweak

---
 .../src/internal/client/reactivity/batch.js   | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index e3b10fd561..f7745b2af8 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -436,36 +436,36 @@ export class Batch {
 	 * Associate a change to a given source with the current
 	 * batch, noting its previous and current values
 	 * @param {Value} source
-	 * @param {any} value
+	 * @param {any} v
 	 */
-	capture(source, value) {
+	capture(source, v) {
 		if (source.v !== UNINITIALIZED && !this.previous.has(source)) {
 			this.previous.set(source, { v: source.v, wv: source.wv });
 		}
 
 		// Don't save errors or they won't be thrown in `runtime.js#get`
 		if ((source.f & ERROR_VALUE) === 0) {
-			this.current.set(source, value);
-			active_batch?.values?.set(source, value);
+			this.current.set(source, v);
+			active_batch?.values?.set(source, v);
 		}
 
-		var version = increment_write_version();
+		var wv = increment_write_version();
 
 		this.wvs.delete(source); // order must be preserved
-		this.wvs.set(source, version);
+		this.wvs.set(source, wv);
 
 		if (!this.is_fork) {
-			source.v = value;
-			source.wv = version;
+			source.v = v;
+			source.wv = wv;
 		}
 	}
 
 	/**
 	 * @param {Derived} derived
-	 * @param {any} value
+	 * @param {any} v
 	 * @deprecated
 	 */
-	capture_derived(derived, value) {
+	capture_derived(derived, v) {
 		if (derived.v !== UNINITIALIZED && !this.previous.has(derived)) {
 			this.previous.set(derived, { v: derived.v, wv: derived.wv });
 		}
@@ -474,16 +474,16 @@ export class Batch {
 		if ((derived.f & ERROR_VALUE) === 0) {
 			// TODO not totally sure about the CONNECTED condition, seems like it should be irrelevant
 			if ((derived.f & CONNECTED) !== 0) {
-				this.current.set(derived, value);
+				this.current.set(derived, v);
 			}
 
-			active_batch?.values?.set(derived, value);
+			active_batch?.values?.set(derived, v);
 		}
 
 		this.wvs.set(derived, write_version);
 
 		if (!this.is_fork || derived.deps === null) {
-			derived.v = value;
+			derived.v = v;
 			derived.wv = write_version;
 		}
 	}

From 0a0352d2894c01008a26193a30f78100ae5c0beb Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 00:35:19 -0400
Subject: [PATCH 088/122] tweak

---
 .../src/internal/client/reactivity/batch.js   | 20 ++++++++-----------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index f7745b2af8..e01f350c4e 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -443,17 +443,17 @@ export class Batch {
 			this.previous.set(source, { v: source.v, wv: source.wv });
 		}
 
+		var wv = increment_write_version();
+
 		// Don't save errors or they won't be thrown in `runtime.js#get`
 		if ((source.f & ERROR_VALUE) === 0) {
 			this.current.set(source, v);
+			this.wvs.delete(source); // order must be preserved
+			this.wvs.set(source, wv);
+
 			active_batch?.values?.set(source, v);
 		}
 
-		var wv = increment_write_version();
-
-		this.wvs.delete(source); // order must be preserved
-		this.wvs.set(source, wv);
-
 		if (!this.is_fork) {
 			source.v = v;
 			source.wv = wv;
@@ -472,16 +472,12 @@ export class Batch {
 
 		// Don't save errors or they won't be thrown in `runtime.js#get`
 		if ((derived.f & ERROR_VALUE) === 0) {
-			// TODO not totally sure about the CONNECTED condition, seems like it should be irrelevant
-			if ((derived.f & CONNECTED) !== 0) {
-				this.current.set(derived, v);
-			}
+			this.current.set(derived, v);
+			this.wvs.set(derived, write_version);
 
 			active_batch?.values?.set(derived, v);
 		}
 
-		this.wvs.set(derived, write_version);
-
 		if (!this.is_fork || derived.deps === null) {
 			derived.v = v;
 			derived.wv = write_version;
@@ -599,7 +595,7 @@ export class Batch {
 				checked = new Map();
 				var current_unequal = [
 					...[...batch.current.keys()].filter((c) =>
-						this.current.has(c) ? /** @type {any} */ (this.current.get(c)) !== c : true
+						this.current.has(c) ? /** @type {any} */ (this.current.get(c)) !== c.v : true
 					)
 				];
 

From 253a20efdd03e1b54d6091b86650f161e9a1d178 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 00:51:59 -0400
Subject: [PATCH 089/122] get rid of batch.wvs

---
 .../src/internal/client/reactivity/batch.js   | 52 +++++++++----------
 .../internal/client/reactivity/equality.js    |  3 +-
 .../svelte/src/internal/client/runtime.js     |  5 +-
 3 files changed, 31 insertions(+), 29 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index e01f350c4e..d839dab59e 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -103,7 +103,7 @@ export class Batch {
 	 * The current values of any signals that are updated in this batch.
 	 * Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
 	 * They keys of this map are identical to `this.#previous`
-	 * @type {Map<Value, any>}
+	 * @type {Map<Value, ValueSnapshot>}
 	 */
 	current = new Map();
 
@@ -119,7 +119,7 @@ export class Batch {
 	 * When time travelling (i.e. working in one batch, while other batches
 	 * still have ongoing work), we ignore the real values of affected
 	 * signals in favour of their values within the batch
-	 * @type {Map<Value, any> | null}
+	 * @type {Map<Value, ValueSnapshot> | null}
 	 */
 	values = null;
 
@@ -173,9 +173,6 @@ export class Batch {
 	 */
 	#dirty_effects = new Set();
 
-	/** @type {Map<Value, number>} */
-	wvs = new Map();
-
 	/** @type {Map<Reaction, number>} */
 	cvs = new Map();
 
@@ -264,8 +261,8 @@ export class Batch {
 		}
 
 		// TODO we only need to do this for re-runs
-		for (const [source, wv] of this.wvs) {
-			mark_reactions(source, wv, null);
+		for (const [source, snapshot] of this.current) {
+			mark_reactions(source, snapshot.wv, null);
 		}
 
 		// we only reschedule previously-deferred effects if we expect
@@ -447,11 +444,12 @@ export class Batch {
 
 		// Don't save errors or they won't be thrown in `runtime.js#get`
 		if ((source.f & ERROR_VALUE) === 0) {
-			this.current.set(source, v);
-			this.wvs.delete(source); // order must be preserved
-			this.wvs.set(source, wv);
+			var snapshot = { v, wv };
 
-			active_batch?.values?.set(source, v);
+			this.current.delete(source); // order must be preserved
+
+			this.current.set(source, snapshot);
+			active_batch?.values?.set(source, snapshot);
 		}
 
 		if (!this.is_fork) {
@@ -472,10 +470,12 @@ export class Batch {
 
 		// Don't save errors or they won't be thrown in `runtime.js#get`
 		if ((derived.f & ERROR_VALUE) === 0) {
-			this.current.set(derived, v);
-			this.wvs.set(derived, write_version);
+			var snapshot = { v, wv: write_version };
+
+			this.current.delete(derived); // order must be preserved
 
-			active_batch?.values?.set(derived, v);
+			this.current.set(derived, snapshot);
+			active_batch?.values?.set(derived, snapshot);
 		}
 
 		if (!this.is_fork || derived.deps === null) {
@@ -550,13 +550,13 @@ export class Batch {
 			/** @type {Source[]} */
 			var sources = [];
 
-			for (const [source, value] of this.current) {
-				if (batch.current.has(source)) {
-					var batch_value = batch.current.get(source);
+			for (const [source, snapshot] of this.current) {
+				var batch_snapshot = batch.current.get(source);
 
-					if (is_earlier && value !== batch_value) {
+				if (batch_snapshot) {
+					if (is_earlier && snapshot.v !== batch_snapshot.v) {
 						// bring the value up to date
-						batch.current.set(source, value);
+						batch.current.set(source, snapshot.v);
 					} else {
 						// same value or later batch has more recent value,
 						// no need to re-run these effects
@@ -595,7 +595,7 @@ export class Batch {
 				checked = new Map();
 				var current_unequal = [
 					...[...batch.current.keys()].filter((c) =>
-						this.current.has(c) ? /** @type {any} */ (this.current.get(c)) !== c.v : true
+						this.current.has(c) ? /** @type {any} */ (this.current.get(c)).v !== c.v : true
 					)
 				];
 
@@ -764,8 +764,7 @@ export class Batch {
 			} else {
 				for (const [value, snapshot] of batch.previous) {
 					if (!this.values.has(value)) {
-						this.values.set(value, snapshot.v);
-						this.wvs.set(value, snapshot.wv);
+						this.values.set(value, snapshot);
 					}
 				}
 			}
@@ -1237,9 +1236,9 @@ export function fork(fn) {
 				}
 			}
 
-			for (var [value, wv] of batch.wvs) {
-				value.v = batch.current.get(value);
-				value.wv = wv;
+			for (var [value, snapshot] of batch.current) {
+				value.v = snapshot.v;
+				value.wv = snapshot.wv;
 			}
 
 			// trigger any `$state.eager(...)` expressions with the new state.
@@ -1282,7 +1281,8 @@ export function fork(fn) {
  * @param {Value} value
  */
 export function get_wv(value) {
-	return active_batch?.wvs.get(value) ?? value.wv;
+	var snapshot = active_batch?.values?.get(value);
+	return snapshot ? snapshot.wv : value.wv;
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/reactivity/equality.js b/packages/svelte/src/internal/client/reactivity/equality.js
index dbff1686d7..9f13bdc8c6 100644
--- a/packages/svelte/src/internal/client/reactivity/equality.js
+++ b/packages/svelte/src/internal/client/reactivity/equality.js
@@ -3,7 +3,8 @@ import { active_batch } from './batch.js';
 
 /** @type {Equals} */
 export function equals(value) {
-	return value === (active_batch?.values?.get(this) ?? this.v);
+	var snapshot = active_batch?.values?.get(this);
+	return value === (snapshot ? snapshot.v : this.v);
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 96f32b8ae8..14a96e03a1 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -676,8 +676,9 @@ export function get(signal) {
 		}
 	}
 
-	if (active_batch?.values?.has(signal)) {
-		return active_batch.values.get(signal);
+	var snapshot = active_batch?.values?.get(signal);
+	if (snapshot) {
+		return snapshot.v;
 	}
 
 	if ((signal.f & ERROR_VALUE) !== 0) {

From 679690b71238a3b32ad1bc57e7d555c16374284f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 00:58:05 -0400
Subject: [PATCH 090/122] DRY

---
 .../src/internal/client/reactivity/batch.js   | 49 +++++--------------
 .../internal/client/reactivity/deriveds.js    |  2 +-
 .../src/internal/client/reactivity/sources.js |  5 +-
 3 files changed, 15 insertions(+), 41 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index d839dab59e..8e8c1d0606 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -432,55 +432,28 @@ export class Batch {
 	/**
 	 * Associate a change to a given source with the current
 	 * batch, noting its previous and current values
-	 * @param {Value} source
+	 * @param {Value} value
 	 * @param {any} v
+	 * @param {number} wv
 	 */
-	capture(source, v) {
-		if (source.v !== UNINITIALIZED && !this.previous.has(source)) {
-			this.previous.set(source, { v: source.v, wv: source.wv });
+	capture(value, v, wv) {
+		if (value.v !== UNINITIALIZED && !this.previous.has(value)) {
+			this.previous.set(value, { v: value.v, wv: value.wv });
 		}
 
-		var wv = increment_write_version();
-
 		// Don't save errors or they won't be thrown in `runtime.js#get`
-		if ((source.f & ERROR_VALUE) === 0) {
+		if ((value.f & ERROR_VALUE) === 0) {
 			var snapshot = { v, wv };
 
-			this.current.delete(source); // order must be preserved
+			this.current.delete(value); // order must be preserved
 
-			this.current.set(source, snapshot);
-			active_batch?.values?.set(source, snapshot);
+			this.current.set(value, snapshot);
+			active_batch?.values?.set(value, snapshot);
 		}
 
 		if (!this.is_fork) {
-			source.v = v;
-			source.wv = wv;
-		}
-	}
-
-	/**
-	 * @param {Derived} derived
-	 * @param {any} v
-	 * @deprecated
-	 */
-	capture_derived(derived, v) {
-		if (derived.v !== UNINITIALIZED && !this.previous.has(derived)) {
-			this.previous.set(derived, { v: derived.v, wv: derived.wv });
-		}
-
-		// Don't save errors or they won't be thrown in `runtime.js#get`
-		if ((derived.f & ERROR_VALUE) === 0) {
-			var snapshot = { v, wv: write_version };
-
-			this.current.delete(derived); // order must be preserved
-
-			this.current.set(derived, snapshot);
-			active_batch?.values?.set(derived, snapshot);
-		}
-
-		if (!this.is_fork || derived.deps === null) {
-			derived.v = v;
-			derived.wv = write_version;
+			value.v = v;
+			value.wv = wv;
 		}
 	}
 
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index fa9c37d832..f0087422fc 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -394,7 +394,7 @@ export function update_derived(derived) {
 
 	if (!derived.equals(value)) {
 		if (active_batch !== null) {
-			active_batch.capture_derived(derived, value);
+			active_batch.capture(derived, value, write_version);
 		} else {
 			derived.v = value;
 			derived.wv = write_version;
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 0d5e1e5ede..f81393baa5 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -13,7 +13,8 @@ import {
 	untracking,
 	is_destroying_effect,
 	push_reaction_value,
-	write_version
+	write_version,
+	increment_write_version
 } from '../runtime.js';
 import { equals, safe_equals } from './equality.js';
 import {
@@ -196,7 +197,7 @@ export function internal_set(source, value, updated_during_traversal = null) {
 			set_cv(derived);
 		}
 
-		batch.capture(source, value);
+		batch.capture(source, value, increment_write_version());
 
 		if (DEV) {
 			if (tracing_mode_flag || active_effect !== null) {

From e39f561ac9433b69a1387e4889b0531ca989546f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 00:58:28 -0400
Subject: [PATCH 091/122] unused

---
 packages/svelte/src/internal/client/reactivity/batch.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 8e8c1d0606..b54334ddf1 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -15,7 +15,6 @@ import {
 	ERROR_VALUE,
 	MANAGED_EFFECT,
 	REACTION_RAN,
-	CONNECTED,
 	STATE_EAGER_EFFECT
 } from '#client/constants';
 import { async_mode_flag } from '../../flags/index.js';

From 9e09508df4d3d7d9d2ef82862533948dbc1a938d Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 10:29:02 -0400
Subject: [PATCH 092/122] WIP

---
 .../svelte/src/internal/client/reactivity/deriveds.js |  8 +++++++-
 .../svelte/src/internal/client/reactivity/sources.js  |  5 +++--
 packages/svelte/src/internal/client/runtime.js        | 11 ++++++++++-
 3 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index f0087422fc..25a95b8060 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -10,7 +10,9 @@ import {
 	ASYNC,
 	WAS_MARKED,
 	DESTROYED,
-	REACTION_RAN
+	REACTION_RAN,
+	CONNECTED,
+	CLEAN
 } from '#client/constants';
 import {
 	active_reaction,
@@ -400,6 +402,10 @@ export function update_derived(derived) {
 			derived.wv = write_version;
 		}
 	}
+
+	if (active_batch === null && (derived.f & CONNECTED) !== 0) {
+		derived.f |= CLEAN;
+	}
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index f81393baa5..7e2a4e49b7 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -337,9 +337,10 @@ export function mark_reactions(signal, wv, updated_during_traversal) {
 		if ((flags & DERIVED) !== 0) {
 			var derived = /** @type {Derived} */ (reaction);
 
-			active_batch?.values?.delete(derived);
-
 			if (wv > get_cv(derived)) {
+				active_batch?.values?.delete(derived);
+				derived.f &= ~CLEAN;
+
 				if ((flags & WAS_MARKED) === 0) {
 					// Only connected deriveds can be reliably unmarked right away
 					if (flags & CONNECTED) {
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 14a96e03a1..54dd9315ae 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -21,7 +21,8 @@ import {
 	WAS_MARKED,
 	MANAGED_EFFECT,
 	REACTION_RAN,
-	EFFECT_LEGACY
+	EFFECT_LEGACY,
+	CLEAN
 } from './constants.js';
 import { old_values } from './reactivity/sources.js';
 import {
@@ -167,6 +168,14 @@ export function is_dirty(reaction) {
 
 	if (flags & DERIVED) {
 		reaction.f &= ~WAS_MARKED;
+
+		if ((flags & CONNECTED) !== 0) {
+			if (active_batch !== null) {
+				if (active_batch.values?.has(reaction)) return false;
+			} else {
+				if ((reaction.f & CLEAN) !== 0) return false;
+			}
+		}
 	}
 
 	var dependencies = /** @type {Value[]} */ (reaction.deps);

From e4219d5452c18780d7049948b7c660115342c7f1 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 10:41:19 -0400
Subject: [PATCH 093/122] WIP

---
 .../svelte/src/internal/client/reactivity/batch.js     | 10 ++++++----
 .../svelte/src/internal/client/reactivity/types.d.ts   |  2 +-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index b54334ddf1..7a8d4e82d0 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -102,14 +102,14 @@ export class Batch {
 	 * The current values of any signals that are updated in this batch.
 	 * Tuple format: [value, is_derived] (note: is_derived is false for deriveds, too, if they were overridden via assignment)
 	 * They keys of this map are identical to `this.#previous`
-	 * @type {Map<Value, ValueSnapshot>}
+	 * @type {Map<Value, ValueSnapshot<unknown>>}
 	 */
 	current = new Map();
 
 	/**
 	 * The values of any signals (sources and deriveds) that are updated in this batch _before_ those updates took place.
 	 * They keys of this map are identical to `this.#current`
-	 * @type {Map<Value, ValueSnapshot>}
+	 * @type {Map<Value, ValueSnapshot<unknown>>}
 	 */
 	previous = new Map();
 
@@ -118,7 +118,7 @@ export class Batch {
 	 * When time travelling (i.e. working in one batch, while other batches
 	 * still have ongoing work), we ignore the real values of affected
 	 * signals in favour of their values within the batch
-	 * @type {Map<Value, ValueSnapshot> | null}
+	 * @type {Map<Value, ValueSnapshot<unknown>> | null}
 	 */
 	values = null;
 
@@ -528,7 +528,7 @@ export class Batch {
 				if (batch_snapshot) {
 					if (is_earlier && snapshot.v !== batch_snapshot.v) {
 						// bring the value up to date
-						batch.current.set(source, snapshot.v);
+						batch.current.set(source, snapshot);
 					} else {
 						// same value or later batch has more recent value,
 						// no need to re-run these effects
@@ -973,6 +973,8 @@ function mark_effects(batch, value, sources, marked, checked) {
 			const flags = reaction.f;
 
 			if ((flags & DERIVED) !== 0) {
+				batch.current.delete(reaction);
+
 				mark_effects(batch, /** @type {Derived} */ (reaction), sources, marked, checked);
 			} else if ((flags & (ASYNC | BLOCK_EFFECT)) !== 0 && depends_on(reaction, sources, checked)) {
 				batch.schedule(/** @type {Effect} */ (reaction));
diff --git a/packages/svelte/src/internal/client/reactivity/types.d.ts b/packages/svelte/src/internal/client/reactivity/types.d.ts
index 5cde587830..bd1d5cfddd 100644
--- a/packages/svelte/src/internal/client/reactivity/types.d.ts
+++ b/packages/svelte/src/internal/client/reactivity/types.d.ts
@@ -110,7 +110,7 @@ export interface Blocker {
 	settled: boolean;
 }
 
-export interface ValueSnapshot<T = any> {
+export interface ValueSnapshot<T = unknown> {
 	v: T;
 	wv: number;
 }

From 3dd1d6715577c5e635cf13334ef02bd3dd24145b Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 11:31:51 -0400
Subject: [PATCH 094/122] print cv/wv when logging tree

---
 packages/svelte/src/internal/client/dev/debug.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/dev/debug.js b/packages/svelte/src/internal/client/dev/debug.js
index 56dcbf497b..bda682c393 100644
--- a/packages/svelte/src/internal/client/dev/debug.js
+++ b/packages/svelte/src/internal/client/dev/debug.js
@@ -17,6 +17,7 @@ import {
 	MANAGED_EFFECT
 } from '#client/constants';
 import { snapshot } from '../../shared/clone.js';
+import { get_cv, get_wv } from '../reactivity/batch.js';
 import { is_dirty, untrack } from '../runtime.js';
 
 /**
@@ -101,7 +102,7 @@ export function log_effect_tree(effect, highlighted = [], depth = 0, is_reachabl
 	}
 
 	// eslint-disable-next-line no-console
-	console.group(`%c${label} (${status})`, styles.join('; '));
+	console.group(`%c${label} (${status}) cv=${get_cv(effect)}`, styles.join('; '));
 
 	if (depth === 0) {
 		const callsite = new Error().stack
@@ -163,7 +164,7 @@ function log_dep(dep) {
 
 		// eslint-disable-next-line no-console
 		console.groupCollapsed(
-			`%c$derived %c${dep.label ?? '<unknown>'}`,
+			`%c$derived %c${dep.label ?? '<unknown>'} wv=${get_wv(derived)} cv=${get_cv(derived)}`,
 			'font-weight: bold; color: CornflowerBlue',
 			'font-weight: normal',
 			untrack(() => snapshot(derived.v))
@@ -180,7 +181,7 @@ function log_dep(dep) {
 	} else {
 		// eslint-disable-next-line no-console
 		console.log(
-			`%c$state %c${dep.label ?? '<unknown>'}`,
+			`%c$state %c${dep.label ?? '<unknown>'} wv=${get_wv(dep)}`,
 			'font-weight: bold; color: CornflowerBlue',
 			'font-weight: normal',
 			untrack(() => snapshot(dep.v))

From 1747c7b19095e79d445d99964eb7b6e6c2c7c2d5 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 11:32:21 -0400
Subject: [PATCH 095/122] lint

---
 packages/svelte/src/internal/client/reactivity/batch.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 7a8d4e82d0..e36134494c 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -973,7 +973,7 @@ function mark_effects(batch, value, sources, marked, checked) {
 			const flags = reaction.f;
 
 			if ((flags & DERIVED) !== 0) {
-				batch.current.delete(reaction);
+				batch.current.delete(/** @type {Derived} */ (reaction));
 
 				mark_effects(batch, /** @type {Derived} */ (reaction), sources, marked, checked);
 			} else if ((flags & (ASYNC | BLOCK_EFFECT)) !== 0 && depends_on(reaction, sources, checked)) {

From 9b34d8ff76906bbc5be0de3a9c4e66991bfdb896 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 11:32:46 -0400
Subject: [PATCH 096/122] tidy up

---
 packages/svelte/src/internal/client/runtime.js | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 54dd9315ae..8e83c6d37a 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -171,9 +171,13 @@ export function is_dirty(reaction) {
 
 		if ((flags & CONNECTED) !== 0) {
 			if (active_batch !== null) {
-				if (active_batch.values?.has(reaction)) return false;
+				if (active_batch.values?.has(/** @type {Derived} */ (reaction))) {
+					return false;
+				}
 			} else {
-				if ((reaction.f & CLEAN) !== 0) return false;
+				if ((reaction.f & CLEAN) !== 0) {
+					return false;
+				}
 			}
 		}
 	}

From 6914710977d41571f79e4eef7aefdb3ce4e79595 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 11:38:53 -0400
Subject: [PATCH 097/122] WIP

---
 .../src/internal/client/reactivity/sources.js   | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 7e2a4e49b7..013f487963 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -42,7 +42,8 @@ import {
 	legacy_updates,
 	set_cv,
 	get_cv,
-	active_batch
+	active_batch,
+	current_batch
 } from './batch.js';
 import { proxy } from '../proxy.js';
 import { execute_derived } from './deriveds.js';
@@ -334,21 +335,19 @@ export function mark_reactions(signal, wv, updated_during_traversal) {
 			continue;
 		}
 
+		// TODO ideally this would work, but I think we need to `apply()` before `mark_reactions`.
+		// Or pass `batch` in as an argument?
+		// if (wv <= get_cv(reaction)) continue;
+
 		if ((flags & DERIVED) !== 0) {
 			var derived = /** @type {Derived} */ (reaction);
 
 			if (wv > get_cv(derived)) {
+				current_batch?.current?.delete(derived); // TODO would be nice if `batch` was passed in and we weren't doing this
 				active_batch?.values?.delete(derived);
 				derived.f &= ~CLEAN;
 
-				if ((flags & WAS_MARKED) === 0) {
-					// Only connected deriveds can be reliably unmarked right away
-					if (flags & CONNECTED) {
-						reaction.f |= WAS_MARKED;
-					}
-
-					mark_reactions(derived, wv, updated_during_traversal);
-				}
+				mark_reactions(derived, wv, updated_during_traversal);
 			}
 		} else {
 			var effect = /** @type {Effect} */ (reaction);

From 0ac1a34841747a0ede00abe55ad50bb1381ac16e Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 11:43:45 -0400
Subject: [PATCH 098/122] reinstate WAS_MARKED optimization

---
 .../svelte/src/internal/client/reactivity/sources.js     | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 013f487963..b5d32fc31b 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -347,7 +347,14 @@ export function mark_reactions(signal, wv, updated_during_traversal) {
 				active_batch?.values?.delete(derived);
 				derived.f &= ~CLEAN;
 
-				mark_reactions(derived, wv, updated_during_traversal);
+				if ((flags & WAS_MARKED) === 0) {
+					// Only connected deriveds can be reliably unmarked right away
+					if (flags & CONNECTED) {
+						reaction.f |= WAS_MARKED;
+					}
+
+					mark_reactions(derived, wv, updated_during_traversal);
+				}
 			}
 		} else {
 			var effect = /** @type {Effect} */ (reaction);

From fe79b7645be629989d217e729eb79d8586d7311c Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 11:51:52 -0400
Subject: [PATCH 099/122] WIP

---
 .../src/internal/client/reactivity/batch.js      |  2 +-
 .../src/internal/client/reactivity/sources.js    | 16 +++++++++++-----
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index e36134494c..31ce8fe46c 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -261,7 +261,7 @@ export class Batch {
 
 		// TODO we only need to do this for re-runs
 		for (const [source, snapshot] of this.current) {
-			mark_reactions(source, snapshot.wv, null);
+			mark_reactions(this, source, snapshot.wv, null);
 		}
 
 		// we only reschedule previously-deferred effects if we expect
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index b5d32fc31b..a45c8556cd 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -232,7 +232,7 @@ export function internal_set(source, value, updated_during_traversal = null) {
 
 		// For debugging, in case you want to know which reactions are being scheduled:
 		// log_reactions(source);
-		mark_reactions(source, write_version, updated_during_traversal);
+		mark_reactions(batch, source, write_version, updated_during_traversal);
 
 		// It's possible that the current reaction might not have up-to-date dependencies
 		// whilst it's actively running. So in the case of ensuring it registers the reaction
@@ -310,12 +310,14 @@ export function increment(source) {
 }
 
 /**
+ * TODO this should probably be a method on `batch`
+ * @param {Batch} batch
  * @param {Value} signal
  * @param {number} wv
  * @param {Effect[] | null} updated_during_traversal
  * @returns {void}
  */
-export function mark_reactions(signal, wv, updated_during_traversal) {
+export function mark_reactions(batch, signal, wv, updated_during_traversal) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
 
@@ -343,8 +345,12 @@ export function mark_reactions(signal, wv, updated_during_traversal) {
 			var derived = /** @type {Derived} */ (reaction);
 
 			if (wv > get_cv(derived)) {
-				current_batch?.current?.delete(derived); // TODO would be nice if `batch` was passed in and we weren't doing this
+				// If setting state inside an effect, `batch !== active_batch` —
+				// we need to invalidate the current overlay so that subsequent
+				// effects read the correct value
 				active_batch?.values?.delete(derived);
+
+				batch.current.delete(derived);
 				derived.f &= ~CLEAN;
 
 				if ((flags & WAS_MARKED) === 0) {
@@ -353,7 +359,7 @@ export function mark_reactions(signal, wv, updated_during_traversal) {
 						reaction.f |= WAS_MARKED;
 					}
 
-					mark_reactions(derived, wv, updated_during_traversal);
+					mark_reactions(batch, derived, wv, updated_during_traversal);
 				}
 			}
 		} else {
@@ -366,7 +372,7 @@ export function mark_reactions(signal, wv, updated_during_traversal) {
 			if (updated_during_traversal !== null) {
 				updated_during_traversal.push(effect);
 			} else {
-				schedule_effect(effect);
+				batch.schedule(effect);
 			}
 		}
 	}

From e080f399ca0182ef60628f06684df2e246002172 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 13:15:49 -0400
Subject: [PATCH 100/122] break out report generation

---
 benchmarking/compare/generate-report.js | 81 +++++++++++++++++++++++++
 benchmarking/compare/index.js           | 70 +--------------------
 2 files changed, 83 insertions(+), 68 deletions(-)
 create mode 100644 benchmarking/compare/generate-report.js

diff --git a/benchmarking/compare/generate-report.js b/benchmarking/compare/generate-report.js
new file mode 100644
index 0000000000..a61f58909b
--- /dev/null
+++ b/benchmarking/compare/generate-report.js
@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+export function generate_report(outdir) {
+	const result_files = fs
+		.readdirSync(outdir)
+		.filter((file) => file.endsWith('.json'))
+		.sort((a, b) => a.localeCompare(b));
+
+	const branches = result_files.map((file) => file.slice(0, -5));
+	const results = result_files.map((file) =>
+		JSON.parse(fs.readFileSync(`${outdir}/${file}`, 'utf-8'))
+	);
+
+	if (results.length === 0) {
+		console.error(`No result files found in ${outdir}`);
+		process.exit(1);
+	}
+
+	const report_file = path.join(outdir, 'report.txt');
+
+	fs.writeFileSync(report_file, '');
+
+	const write = (str) => {
+		fs.appendFileSync(report_file, str + '\n');
+		console.log(str);
+	};
+
+	for (let i = 0; i < branches.length; i += 1) {
+		write(`${char(i)}: ${branches[i]}`);
+	}
+
+	write('');
+
+	for (let i = 0; i < results[0].length; i += 1) {
+		write(`${results[0][i].benchmark}`);
+
+		for (const metric of ['time', 'gc_time']) {
+			const times = results.map((result) => +result[i][metric]);
+			let min = Infinity;
+			let max = -Infinity;
+			let min_index = -1;
+
+			for (let b = 0; b < times.length; b += 1) {
+				const time = times[b];
+
+				if (time < min) {
+					min = time;
+					min_index = b;
+				}
+
+				if (time > max) {
+					max = time;
+				}
+			}
+
+			if (min !== 0) {
+				write(`  ${metric}: fastest is ${char(min_index)} (${branches[min_index]})`);
+				times.forEach((time, b) => {
+					const SIZE = 20;
+					const n = Math.round(SIZE * (time / max));
+
+					write(`    ${char(b)}: ${'◼'.repeat(n)}${' '.repeat(SIZE - n)} ${time.toFixed(2)}ms`);
+				});
+			}
+		}
+
+		write('');
+	}
+}
+
+function char(i) {
+	return String.fromCharCode(97 + i);
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+	const outdir = path.resolve(process.argv[1], '../.results');
+
+	generate_report(outdir);
+}
diff --git a/benchmarking/compare/index.js b/benchmarking/compare/index.js
index 100d98a767..9064ee7da9 100644
--- a/benchmarking/compare/index.js
+++ b/benchmarking/compare/index.js
@@ -3,6 +3,7 @@ import path from 'node:path';
 import { execSync, fork } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { safe } from '../utils.js';
+import { generate_report } from './generate-report.js';
 
 // if (execSync('git status --porcelain').toString().trim()) {
 // 	console.error('Working directory is not clean');
@@ -12,7 +13,6 @@ import { safe } from '../utils.js';
 const filename = fileURLToPath(import.meta.url);
 const runner = path.resolve(filename, '../runner.js');
 const outdir = path.resolve(filename, '../.results');
-const report_file = `${outdir}/report.txt`;
 
 fs.mkdirSync(outdir, { recursive: true });
 
@@ -85,70 +85,4 @@ if (PROFILE_DIR !== null) {
 	console.log(`\nCPU profiles written to ${PROFILE_DIR}`);
 }
 
-const result_files = fs
-	.readdirSync(outdir)
-	.filter((file) => file.endsWith('.json'))
-	.sort((a, b) => a.localeCompare(b));
-
-const branches = result_files.map((file) => file.slice(0, -5));
-const results = result_files.map((file) =>
-	JSON.parse(fs.readFileSync(`${outdir}/${file}`, 'utf-8'))
-);
-
-if (results.length === 0) {
-	console.error(`No result files found in ${outdir}`);
-	process.exit(1);
-}
-
-fs.writeFileSync(report_file, '');
-
-const write = (str) => {
-	fs.appendFileSync(report_file, str + '\n');
-	console.log(str);
-};
-
-for (let i = 0; i < branches.length; i += 1) {
-	write(`${char(i)}: ${branches[i]}`);
-}
-
-write('');
-
-for (let i = 0; i < results[0].length; i += 1) {
-	write(`${results[0][i].benchmark}`);
-
-	for (const metric of ['time', 'gc_time']) {
-		const times = results.map((result) => +result[i][metric]);
-		let min = Infinity;
-		let max = -Infinity;
-		let min_index = -1;
-
-		for (let b = 0; b < times.length; b += 1) {
-			const time = times[b];
-
-			if (time < min) {
-				min = time;
-				min_index = b;
-			}
-
-			if (time > max) {
-				max = time;
-			}
-		}
-
-		if (min !== 0) {
-			write(`  ${metric}: fastest is ${char(min_index)} (${branches[min_index]})`);
-			times.forEach((time, b) => {
-				const SIZE = 20;
-				const n = Math.round(SIZE * (time / max));
-
-				write(`    ${char(b)}: ${'◼'.repeat(n)}${' '.repeat(SIZE - n)} ${time.toFixed(2)}ms`);
-			});
-		}
-	}
-
-	write('');
-}
-
-function char(i) {
-	return String.fromCharCode(97 + i);
-}
+generate_report(outdir);

From f900fcfb5a1a70f0f73dd2712edd1a477a2ebca7 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 13:21:00 -0400
Subject: [PATCH 101/122] lint

---
 packages/svelte/src/internal/client/runtime.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 8e83c6d37a..b92d9fa580 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -690,9 +690,7 @@ export function get(signal) {
 	}
 
 	var snapshot = active_batch?.values?.get(signal);
-	if (snapshot) {
-		return snapshot.v;
-	}
+	if (snapshot) return /** @type {V} */ (snapshot.v);
 
 	if ((signal.f & ERROR_VALUE) !== 0) {
 		throw signal.v;

From d197e83714b61465b766fadda071e6f7e9b38849 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 14:13:34 -0400
Subject: [PATCH 102/122] fix

---
 .../svelte/src/internal/client/runtime.js     | 27 ++++++++++---------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index b92d9fa580..072c09071f 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -457,6 +457,10 @@ export function update_effect(effect) {
 		set_dev_stack(effect.dev_stack ?? dev_stack);
 	}
 
+	// get this now, so that any writes during execution cause a re-run,
+	// but don't set it yet so that `$inspect.trace` works
+	const cv = write_version;
+
 	try {
 		if ((flags & (BLOCK_EFFECT | MANAGED_EFFECT)) !== 0) {
 			destroy_block_effect_children(effect);
@@ -464,23 +468,11 @@ export function update_effect(effect) {
 			destroy_effect_children(effect);
 		}
 
-		// get this now, so that any writes during execution cause a re-run,
-		// but don't set it yet so that `$inspect.trace` works
-		const cv = write_version;
-
 		execute_effect_teardown(effect);
+
 		var teardown = update_reaction(effect);
 		effect.teardown = typeof teardown === 'function' ? teardown : null;
 
-		if (effect.deps !== null) {
-			if (is_runes() && (effect.f & EFFECT_LEGACY) === 0) {
-				set_cv(effect, cv);
-			} else {
-				// in legacy mode, prevent the effect re-running immediately
-				set_cv(effect);
-			}
-		}
-
 		// In DEV, increment versions of any sources that were written to during the effect,
 		// so that they are correctly marked as dirty when the effect re-runs
 		if (DEV && tracing_mode_flag && effect.deps !== null) {
@@ -492,6 +484,15 @@ export function update_effect(effect) {
 			}
 		}
 	} finally {
+		if (effect.deps !== null) {
+			if (is_runes() && (effect.f & EFFECT_LEGACY) === 0) {
+				set_cv(effect, cv);
+			} else {
+				// in legacy mode, prevent the effect re-running immediately
+				set_cv(effect);
+			}
+		}
+
 		is_updating_effect = was_updating_effect;
 		active_effect = previous_effect;
 

From 1fd260f85a7e6ea55a877a1ed883a144b9d61d7e Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 15:01:16 -0400
Subject: [PATCH 103/122] fix

---
 .../svelte/src/internal/client/reactivity/sources.js  |  5 -----
 .../svelte/src/internal/client/reactivity/types.d.ts  |  5 -----
 packages/svelte/src/internal/client/runtime.js        | 11 -----------
 3 files changed, 21 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index a45c8556cd..f35bf72fc1 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -89,7 +89,6 @@ export function source(v, stack) {
 	if (DEV && tracing_mode_flag) {
 		signal.created = stack ?? get_error('created at');
 		signal.updated = null;
-		signal.set_during_effect = false;
 		signal.trace = null;
 	}
 
@@ -224,10 +223,6 @@ export function internal_set(source, value, updated_during_traversal = null) {
 					}
 				}
 			}
-
-			if (active_effect !== null) {
-				source.set_during_effect = true;
-			}
 		}
 
 		// For debugging, in case you want to know which reactions are being scheduled:
diff --git a/packages/svelte/src/internal/client/reactivity/types.d.ts b/packages/svelte/src/internal/client/reactivity/types.d.ts
index bd1d5cfddd..48e62fb9b1 100644
--- a/packages/svelte/src/internal/client/reactivity/types.d.ts
+++ b/packages/svelte/src/internal/client/reactivity/types.d.ts
@@ -27,11 +27,6 @@ export interface Value<V = unknown> extends Signal {
 	created?: Error | null;
 	/** An map of errors with stack traces showing when the source was updated, keyed by the stack trace */
 	updated?: Map<string, { error: Error; count: number }> | null;
-	/**
-	 * Whether or not the source was set while running an effect — if so, we need to
-	 * increment the write version so that it shows up as dirty when the effect re-runs
-	 */
-	set_during_effect?: boolean;
 	/** A function that retrieves the underlying source, used for each block item signals */
 	trace?: null | (() => void);
 	/** Write version */
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 072c09071f..4107da523b 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -472,17 +472,6 @@ export function update_effect(effect) {
 
 		var teardown = update_reaction(effect);
 		effect.teardown = typeof teardown === 'function' ? teardown : null;
-
-		// In DEV, increment versions of any sources that were written to during the effect,
-		// so that they are correctly marked as dirty when the effect re-runs
-		if (DEV && tracing_mode_flag && effect.deps !== null) {
-			for (var dep of effect.deps) {
-				if (dep.set_during_effect) {
-					dep.wv = increment_write_version();
-					dep.set_during_effect = false;
-				}
-			}
-		}
 	} finally {
 		if (effect.deps !== null) {
 			if (is_runes() && (effect.f & EFFECT_LEGACY) === 0) {

From 3bb8f3d2e52e445f1122185af3d30668d40e3506 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 15:03:43 -0400
Subject: [PATCH 104/122] lint

---
 packages/svelte/src/internal/client/dom/blocks/each.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/dom/blocks/each.js b/packages/svelte/src/internal/client/dom/blocks/each.js
index 3de6296611..60acaf8bc9 100644
--- a/packages/svelte/src/internal/client/dom/blocks/each.js
+++ b/packages/svelte/src/internal/client/dom/blocks/each.js
@@ -203,7 +203,9 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 	var each_array = derived_safe_equal(() => {
 		var collection = get_collection();
 
-		return is_array(collection) ? collection : collection == null ? [] : array_from(collection);
+		return /** @type {V[]} */ (
+			is_array(collection) ? collection : collection == null ? [] : array_from(collection)
+		);
 	});
 
 	if (DEV) {
@@ -260,7 +262,7 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 	}
 
 	var effect = block(() => {
-		array = /** @type {V[]} */ (get(each_array));
+		array = get(each_array);
 		var length = array.length;
 
 		/** `true` if there was a hydration mismatch. Needs to be a `let` or else it isn't treeshaken out */

From 261dc4175ff80835224bdbf46b77cd68ac738a16 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 15:37:21 -0400
Subject: [PATCH 105/122] this change appears to be no longer necessary

---
 packages/svelte/src/internal/client/reactivity/deriveds.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 25a95b8060..7b7f72702c 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -246,9 +246,8 @@ export function async_derived(fn, label, location) {
 	return new Promise((fulfil) => {
 		/** @param {Promise<V>} p */
 		function next(p) {
-			/** @param {unknown} v */
-			function go(v) {
-				if (p === promise || v !== STALE_REACTION) {
+			function go() {
+				if (p === promise) {
 					fulfil(signal);
 				} else {
 					// if the effect re-runs before the initial promise

From 6fb4705e033e0322155c493839da356453db4e14 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 15:45:06 -0400
Subject: [PATCH 106/122] enable async flag

---
 benchmarking/benchmarks/reactivity/index.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/benchmarking/benchmarks/reactivity/index.js b/benchmarking/benchmarks/reactivity/index.js
index 2b75b3dfc6..3fe9639376 100644
--- a/benchmarking/benchmarks/reactivity/index.js
+++ b/benchmarking/benchmarks/reactivity/index.js
@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import 'svelte/internal/flags/async';
 import {
 	sbench_create_0to1,
 	sbench_create_1000to1,

From 03b1f22963b3bdb902a7e9fe0e926810cf11d1e9 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 3 Apr 2026 16:04:05 -0400
Subject: [PATCH 107/122] add a benchmark

---
 .../reactivity/tests/clean_effects.bench.js   | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 benchmarking/benchmarks/reactivity/tests/clean_effects.bench.js

diff --git a/benchmarking/benchmarks/reactivity/tests/clean_effects.bench.js b/benchmarking/benchmarks/reactivity/tests/clean_effects.bench.js
new file mode 100644
index 0000000000..a617554f1b
--- /dev/null
+++ b/benchmarking/benchmarks/reactivity/tests/clean_effects.bench.js
@@ -0,0 +1,32 @@
+import assert from 'node:assert';
+import * as $ from 'svelte/internal/client';
+
+export default () => {
+	const a = $.state(1);
+	const b = $.state(2);
+
+	let total = 0;
+
+	const destroy = $.effect_root(() => {
+		for (let i = 0; i < 1000; i += 1) {
+			$.render_effect(() => {
+				total += $.get(a);
+			});
+		}
+
+		$.render_effect(() => {
+			total += $.get(b);
+		});
+	});
+
+	return {
+		destroy,
+		run() {
+			for (let i = 0; i < 5; i++) {
+				total = 0;
+				$.flush(() => $.set(b, i));
+				assert.equal(total, i);
+			}
+		}
+	};
+};

From ef4a077a51a832108ff2ea9f93df857b1bf84477 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 21 May 2026 10:30:57 -0400
Subject: [PATCH 108/122] fix

---
 .../client/visitors/VariableDeclaration.js            | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/VariableDeclaration.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/VariableDeclaration.js
index dffa79cd7a..72685a8e83 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/VariableDeclaration.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/VariableDeclaration.js
@@ -194,11 +194,6 @@ export function VariableDeclaration(node, context) {
 					/** @type {CallExpression} */ (init)
 				);
 
-				// for now, only wrap async derived in $.save if it's not
-				// a top-level instance derived. TODO in future maybe we
-				// can dewaterfall all of them?
-				const should_save = context.state.is_instance && context.state.scope.function_depth > 1;
-
 				if (declarator.id.type === 'Identifier') {
 					let expression = /** @type {Expression} */ (context.visit(value));
 
@@ -213,9 +208,7 @@ export function VariableDeclaration(node, context) {
 							location ? b.literal(location) : undefined
 						);
 
-						call = should_save ? save(call) : b.await(call);
-
-						declarations.push(b.declarator(declarator.id, call));
+						declarations.push(b.declarator(declarator.id, b.await(call)));
 					} else {
 						if (rune === '$derived') expression = b.thunk(expression);
 
@@ -251,7 +244,7 @@ export function VariableDeclaration(node, context) {
 								location ? b.literal(location) : undefined
 							);
 
-							call = should_save ? save(call) : b.await(call);
+							call = b.await(call);
 						}
 
 						declarations.push(b.declarator(id, call));

From 3a45c49b79eb3c9f9a5fea3ca42de91bea6016db Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 21 May 2026 10:49:06 -0400
Subject: [PATCH 109/122] fix

---
 packages/svelte/src/internal/client/reactivity/batch.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 895b752ed8..e3cb4abf9d 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -530,7 +530,10 @@ export class Batch {
 					var effect = /** @type {Effect} */ (reaction);
 
 					if (flags & (ASYNC | BLOCK_EFFECT) && !this.async_deriveds.has(effect)) {
-						effect.f ^= ~CLEAN;
+						if ((effect.f & CLEAN) !== 0) {
+							effect.f ^= CLEAN;
+						}
+
 						this.schedule(effect);
 					}
 				}

From d1de7c5b03688423e64a20cbe2f4615a47732791 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 21 May 2026 17:08:44 -0400
Subject: [PATCH 110/122] fix

---
 .../src/internal/client/reactivity/batch.js       | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index e3cb4abf9d..d5fbc750ff 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -300,12 +300,8 @@ export class Batch {
 			}
 		}
 
-		// we only reschedule previously-deferred effects if we expect
-		// to be able to run them after processing the batch
-		if (!this.#is_deferred()) {
-			for (const e of this.#dirty_effects) {
-				this.schedule(e);
-			}
+		for (const e of this.#dirty_effects) {
+			this.schedule(e);
 		}
 
 		const roots = this.#roots;
@@ -494,19 +490,22 @@ export class Batch {
 	 * @param {Batch} batch
 	 */
 	#merge(batch) {
-		for (const [source, value] of batch.current) {
+		for (const [source, snapshot] of batch.current) {
 			var previous = batch.previous.get(source);
 
 			if (previous && !this.previous.has(source)) {
 				this.previous.set(source, previous);
 			}
 
-			this.current.set(source, value);
+			this.current.set(source, snapshot);
 		}
 
 		for (const [effect, deferred] of batch.async_deriveds) {
 			const d = this.async_deriveds.get(effect);
 			if (d) deferred.promise.then(d.resolve);
+
+			var cv = batch.cvs.get(effect);
+			if (cv !== undefined) this.cvs.set(effect, cv);
 		}
 
 		/**

From 957dbfe75a4ef22f2b0253eb88729cddbb1b7e69 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 21 May 2026 19:09:36 -0400
Subject: [PATCH 111/122] drive-by

---
 packages/svelte/src/internal/client/runtime.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 2bbfcaa239..c69f80590b 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -212,9 +212,8 @@ export function is_dirty(reaction) {
 /**
  * @param {Value} signal
  * @param {Effect} effect
- * @param {boolean} [root]
  */
-function schedule_possible_effect_self_invalidation(signal, effect, root = true) {
+function schedule_possible_effect_self_invalidation(signal, effect) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
 
@@ -226,7 +225,7 @@ function schedule_possible_effect_self_invalidation(signal, effect, root = true)
 		var reaction = reactions[i];
 
 		if ((reaction.f & DERIVED) !== 0) {
-			schedule_possible_effect_self_invalidation(/** @type {Derived} */ (reaction), effect, false);
+			schedule_possible_effect_self_invalidation(/** @type {Derived} */ (reaction), effect);
 		} else if (effect === reaction) {
 			schedule_effect(/** @type {Effect} */ (reaction));
 		}

From 6d835a00fb7080704abaa5541ddb325cf3f7e331 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 22 May 2026 15:37:01 -0400
Subject: [PATCH 112/122] fix. almost there

---
 .../svelte/src/internal/client/reactivity/sources.js     | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 47ed57ce18..ae53fc17ce 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -28,7 +28,8 @@ import {
 	WAS_MARKED,
 	CONNECTED,
 	STATE_EAGER_EFFECT,
-	REACTION_IS_UPDATING
+	REACTION_IS_UPDATING,
+	REACTION_RAN
 } from '#client/constants';
 import * as e from '../errors.js';
 import { legacy_mode_flag, tracing_mode_flag } from '../../flags/index.js';
@@ -361,7 +362,11 @@ export function mark_reactions(batch, signal, wv, updated_during_traversal) {
 
 				if ((flags & WAS_MARKED) === 0) {
 					// Only connected deriveds can be reliably unmarked right away
-					if (flags & CONNECTED) {
+					if (
+						flags & CONNECTED &&
+						active_reaction !== null &&
+						(active_reaction.f & REACTION_RAN) !== 0
+					) {
 						reaction.f |= WAS_MARKED;
 					}
 

From 8332bb32a236a7dcad9f791237dd1705948cd206 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 22 May 2026 17:40:25 -0400
Subject: [PATCH 113/122] fixes

---
 packages/svelte/src/internal/client/reactivity/batch.js    | 1 +
 packages/svelte/src/internal/client/reactivity/deriveds.js | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index bb05283366..441f89a299 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1173,6 +1173,7 @@ function mark_effects(batch, value, sources, marked, checked) {
 
 			if ((flags & DERIVED) !== 0) {
 				batch.current.delete(/** @type {Derived} */ (reaction));
+				batch.cvs.set(/** @type {Derived} */ (reaction), -1);
 
 				mark_effects(batch, /** @type {Derived} */ (reaction), sources, marked, checked);
 			} else if ((flags & (ASYNC | BLOCK_EFFECT)) !== 0 && depends_on(reaction, sources, checked)) {
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index ac2d5401df..8bdb61748e 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -402,7 +402,7 @@ export function update_derived(derived) {
 
 	if (!derived.equals(value)) {
 		if (active_batch !== null) {
-			active_batch.capture(derived, value, write_version);
+			(current_batch ?? active_batch).capture(derived, value, write_version);
 
 			// We also write to previous_batch because if it exists, it is a sign that we're
 			// currently in the process of flushing effects. These updates to deriveds may belong

From 2f4b0584fa4f2de578590607414f3a8bf05e7957 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 26 May 2026 14:44:38 -0400
Subject: [PATCH 114/122] fix

---
 .../svelte/src/internal/client/reactivity/batch.js   |  8 --------
 .../svelte/src/internal/client/reactivity/sources.js |  5 +----
 packages/svelte/src/internal/client/runtime.js       | 12 +++++++-----
 3 files changed, 8 insertions(+), 17 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index c51bce1353..d3f7e0493d 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1233,14 +1233,6 @@ function depends_on(reaction, sources, checked) {
 	return false;
 }
 
-/**
- * @param {Effect} effect
- * @returns {void}
- */
-export function schedule_effect(effect) {
-	/** @type {Batch} */ (current_batch).schedule(effect);
-}
-
 /** @type {Source<number>[]} */
 let eager_versions = [];
 
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index ae53fc17ce..389638ee09 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -28,7 +28,6 @@ import {
 	WAS_MARKED,
 	CONNECTED,
 	STATE_EAGER_EFFECT,
-	REACTION_IS_UPDATING,
 	REACTION_RAN
 } from '#client/constants';
 import * as e from '../errors.js';
@@ -40,12 +39,10 @@ import { component_context, is_runes } from '../context.js';
 import {
 	Batch,
 	eager_block_effects,
-	schedule_effect,
 	legacy_updates,
 	set_cv,
 	get_cv,
-	active_batch,
-	current_batch
+	active_batch
 } from './batch.js';
 import { proxy } from '../proxy.js';
 import { execute_derived } from './deriveds.js';
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index c69f80590b..0d925e2337 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -52,7 +52,6 @@ import {
 	flushSync,
 	get_cv,
 	active_batch,
-	schedule_effect,
 	set_cv,
 	get_wv
 } from './reactivity/batch.js';
@@ -210,10 +209,11 @@ export function is_dirty(reaction) {
 }
 
 /**
+ * @param {Batch} batch
  * @param {Value} signal
  * @param {Effect} effect
  */
-function schedule_possible_effect_self_invalidation(signal, effect) {
+function schedule_possible_effect_self_invalidation(batch, signal, effect) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
 
@@ -225,9 +225,9 @@ function schedule_possible_effect_self_invalidation(signal, effect) {
 		var reaction = reactions[i];
 
 		if ((reaction.f & DERIVED) !== 0) {
-			schedule_possible_effect_self_invalidation(/** @type {Derived} */ (reaction), effect);
+			schedule_possible_effect_self_invalidation(batch, /** @type {Derived} */ (reaction), effect);
 		} else if (effect === reaction) {
-			schedule_effect(/** @type {Effect} */ (reaction));
+			batch.schedule(/** @type {Effect} */ (reaction));
 		}
 	}
 }
@@ -308,10 +308,12 @@ export function update_reaction(reaction) {
 			untracked_writes !== null &&
 			!untracking &&
 			deps !== null &&
-			(reaction.f & DERIVED) === 0
+			(reaction.f & DERIVED) === 0 &&
+			current_batch !== null
 		) {
 			for (i = 0; i < /** @type {Source[]} */ (untracked_writes).length; i++) {
 				schedule_possible_effect_self_invalidation(
+					current_batch,
 					untracked_writes[i],
 					/** @type {Effect} */ (reaction)
 				);

From 9ff512377e7716ca40e23d3a7dea48dbe711bed0 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 26 May 2026 15:41:16 -0400
Subject: [PATCH 115/122] gate on non-async mode

---
 packages/svelte/src/internal/client/runtime.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 0d925e2337..dadad43945 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -217,7 +217,7 @@ function schedule_possible_effect_self_invalidation(batch, signal, effect) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
 
-	if (!async_mode_flag && current_sources !== null && includes.call(current_sources, signal)) {
+	if (current_sources !== null && includes.call(current_sources, signal)) {
 		return;
 	}
 
@@ -304,6 +304,7 @@ export function update_reaction(reaction) {
 		// ensure that if any of those untracked writes result in re-invalidation
 		// of the current effect, then that happens accordingly
 		if (
+			!async_mode_flag &&
 			is_runes() &&
 			untracked_writes !== null &&
 			!untracking &&

From 6bba64707379ef7f40d9cf38a29ea5142a0393ff Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 28 May 2026 17:19:36 -0400
Subject: [PATCH 116/122] working?

---
 .../svelte/src/internal/client/reactivity/batch.js     | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index dcc02793ce..be1e6f2d82 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -532,6 +532,16 @@ export class Batch {
 		// Mark is not guaranteed to not touch these, so we transfer them
 		this.transfer_effects(batch.#dirty_effects);
 
+		for (const fn of batch.#commit_callbacks) {
+			this.#commit_callbacks.add(() => fn(batch));
+		}
+
+		for (const fn of batch.#discard_callbacks) {
+			this.#discard_callbacks.add(() => fn(batch));
+		}
+
+		this.settled().then(batch.#deferred?.resolve, batch.#deferred?.reject);
+
 		/**
 		 * mark all effects that depend on `batch.current`, except the
 		 * async effects that we just resolved (TODO unless they depend

From 47a4dd3712a10af216590aad222bdcf2f773ad7f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 28 May 2026 17:38:17 -0400
Subject: [PATCH 117/122] tweak

---
 .../svelte/src/internal/client/reactivity/batch.js | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index be1e6f2d82..8564228b8f 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -529,9 +529,6 @@ export class Batch {
 			if (cv !== undefined) this.cvs.set(effect, cv);
 		}
 
-		// Mark is not guaranteed to not touch these, so we transfer them
-		this.transfer_effects(batch.#dirty_effects);
-
 		for (const fn of batch.#commit_callbacks) {
 			this.#commit_callbacks.add(() => fn(batch));
 		}
@@ -540,7 +537,15 @@ export class Batch {
 			this.#discard_callbacks.add(() => fn(batch));
 		}
 
-		this.settled().then(batch.#deferred?.resolve, batch.#deferred?.reject);
+		// TODO this doesn't feel quite right, but it gets the tests to pass
+		this.oncommit(() => {
+			for (const fn of batch.#discard_callbacks) fn(batch);
+		});
+
+		this.settled().then(() => batch.#deferred?.resolve());
+
+		// Mark is not guaranteed to not touch these, so we transfer them
+		this.transfer_effects(batch.#dirty_effects);
 
 		/**
 		 * mark all effects that depend on `batch.current`, except the
@@ -577,7 +582,6 @@ export class Batch {
 			mark(source);
 		}
 
-		this.oncommit(() => batch.discard());
 		batch.#unlink();
 
 		current_batch = this;

From 464a2d3671cbe7c5da7a4351dd60fc0cba7397cf Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Fri, 29 May 2026 17:58:50 -0400
Subject: [PATCH 118/122] tidy up

---
 packages/svelte/src/internal/client/dom/blocks/each.js | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/svelte/src/internal/client/dom/blocks/each.js b/packages/svelte/src/internal/client/dom/blocks/each.js
index 60acaf8bc9..87ec82d70e 100644
--- a/packages/svelte/src/internal/client/dom/blocks/each.js
+++ b/packages/svelte/src/internal/client/dom/blocks/each.js
@@ -212,9 +212,6 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 		tag(each_array, '{#each ...}');
 	}
 
-	/** @type {V[]} */
-	var array;
-
 	/** @type {Map<Batch, Set<any>>} */
 	var pending = new Map();
 
@@ -262,7 +259,7 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 	}
 
 	var effect = block(() => {
-		array = get(each_array);
+		var array = get(each_array);
 		var length = array.length;
 
 		/** `true` if there was a hydration mismatch. Needs to be a `let` or else it isn't treeshaken out */

From b199a7ea907957676db3c23019b9f90d258df8cd Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 1 Jun 2026 21:42:25 -0400
Subject: [PATCH 119/122] add test

---
 .../async-overlapping-array-2/_config.js      | 62 +++++++++++++++++++
 .../async-overlapping-array-2/main.svelte     | 32 ++++++++++
 2 files changed, 94 insertions(+)
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlapping-array-2/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-overlapping-array-2/main.svelte

diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlapping-array-2/_config.js b/packages/svelte/tests/runtime-runes/samples/async-overlapping-array-2/_config.js
new file mode 100644
index 0000000000..ff11893334
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlapping-array-2/_config.js
@@ -0,0 +1,62 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target, logs }) {
+		await tick();
+
+		const [increment, shift] = target.querySelectorAll('button');
+
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+				<button>increment</button>
+				<button>shift</button>
+				<div>1</div>
+				<div>2</div>
+				<div>3</div>
+			`
+		);
+
+		assert.deepEqual(logs, ['updating']);
+
+		increment.click();
+		await tick();
+		increment.click();
+		await tick();
+
+		assert.deepEqual(logs, ['updating', 'updating', 'updating']);
+
+		shift.click();
+		shift.click();
+		shift.click();
+		await tick();
+
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+				<button>increment</button>
+				<button>shift</button>
+				<div>2</div>
+				<div>3</div>
+				<div>4</div>
+			`
+		);
+
+		shift.click();
+		shift.click();
+		shift.click();
+		await tick();
+
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+				<button>increment</button>
+				<button>shift</button>
+				<div>3</div>
+				<div>4</div>
+				<div>5</div>
+			`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-overlapping-array-2/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-overlapping-array-2/main.svelte
new file mode 100644
index 0000000000..08a2ab110b
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-overlapping-array-2/main.svelte
@@ -0,0 +1,32 @@
+<script lang="ts">
+	let items = $state([1, 2, 3])
+	let queue: Array<() => void> = [];
+
+	function push(value: number) {
+		return new Promise((fulfil) => {
+			queue.push(() => fulfil(value));
+		});
+	}
+
+	function shift() {
+		queue.shift()?.();
+	}
+
+	let array = $derived.by(() => {
+		console.log('updating');
+		return items;
+	});
+
+	queueMicrotask(() => {
+		shift();
+		shift();
+		shift();
+	});
+</script>
+
+<button onclick={() => items = items.map((n) => n + 1)}>increment</button>
+<button onclick={shift}>shift</button>
+
+{#each array as item}
+	<div>{await push(item)}</div>
+{/each}

From 4866aa233359e8d307122e14cb56196beaa94b22 Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Tue, 2 Jun 2026 13:26:53 +0200
Subject: [PATCH 120/122] don't bail self-invalidation in async mode + don't
 mark reactions on initial run

not marking without not bailing makes two tests fail, revealing that the "don't self-invalidate in async mode" change would actually be a subtle breaking change
---
 .../svelte/src/internal/client/reactivity/batch.js     | 10 ++++++----
 .../svelte/src/internal/client/reactivity/deriveds.js  |  8 +++-----
 packages/svelte/src/internal/client/runtime.js         |  1 -
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index bdc2bdae42..566adc5b03 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -287,18 +287,20 @@ export class Batch {
 		if (this.#committed) return;
 
 		current_batch = this;
-		this.#started = true;
 
 		if (flush_count++ > 1000) {
 			this.#unlink();
 			infinite_loop_guard();
 		}
 
-		// TODO we only need to do this for re-runs
-		for (const [source, snapshot] of this.current) {
-			mark_reactions(this, source, snapshot.wv, null);
+		if (this.#started) {
+			for (const [source, snapshot] of this.current) {
+				mark_reactions(this, source, snapshot.wv, null);
+			}
 		}
 
+		this.#started = true;
+
 		if (DEV) {
 			// track all the values that were updated during this flush,
 			// so that they can be reset afterwards
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 6352c66b17..99a809dbaa 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -1,6 +1,5 @@
-/** @import { Derived, Effect, Reaction, Source, Value } from '#client' */
+/** @import { Derived, Effect, Source, Value } from '#client' */
 /** @import { Batch } from './batch.js'; */
-/** @import { Boundary } from '../dom/blocks/boundary.js'; */
 import { DEV } from 'esm-env';
 import {
 	ERROR_VALUE,
@@ -26,14 +25,13 @@ import {
 	write_version,
 	skipped_deps,
 	new_deps,
-	is_destroying_effect,
-	current_sources
+	is_destroying_effect
 } from '../runtime.js';
 import { equals, safe_equals } from './equality.js';
 import * as e from '../errors.js';
 import * as w from '../warnings.js';
 import { async_effect, destroy_effect, destroy_effect_children, teardown } from './effects.js';
-import { eager_effects, internal_set, set_eager_effects, source, state } from './sources.js';
+import { eager_effects, internal_set, set_eager_effects, state } from './sources.js';
 import { get_error } from '../../shared/dev.js';
 import { async_mode_flag, tracing_mode_flag } from '../../flags/index.js';
 import { component_context } from '../context.js';
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index b4dcc04b30..78f4179890 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -300,7 +300,6 @@ export function update_reaction(reaction) {
 		// ensure that if any of those untracked writes result in re-invalidation
 		// of the current effect, then that happens accordingly
 		if (
-			!async_mode_flag &&
 			is_runes() &&
 			untracked_writes !== null &&
 			!untracking &&

From 00eefb6c8168f01dccc797db8c54e80553db00f8 Mon Sep 17 00:00:00 2001
From: Simon H <5968653+dummdidumm@users.noreply.github.com>
Date: Fri, 5 Jun 2026 23:52:07 +0200
Subject: [PATCH 121/122] fix: create batch.eager for forks with eager work
 (#18362)

Replaces the ad-hoc `STATE_EAGER_EFFECT` flag which makes eager effects
over-execute with a mechanism that is two-fold:
1. eager versions are sorted by batch. If a batch belongs to a fork,
that way it's made sure it doesn't "escape" that fork
2. batches now have an `eager` field, which is set for forks with eager
work. It's flushed on commit just before the main commit. This way the
eager work happens separately and eagerly just before the main fork
commits, which itself may not be ready yet.

Additionally in `sources.js` we make sure `active_batch` is set properly
when flushing eager effects.

---------

Co-authored-by: Rich Harris <rich.harris@vercel.com>
Co-authored-by: vercel[bot] <35613825+vercel[bot]@users.noreply.github.com>
Co-authored-by: Vercel <vercel[bot]@users.noreply.github.com>
Co-authored-by: Rich-Harris <hello@rich-harris.dev>
---
 .../svelte/src/internal/client/constants.js   |  1 -
 .../src/internal/client/reactivity/batch.js   | 88 +++++++++++--------
 .../src/internal/client/reactivity/sources.js |  7 +-
 .../samples/async-eager-derived/main.svelte   |  1 -
 4 files changed, 53 insertions(+), 44 deletions(-)

diff --git a/packages/svelte/src/internal/client/constants.js b/packages/svelte/src/internal/client/constants.js
index d96cb5204c..bc9f014ce4 100644
--- a/packages/svelte/src/internal/client/constants.js
+++ b/packages/svelte/src/internal/client/constants.js
@@ -42,7 +42,6 @@ export const HEAD_EFFECT = 1 << 18;
 export const EFFECT_PRESERVED = 1 << 19;
 export const USER_EFFECT = 1 << 20;
 export const EFFECT_OFFSCREEN = 1 << 25;
-export const STATE_EAGER_EFFECT = 1 << 27;
 
 // Flags exclusive to deriveds
 /**
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 566adc5b03..16d1ba273a 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -15,7 +15,6 @@ import {
 	ERROR_VALUE,
 	MANAGED_EFFECT,
 	REACTION_RAN,
-	STATE_EAGER_EFFECT,
 	DESTROYING
 } from '#client/constants';
 import { async_mode_flag } from '../../flags/index.js';
@@ -110,6 +109,13 @@ export class Batch {
 
 	linked = true;
 
+	/**
+	 * In case of a fork with eager effects, this is the related eager batch
+	 * that will commit eagerly updating effects just before this fork commits.
+	 * @type {Batch | null}
+	 */
+	eager = null;
+
 	/** @type {Batch | null} */
 	#prev = null;
 
@@ -1242,16 +1248,22 @@ function depends_on(reaction, sources, checked) {
 	return false;
 }
 
-/** @type {Source<number>[]} */
-let eager_versions = [];
+/** @type {Map<Batch | null, Source<number>[]>} */
+let eager_map = new Map();
 
 let running_eager_effect = false;
 
-function eager_flush() {
+/** @param {Batch} batch */
+function eager_flush(batch) {
 	flushSync(() => {
-		const eager = eager_versions;
-		eager_versions = [];
-		for (const version of eager) {
+		const versions = /** @type {Source<number>[]} */ (eager_map.get(batch));
+		eager_map.delete(batch);
+		const eager_batch = (current_batch = batch.eager ?? new Batch());
+		if (batch.is_fork) {
+			eager_batch.is_fork = true;
+			batch.eager = eager_batch;
+		}
+		for (const version of versions) {
 			update(version);
 		}
 	});
@@ -1289,7 +1301,7 @@ export function eager(fn) {
 		version.label = '<eager>';
 	}
 
-	var effect = eager_effect(() => {
+	eager_effect(() => {
 		if (initial) {
 			// the first time this runs, we create an eager effect
 			// that will run eagerly whenever the expression changes
@@ -1308,23 +1320,18 @@ export function eager(fn) {
 			return;
 		}
 
-		if (!current_batch?.is_fork) {
-			// the second time this effect runs, it's to schedule a
-			// `version` update. since this will recreate the effect,
-			// we don't need to evaluate the expression here
-			if (eager_versions.length === 0) {
-				queue_micro_task(eager_flush);
-			}
-
-			eager_versions.push(version);
-		} else {
-			fn();
+		// the second time this effect runs, it's to schedule a
+		// `version` update. since this will recreate the effect,
+		// we don't need to evaluate the expression here
+		const batch = /** @type {Batch} */ (current_batch);
+		const versions = eager_map.get(batch) ?? [];
+		if (versions.length === 0) {
+			eager_map.set(batch, versions);
+			queue_micro_task(() => eager_flush(batch));
 		}
-	});
 
-	// TODO ideally this wouldn't be necessary. I haven't figured out a way for these
-	// effects to correctly be marked dirty when `$state.eager(...)` arguments change
-	effect.f |= STATE_EAGER_EFFECT;
+		versions.push(version);
+	});
 
 	initial = false;
 
@@ -1430,24 +1437,26 @@ export function fork(fn) {
 				value.wv = snapshot.wv;
 			}
 
-			// trigger any `$state.eager(...)` expressions with the new state.
-			// eager effects don't get scheduled like other effects, so we
-			// can't just encounter them during traversal, we need to
-			// proactively flush them
-			// TODO maybe there's a better implementation?
-			// e.g. maybe we can just schedule them so that they run
-			// with everything else during batch.flush?
-			flushSync(() => {
-				/** @type {Set<Effect>} */
-				var eager_effects = new Set();
-
-				for (var source of batch.current.keys()) {
-					mark_eager_effects(source, eager_effects);
+			// Flush the eager batch first to update any effects depending
+			// on `$state.eager/$effect.pending`
+			if (batch.eager) {
+				const eager = batch.eager;
+				eager.is_fork = false;
+
+				for ([reaction, cv] of eager.cvs) {
+					if (cv > reaction.cv) {
+						reaction.cv = cv;
+					}
 				}
 
-				set_eager_effects(eager_effects);
-				flush_eager_effects();
-			});
+				for ([value, snapshot] of eager.current) {
+					value.v = snapshot.v;
+					value.wv = snapshot.wv;
+				}
+
+				eager.flush();
+				batch.eager = null;
+			}
 
 			batch.flush();
 			await settled;
@@ -1460,6 +1469,7 @@ export function fork(fn) {
 			}
 
 			if (!committed && batch.linked) {
+				batch.eager?.discard();
 				batch.discard();
 			}
 		}
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 2514163fdd..aa0206a917 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -27,7 +27,6 @@ import {
 	ASYNC,
 	WAS_MARKED,
 	CONNECTED,
-	STATE_EAGER_EFFECT,
 	REACTION_RAN
 } from '#client/constants';
 import * as e from '../errors.js';
@@ -41,7 +40,8 @@ import {
 	legacy_updates,
 	set_cv,
 	get_cv,
-	active_batch
+	active_batch,
+	current_batch
 } from './batch.js';
 import { proxy } from '../proxy.js';
 import { execute_derived } from './deriveds.js';
@@ -245,6 +245,7 @@ export function internal_set(source, value, updated_during_traversal = null) {
 		}
 
 		if (!batch.is_fork && eager_effects.size > 0 && !eager_effects_deferred) {
+			current_batch?.apply(); // the current batch is not necessarily the active batch, ensure it is
 			flush_eager_effects();
 		}
 	}
@@ -259,7 +260,7 @@ export function flush_eager_effects() {
 		let dirty;
 
 		try {
-			dirty = (effect.f & STATE_EAGER_EFFECT) !== 0 || is_dirty(effect);
+			dirty = is_dirty(effect);
 		} catch {
 			// Dirty-checking can evaluate derived dependencies and throw in cases where
 			// parent effects are about to destroy this eager effect. Run the effect so
diff --git a/packages/svelte/tests/runtime-runes/samples/async-eager-derived/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-eager-derived/main.svelte
index d1d979126d..e199386870 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-eager-derived/main.svelte
+++ b/packages/svelte/tests/runtime-runes/samples/async-eager-derived/main.svelte
@@ -1,5 +1,4 @@
 <script>
-	
 	let count = $state(0);
 	const delayedCount = $derived(await push(count));
 	const derivedCount = $derived(count);

From aacb5c458d0ed8cb43b974de3129e2b54b651d69 Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Mon, 6 Jul 2026 14:41:17 +0200
Subject: [PATCH 122/122] fix

---
 packages/svelte/src/internal/client/runtime.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 4dbae1fee9..b4f6636b2e 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -54,8 +54,7 @@ import {
 	active_batch,
 	set_cv,
 	get_wv,
-	previous_batch,
-	schedule_effect
+	previous_batch
 } from './reactivity/batch.js';
 import { handle_error } from './error-handling.js';
 import { UNINITIALIZED } from '../../constants.js';