From 58297c5a73e6a06687c3892efbfc807eec3f23af Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Thu, 24 Sep 2026 04:19:37 -0400
Subject: [PATCH 01/14] chore: extract some minor changes from #18861 (#18866)

doing my usual thing of extracting no-brainer changes from a giant PR to
try and make it slightly less giant
---
 packages/svelte/src/internal/client/dev/tracing.js        | 4 +++-
 packages/svelte/src/internal/client/dom/blocks/each.js    | 4 ++--
 packages/svelte/src/internal/client/reactivity/batch.js   | 4 ++++
 packages/svelte/src/internal/client/reactivity/sources.js | 6 +++---
 packages/svelte/src/internal/client/runtime.js            | 6 +++---
 packages/svelte/src/reactivity/date.js                    | 4 ++--
 6 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/packages/svelte/src/internal/client/dev/tracing.js b/packages/svelte/src/internal/client/dev/tracing.js
index c6edfde933..9fea8175bd 100644
--- a/packages/svelte/src/internal/client/dev/tracing.js
+++ b/packages/svelte/src/internal/client/dev/tracing.js
@@ -131,8 +131,10 @@ export function trace(label, fn) {
 }
 
 /**
- * @param {Value} source
+ * @template {Value} T
+ * @param {T} source
  * @param {string} label
+ * @returns {T}
  */
 export function tag(source, label) {
 	source.label = label;
diff --git a/packages/svelte/src/internal/client/dom/blocks/each.js b/packages/svelte/src/internal/client/dom/blocks/each.js
index 9a2504f887..ea828f893b 100644
--- a/packages/svelte/src/internal/client/dom/blocks/each.js
+++ b/packages/svelte/src/internal/client/dom/blocks/each.js
@@ -1,4 +1,4 @@
-/** @import { EachItem, EachOutroGroup, EachState, Effect, EffectNodes, MaybeSource, Source, TemplateNode, TransitionManager, Value } from '#client' */
+/** @import { EachItem, EachOutroGroup, EachState, Effect, EffectNodes, MaybeSource, TemplateNode, TransitionManager } from '#client' */
 /** @import { Batch } from '../../reactivity/batch.js'; */
 import {
 	EACH_INDEX_REACTIVE,
@@ -664,7 +664,7 @@ function reconcile(state, array, anchor, flags, get_key) {
  * @param {V} value
  * @param {unknown} key
  * @param {number} index
- * @param {(anchor: Node, item: V | Source<V>, index: number | Value<number>, collection: () => V[]) => void} render_fn
+ * @param {(anchor: Node, item: MaybeSource<V>, index: MaybeSource<number>, collection: () => V[]) => void} render_fn
  * @param {number} flags
  * @param {() => V[]} get_collection
  * @returns {EachItem}
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 75ce33b1c5..f620c2b4c8 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1295,6 +1295,10 @@ export function eager(fn) {
 	let version = version_map.get(parent) ?? source(0);
 	version_map.set(parent, version);
 
+	if (DEV) {
+		version.label ??= '$state.eager version';
+	}
+
 	teardown(() => {
 		if (parent.f & DESTROYING) version_map.delete(parent);
 	});
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 006494f0b5..4b10ddbd31 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -46,7 +46,7 @@ import { set_signal_status, update_derived_status } from './status.js';
 /** @type {Set<Effect>} */
 export let eager_effects = new Set();
 
-/** @type {Map<Source, any>} */
+/** @type {Map<Value, any>} */
 export const old_values = new Map();
 
 /**
@@ -141,7 +141,7 @@ export function mutate(source, value) {
 
 /**
  * @template V
- * @param {Source<V>} source
+ * @param {Value<V>} source
  * @param {V} value
  * @param {boolean} [should_proxy]
  * @returns {V}
@@ -181,7 +181,7 @@ var count_deps = 0;
 
 /**
  * @template V
- * @param {Source<V>} source
+ * @param {Value<V>} source
  * @param {V} value
  * @param {Effect[] | null} [updated_during_traversal]
  * @returns {V}
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 27def05300..6212605008 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -93,7 +93,7 @@ export function set_active_effect(effect) {
 /**
  * When sources are created within a reaction, reading and writing
  * them within that reaction should not cause a re-run
- * @type {null | Set<Source>}
+ * @type {null | Set<Value>}
  */
 export let current_sources = null;
 
@@ -121,11 +121,11 @@ export let skipped_deps = 0;
 /**
  * Tracks writes that the effect it's executed in doesn't listen to yet,
  * so that the dependency can be added to the effect later on if it then reads it
- * @type {null | Source[]}
+ * @type {null | Value[]}
  */
 export let untracked_writes = null;
 
-/** @param {null | Source[]} value */
+/** @param {null | Value[]} value */
 export function set_untracked_writes(value) {
 	untracked_writes = value;
 }
diff --git a/packages/svelte/src/reactivity/date.js b/packages/svelte/src/reactivity/date.js
index f882c05d76..b70ba7969a 100644
--- a/packages/svelte/src/reactivity/date.js
+++ b/packages/svelte/src/reactivity/date.js
@@ -1,4 +1,4 @@
-/** @import { Source } from '#client' */
+/** @import { Derived } from '#client' */
 import { derived } from '../internal/client/index.js';
 import { set, state } from '../internal/client/reactivity/sources.js';
 import { tag } from '../internal/client/dev/tracing.js';
@@ -42,7 +42,7 @@ var inited = false;
 export class SvelteDate extends Date {
 	#time = state(super.getTime());
 
-	/** @type {Map<keyof Date, Source<unknown>>} */
+	/** @type {Map<keyof Date, Derived<unknown>>} */
 	#deriveds = new Map();
 
 	#reaction = active_reaction;

From da2f83343bf5e2fb183881b74ef06fac24f0e249 Mon Sep 17 00:00:00 2001
From: Simon H <5968653+dummdidumm@users.noreply.github.com>
Date: Thu, 24 Sep 2026 22:47:52 +0200
Subject: [PATCH 02/14] fix: read batch-local array on each-block commit
 (#18879)

Another extraction from #18861 which I'm pretty sure you can also
construct a buggy reproduction for today, but with #18861 it's strictly
necessary so we don't need to come up with one now
---
 .changeset/short-radios-sneeze.md                      |  5 +++++
 packages/svelte/src/internal/client/dom/blocks/each.js | 10 ++++++----
 2 files changed, 11 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/short-radios-sneeze.md

diff --git a/.changeset/short-radios-sneeze.md b/.changeset/short-radios-sneeze.md
new file mode 100644
index 0000000000..847c3eef17
--- /dev/null
+++ b/.changeset/short-radios-sneeze.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: read batch-local array on each-block commit
diff --git a/packages/svelte/src/internal/client/dom/blocks/each.js b/packages/svelte/src/internal/client/dom/blocks/each.js
index ea828f893b..58d59a6825 100644
--- a/packages/svelte/src/internal/client/dom/blocks/each.js
+++ b/packages/svelte/src/internal/client/dom/blocks/each.js
@@ -216,9 +216,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();
 
@@ -234,6 +231,11 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 
 		state.pending.delete(batch);
 
+		// The effect doesn't necessarily re-run in a batch right before that batch commits
+		// (its view of the collection may not have changed), so we read the collection
+		// as the committing batch sees it rather than using the most recent block run's result
+		var array = get(each_array);
+
 		state.fallback = fallback;
 		reconcile(state, array, anchor, flags, get_key);
 
@@ -264,7 +266,7 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 	}
 
 	var effect = block(() => {
-		array = /** @type {V[]} */ (get(each_array));
+		var array = /** @type {V[]} */ (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 98e547535d9286cfd4163fe3a6d85c7053db6c6e Mon Sep 17 00:00:00 2001
From: Simon H <5968653+dummdidumm@users.noreply.github.com>
Date: Thu, 24 Sep 2026 22:49:15 +0200
Subject: [PATCH 03/14] fix: flush anything pending before invoking flushSync
 callback function (#18878)

no new test here but it's necessary for #18861 to work, and we might as
well extract it
---
 .changeset/major-papayas-run.md                      |  5 +++++
 .../svelte/src/internal/client/reactivity/batch.js   | 12 ++++++++----
 2 files changed, 13 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/major-papayas-run.md

diff --git a/.changeset/major-papayas-run.md b/.changeset/major-papayas-run.md
new file mode 100644
index 0000000000..59909fb448
--- /dev/null
+++ b/.changeset/major-papayas-run.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: flush anything pending before invoking flushSync callback function
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index f620c2b4c8..05f7586072 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1032,15 +1032,15 @@ export class Batch {
  */
 export function flushSync(fn) {
 	var was_flushing_sync = is_flushing_sync;
+	var prev_previous_batch = previous_batch;
+	previous_batch = null;
 	is_flushing_sync = true;
 
 	try {
 		var result;
 
 		if (fn) {
-			if (current_batch !== null && !current_batch.is_fork) {
-				current_batch.flush();
-			}
+			flushSync(); // flush anything pending through the while loop below
 
 			result = fn();
 		}
@@ -1056,6 +1056,7 @@ export function flushSync(fn) {
 		}
 	} finally {
 		is_flushing_sync = was_flushing_sync;
+		previous_batch = prev_previous_batch;
 	}
 }
 
@@ -1406,6 +1407,8 @@ export function fork(fn) {
 		e.fork_timing();
 	}
 
+	flushSync();
+
 	var batch = Batch.ensure();
 	batch.is_fork = true;
 	batch_values = new Map();
@@ -1413,7 +1416,8 @@ export function fork(fn) {
 	var committed = false;
 	var settled = batch.settled();
 
-	flushSync(fn);
+	fn();
+	flushSync();
 
 	return {
 		commit: async () => {

From f7ca0a44a5d198d600521afa44341736c9bee0c8 Mon Sep 17 00:00:00 2001
From: Dex <beniakiraly105@gmail.com>
Date: Fri, 25 Sep 2026 00:04:17 +0200
Subject: [PATCH 04/14] chore: fix typos in code comments (#18860)

Fixes four typos in code comments (no behavioral change):

- `packages/svelte/src/index-client.js`: `noone` -> `no one`
- `packages/svelte/src/internal/client/dom/css.js`: `Therfore` ->
`Therefore`
- `packages/svelte/src/internal/client/runtime.js`: `loosing` ->
`losing`
- `packages/svelte/src/internal/server/index.js`: `aswell` -> `as well`

Checklist: title prefixed with `chore:`; comment-only change so no
changeset and no behavior affected.

Co-authored-by: Dextheking1 <Dextheking1@users.noreply.github.com>
---
 packages/svelte/src/index-client.js            | 2 +-
 packages/svelte/src/internal/client/dom/css.js | 2 +-
 packages/svelte/src/internal/client/runtime.js | 2 +-
 packages/svelte/src/internal/server/index.js   | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/packages/svelte/src/index-client.js b/packages/svelte/src/index-client.js
index 0eb1b80315..3da59eb7f7 100644
--- a/packages/svelte/src/index-client.js
+++ b/packages/svelte/src/index-client.js
@@ -17,7 +17,7 @@ if (DEV) {
 		if (!(rune in globalThis)) {
 			// TODO if people start adjusting the "this can contain runes" config through v-p-s more, adjust this message
 			/** @type {any} */
-			let value; // let's hope noone modifies this global, but belts and braces
+			let value; // let's hope no one modifies this global, but belts and braces
 			Object.defineProperty(globalThis, rune, {
 				configurable: true,
 				// eslint-disable-next-line getter-return
diff --git a/packages/svelte/src/internal/client/dom/css.js b/packages/svelte/src/internal/client/dom/css.js
index 23f4eff4f7..78a32901fe 100644
--- a/packages/svelte/src/internal/client/dom/css.js
+++ b/packages/svelte/src/internal/client/dom/css.js
@@ -12,7 +12,7 @@ export function append_styles(anchor, css) {
 	// Use an effect to ensure `anchor` is in the DOM, otherwise getRootNode() will yield wrong results
 	effect(() => {
 		// Bit of a hack: branches.js/each.js use offscreen fragments with temporary text nodes that will
-		// never be connected to the real dom. Therfore walk up to the branch that has created the component
+		// never be connected to the real dom. Therefore walk up to the branch that has created the component
 		// whose styles we want to append, and check its node instead. It will be connected by the time we get here.
 		anchor = active_effect?.parent?.nodes?.start ?? anchor;
 		var root = anchor.getRootNode();
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 6212605008..76802974b7 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -410,7 +410,7 @@ function remove_reaction(signal, dependency) {
 		// In a fork it's possible that a derived is executed and gets reactions, then commits, but is
 		// never re-executed. This is possible when the derived is only executed once in the context
 		// of a new branch which happens before fork.commit() runs. In this case, the derived still has
-		// UNINITIALIZED as its value, and then when it's loosing its reactions we need to ensure it stays
+		// UNINITIALIZED as its value, and then when it's losing its reactions we need to ensure it stays
 		// DIRTY so it is reexecuted once someone wants its value again.
 		if (derived.v !== UNINITIALIZED) {
 			update_derived_status(derived);
diff --git a/packages/svelte/src/internal/server/index.js b/packages/svelte/src/internal/server/index.js
index 20bef78306..6a63bd9fd6 100644
--- a/packages/svelte/src/internal/server/index.js
+++ b/packages/svelte/src/internal/server/index.js
@@ -168,7 +168,7 @@ export function attributes(attrs, css_hash, classes, styles, flags = 0) {
 				// value/checked takes precedence over defaultValue/defaultChecked
 				name = name === 'defaultvalue' ? 'value' : 'checked';
 				if (name in attrs) continue;
-				// We're checking prior entries aswell because "name in attrs" is not enough as the attributes may have different casing
+				// We're checking prior entries as well because "name in attrs" is not enough as the attributes may have different casing
 				for (let j = 0; j < names.length; j++) {
 					if (names[j].toLowerCase() === name) continue outer;
 				}

From 75aa6ba38d58c83ff012bed77c39edb814e43bc6 Mon Sep 17 00:00:00 2001
From: G <agonavdimetaj@gmail.com>
Date: Fri, 25 Sep 2026 04:44:00 +0200
Subject: [PATCH 05/14] fix: don't warn about redundant `link` role on `<area>`
 without `href` (#18872)

Since #11737, `<a role="link">` without an `href` no longer triggers
`a11y_no_redundant_roles`, but `<area role="link">` without an `href`
still does. Per [ARIA in
HTML](https://www.w3.org/TR/html-aria/#el-area-no-href), an `<area>`
without `href` has the implicit role `generic` and `link` is one of its
allowed roles, so the role isn't redundant. This applies the existing
`<a>` exception to `<area>` and adds test cases for `<area>` with and
without `href`.

Closes #9261. The `<a>` example in that issue was already fixed by
#11737, but the issue was left open.

### Before submitting the PR, please make sure you do the following

- [x] It's really useful if your PR references an issue where it is
discussed ahead of time. In many cases, features are absent for a
reason. For large changes, please create an RFC:
https://github.com/sveltejs/rfcs
- [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`.
- [x] This message body should clearly illustrate what problems it
solves.
- [x] Ideally, include a test that fails without this PR but passes with
it.
- [x] If this PR changes code within `packages/svelte/src`, add a
changeset (`npx changeset`).

### Tests and linting

- [x] Run the tests with `pnpm test` and lint the project with `pnpm
lint`
---
 .changeset/quiet-areas-link.md                       |  5 +++++
 .../phases/2-analyze/visitors/shared/a11y/index.js   |  4 ++--
 .../samples/a11y-no-redundant-roles/input.svelte     |  5 +++++
 .../samples/a11y-no-redundant-roles/warnings.json    | 12 ++++++++++++
 4 files changed, 24 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/quiet-areas-link.md

diff --git a/.changeset/quiet-areas-link.md b/.changeset/quiet-areas-link.md
new file mode 100644
index 0000000000..af4e31f3cb
--- /dev/null
+++ b/.changeset/quiet-areas-link.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: don't warn about a redundant `link` role on `<area>` elements without an `href`
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js
index f06a41d088..c38b03bf69 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js
@@ -173,8 +173,8 @@ export function check_element(node, context) {
 						current_role === get_implicit_role(node.name, attribute_map) &&
 						// <ul role="list"> is ok because CSS list-style:none removes the semantics and this is a way to bring them back
 						!['ul', 'ol', 'li', 'menu'].includes(node.name) &&
-						// <a role="link" /> is ok because without href the a tag doesn't have a role of link
-						!(node.name === 'a' && !attribute_map.has('href'))
+						// <a role="link" /> and <area role="link" /> are ok because without href they don't have a role of link
+						!((node.name === 'a' || node.name === 'area') && !attribute_map.has('href'))
 					) {
 						w.a11y_no_redundant_roles(attribute, current_role);
 					}
diff --git a/packages/svelte/tests/validator/samples/a11y-no-redundant-roles/input.svelte b/packages/svelte/tests/validator/samples/a11y-no-redundant-roles/input.svelte
index 9e06ebe420..68965fb5f4 100644
--- a/packages/svelte/tests/validator/samples/a11y-no-redundant-roles/input.svelte
+++ b/packages/svelte/tests/validator/samples/a11y-no-redundant-roles/input.svelte
@@ -43,6 +43,11 @@
 <header role="banner"></header>
 <footer role="contentinfo"></footer>
 
+<!-- area with href has an implicit role of link -->
+<area href="/" role="link" alt="foo" />
+
 <!-- Allowed -->
 <!-- menu has same interactive role exceptions as ul/ol -->
 <menu role="menu"></menu>
+<!-- area without href doesn't have a role of link, same as a without href -->
+<area role="link" aria-label="foo" />
diff --git a/packages/svelte/tests/validator/samples/a11y-no-redundant-roles/warnings.json b/packages/svelte/tests/validator/samples/a11y-no-redundant-roles/warnings.json
index e041037d71..8e94fef00a 100644
--- a/packages/svelte/tests/validator/samples/a11y-no-redundant-roles/warnings.json
+++ b/packages/svelte/tests/validator/samples/a11y-no-redundant-roles/warnings.json
@@ -454,5 +454,17 @@
 			"column": 8,
 			"line": 44
 		}
+	},
+	{
+		"code": "a11y_no_redundant_roles",
+		"end": {
+			"column": 26,
+			"line": 47
+		},
+		"message": "Redundant role 'link'",
+		"start": {
+			"column": 15,
+			"line": 47
+		}
 	}
 ]

From a956c2bd1fe84eff8e01662b948234c9193c6253 Mon Sep 17 00:00:00 2001
From: waltu <bennet.s@tuta.com>
Date: Fri, 25 Sep 2026 04:44:12 +0200
Subject: [PATCH 06/14] fix: error when using `let:` directives on a component
 with a `children` snippet (#18873)

Closes #13864

A `let:` directive on a component only applies to the default slot
content. If the content is an explicit `{#snippet children()}` block,
the value is never provided, so code like this compiles but fails at
runtime with "value is not defined":

```svelte
<Child let:value>
	{#snippet children()}Value is: {value}{/snippet}
</Child>
```

This adds a compile error on the directive that points to snippet
parameters instead (`{#snippet children({ value })}`, or `{ item: x }`
for `let:item={x}`). Components with a `slot` attribute are not
affected, since there the directive applies to the component itself. An
unused `let:` next to a `children` snippet is also flagged now, but it
never had any effect.

### Before submitting the PR, please make sure you do the following

- [x] It's really useful if your PR references an issue where it is
discussed ahead of time. In many cases, features are absent for a
reason. For large changes, please create an RFC:
https://github.com/sveltejs/rfcs
- [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`.
- [x] This message body should clearly illustrate what problems it
solves.
- [x] Ideally, include a test that fails without this PR but passes with
it.
- [x] If this PR changes code within `packages/svelte/src`, add a
changeset (`npx changeset`).

### Tests and linting

- [x] Run the tests with `pnpm test` and lint the project with `pnpm
lint`

Co-authored-by: waltu <182410443+waltuov@users.noreply.github.com>
---
 .changeset/sour-lets-hide.md                  |  5 ++++
 .../98-reference/.generated/compile-errors.md |  6 +++++
 .../messages/compile-errors/template.md       |  4 ++++
 packages/svelte/src/compiler/errors.js        | 10 ++++++++
 .../phases/2-analyze/visitors/LetDirective.js | 22 ++++++++++++++++++
 .../_config.js                                | 10 ++++++++
 .../main.svelte                               |  7 ++++++
 .../let-directive-children-snippet/_config.js | 10 ++++++++
 .../main.svelte                               | 23 +++++++++++++++++++
 9 files changed, 97 insertions(+)
 create mode 100644 .changeset/sour-lets-hide.md
 create mode 100644 packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet-expression/_config.js
 create mode 100644 packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet-expression/main.svelte
 create mode 100644 packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet/_config.js
 create mode 100644 packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet/main.svelte

diff --git a/.changeset/sour-lets-hide.md b/.changeset/sour-lets-hide.md
new file mode 100644
index 0000000000..6175027cff
--- /dev/null
+++ b/.changeset/sour-lets-hide.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: error when using `let:` directives on a component with a `children` snippet
diff --git a/documentation/docs/98-reference/.generated/compile-errors.md b/documentation/docs/98-reference/.generated/compile-errors.md
index 02e762dc48..eea1be14c8 100644
--- a/documentation/docs/98-reference/.generated/compile-errors.md
+++ b/documentation/docs/98-reference/.generated/compile-errors.md
@@ -677,6 +677,12 @@ Cannot use `$$restProps` in runes mode
 `let:` directive at invalid position
 ```
 
+### let_directive_snippet_conflict
+
+```
+Cannot use `let:` directives on a component that has a `children` snippet. Use snippet parameters instead (e.g. `{#snippet children({ %name% })}`)
+```
+
 ### mixed_event_handler_syntaxes
 
 ```
diff --git a/packages/svelte/messages/compile-errors/template.md b/packages/svelte/messages/compile-errors/template.md
index 6d1ae6ccbf..f71119169f 100644
--- a/packages/svelte/messages/compile-errors/template.md
+++ b/packages/svelte/messages/compile-errors/template.md
@@ -279,6 +279,10 @@ The same applies to components:
 
 > `let:` directive at invalid position
 
+## let_directive_snippet_conflict
+
+> Cannot use `let:` directives on a component that has a `children` snippet. Use snippet parameters instead (e.g. `{#snippet children({ %name% })}`)
+
 ## mixed_event_handler_syntaxes
 
 > Mixing old (on:%name%) and new syntaxes for event handling is not allowed. Use only the on%name% syntax
diff --git a/packages/svelte/src/compiler/errors.js b/packages/svelte/src/compiler/errors.js
index ccb7fe833e..f2be746ff6 100644
--- a/packages/svelte/src/compiler/errors.js
+++ b/packages/svelte/src/compiler/errors.js
@@ -1213,6 +1213,16 @@ export function let_directive_invalid_placement(node) {
 	e(node, 'let_directive_invalid_placement', `\`let:\` directive at invalid position\nhttps://svelte.dev/e/let_directive_invalid_placement`);
 }
 
+/**
+ * Cannot use `let:` directives on a component that has a `children` snippet. Use snippet parameters instead (e.g. `{#snippet children({ %name% })}`)
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function let_directive_snippet_conflict(node, name) {
+	e(node, 'let_directive_snippet_conflict', `Cannot use \`let:\` directives on a component that has a \`children\` snippet. Use snippet parameters instead (e.g. \`{#snippet children({ ${name} })}\`)\nhttps://svelte.dev/e/let_directive_snippet_conflict`);
+}
+
 /**
  * Mixing old (on:%name%) and new syntaxes for event handling is not allowed. Use only the on%name% syntax
  * @param {null | number | NodeLike} node
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/LetDirective.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/LetDirective.js
index e9a56ead0c..2eccac9d8a 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/LetDirective.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/LetDirective.js
@@ -1,6 +1,7 @@
 /** @import { AST } from '#compiler' */
 /** @import { Context } from '../types' */
 import * as e from '../../../errors.js';
+import { determine_slot } from '../../../utils/slot.js';
 
 /**
  * @param {AST.LetDirective} node
@@ -21,4 +22,25 @@ export function LetDirective(node, context) {
 	) {
 		e.let_directive_invalid_placement(node);
 	}
+
+	// an explicit `children` snippet replaces the default slot content, so the `let:`
+	// directive would never be provided. if the component has a `slot` attribute, the
+	// directive applies to the component itself instead, which is fine
+	if (
+		(parent.type === 'Component' ||
+			parent.type === 'SvelteComponent' ||
+			parent.type === 'SvelteSelf') &&
+		!determine_slot(parent) &&
+		parent.fragment.nodes.some(
+			(child) => child.type === 'SnippetBlock' && child.expression.name === 'children'
+		)
+	) {
+		const { expression } = node;
+		const pattern =
+			expression === null || (expression.type === 'Identifier' && expression.name === node.name)
+				? node.name
+				: `${node.name}: ${context.state.analysis.source.slice(expression.start, expression.end)}`;
+
+		e.let_directive_snippet_conflict(node, pattern);
+	}
 }
diff --git a/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet-expression/_config.js b/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet-expression/_config.js
new file mode 100644
index 0000000000..bf56000196
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet-expression/_config.js
@@ -0,0 +1,10 @@
+import { test } from '../../test';
+
+export default test({
+	error: {
+		code: 'let_directive_snippet_conflict',
+		message:
+			'Cannot use `let:` directives on a component that has a `children` snippet. Use snippet parameters instead (e.g. `{#snippet children({ item: x })}`)',
+		position: [62, 74]
+	}
+});
diff --git a/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet-expression/main.svelte b/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet-expression/main.svelte
new file mode 100644
index 0000000000..eddd5f2308
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet-expression/main.svelte
@@ -0,0 +1,7 @@
+<script>
+	import Child from './irrelevant';
+</script>
+
+<Child let:item={x}>
+	{#snippet children()}{x}{/snippet}
+</Child>
diff --git a/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet/_config.js b/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet/_config.js
new file mode 100644
index 0000000000..27b6a88667
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet/_config.js
@@ -0,0 +1,10 @@
+import { test } from '../../test';
+
+export default test({
+	error: {
+		code: 'let_directive_snippet_conflict',
+		message:
+			'Cannot use `let:` directives on a component that has a `children` snippet. Use snippet parameters instead (e.g. `{#snippet children({ value })}`)',
+		position: [359, 368]
+	}
+});
diff --git a/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet/main.svelte b/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet/main.svelte
new file mode 100644
index 0000000000..bdfe3de9b5
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/let-directive-children-snippet/main.svelte
@@ -0,0 +1,23 @@
+<script>
+	import Child from './irrelevant';
+	import Parent from './irrelevant';
+</script>
+
+<!-- ok -->
+<Child let:value>
+	{value}
+	{#snippet foo()}x{/snippet}
+</Child>
+<Child>
+	{#snippet children({ value })}{value}{/snippet}
+</Child>
+<Parent>
+	<Child slot="foo" let:value>
+		{#snippet children()}{value}{/snippet}
+	</Child>
+</Parent>
+
+<!-- invalid -->
+<Child let:value>
+	{#snippet children()}Value is: {value}{/snippet}
+</Child>

From f90853565966bc0bab57c99fe7d669a91bef0f4c Mon Sep 17 00:00:00 2001
From: "svelte-triage-bot[bot]"
 <316883489+svelte-triage-bot[bot]@users.noreply.github.com>
Date: Fri, 25 Sep 2026 23:41:51 +0200
Subject: [PATCH 07/14] fix: prevent untracked derived reads from retaining
 dependencies (#18829)

Fixes https://github.com/sveltejs/svelte/issues/18827.

A disconnected derived re-evaluated through `untrack` inside an effect
could connect descendant deriveds because `is_updating_effect` was true,
even though the active derived reader was not connected. Those
descendants registered on long-lived dependencies without gaining a
reaction that could later trigger their disconnect cascade.

This changes `get()` to connect a derived only when its active reader is
itself `CONNECTED`. Effects already carry that flag, and deriveds
reached through connected readers receive it before evaluation, so
tracked behavior remains intact. The now-unused `is_updating_effect`
state is removed.
---
 .changeset/calm-derived-connections.md        |  5 ++
 .../svelte/src/internal/client/runtime.js     | 13 +---
 packages/svelte/tests/signals/test.ts         | 60 ++++++++++++++++++-
 3 files changed, 65 insertions(+), 13 deletions(-)
 create mode 100644 .changeset/calm-derived-connections.md

diff --git a/.changeset/calm-derived-connections.md b/.changeset/calm-derived-connections.md
new file mode 100644
index 0000000000..4ce38365ff
--- /dev/null
+++ b/.changeset/calm-derived-connections.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: prevent untracked derived reads from retaining disconnected dependencies
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 76802974b7..31d6ebc9ae 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -60,11 +60,6 @@ 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';
 
-/**
- * True if updating in an effect context that is reactive (i.e. not branch/root effects)
- */
-let is_updating_effect = false;
-
 export let is_destroying_effect = false;
 
 /** @param {boolean} value */
@@ -462,10 +457,8 @@ export function update_effect(effect) {
 	set_signal_status(effect, CLEAN);
 
 	var previous_effect = active_effect;
-	var was_updating_effect = is_updating_effect;
 
 	active_effect = effect;
-	is_updating_effect = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) === 0; // Branch/root effects are not reactive contexts
 
 	if (DEV) {
 		var previous_component_fn = dev_current_component_function;
@@ -498,7 +491,6 @@ export function update_effect(effect) {
 			}
 		}
 	} finally {
-		is_updating_effect = was_updating_effect;
 		active_effect = previous_effect;
 
 		if (DEV) {
@@ -680,13 +672,12 @@ export function get(signal) {
 			return value;
 		}
 
-		// connect disconnected deriveds if we are reading them inside an effect,
-		// or inside another derived that is already connected
+		// connect disconnected deriveds when reading them inside a connected reaction
 		var should_connect =
 			(derived.f & CONNECTED) === 0 &&
 			!untracking &&
 			active_reaction !== null &&
-			(is_updating_effect || (active_reaction.f & CONNECTED) !== 0);
+			(active_reaction.f & CONNECTED) !== 0;
 
 		var is_new = (derived.f & REACTION_RAN) === 0;
 
diff --git a/packages/svelte/tests/signals/test.ts b/packages/svelte/tests/signals/test.ts
index 285dc1b3ce..afc866951f 100644
--- a/packages/svelte/tests/signals/test.ts
+++ b/packages/svelte/tests/signals/test.ts
@@ -15,7 +15,7 @@ import { proxy } from '../../src/internal/client/proxy';
 import { derived } from '../../src/internal/client/reactivity/deriveds';
 import { snapshot } from '../../src/internal/shared/clone.js';
 import { SvelteSet } from '../../src/reactivity/set';
-import { DESTROYED } from '../../src/internal/client/constants';
+import { CONNECTED, DESTROYED } from '../../src/internal/client/constants';
 import { noop } from 'svelte/internal/client';
 import { disable_async_mode_flag, enable_async_mode_flag } from '../../src/internal/flags';
 
@@ -1516,12 +1516,68 @@ describe('signals', () => {
 
 			destroy();
 
-			// a was spuriously added to s.reactions via is_updating_effect
+			// a was spuriously added to s.reactions
 			// even though the entire derived chain was read in an untracked context
 			assert.equal(s.reactions, null);
 		};
 	});
 
+	test('untracked derived reads inside effects do not reconnect disconnected dependencies', () => {
+		return () => {
+			const source = state({ n: 1, items: [1] });
+			const data = derived(() => $.get(source));
+			const items = derived(() => $.get(data).items);
+			const count = derived(() => Math.max(1, $.get(items).length));
+			const snapshot = derived(() => ({ n: $.get(data).n, count: $.get(count) }));
+			const show = state(true);
+			const trigger = state(0);
+			let rendered = -1;
+			let seen: { n: number; count: number } | undefined;
+
+			const destroy = effect_root(() => {
+				render_effect(() => {
+					if ($.get(show)) {
+						render_effect(() => {
+							rendered = $.get(snapshot).count;
+						});
+					}
+				});
+
+				render_effect(() => {
+					$.get(trigger);
+					seen = $.untrack(() => $.get(snapshot));
+				});
+			});
+
+			flushSync();
+			assert.equal(rendered, 1);
+
+			flushSync(() => set(show, false));
+			assert.equal(source.reactions, null);
+
+			flushSync(() => set(source, { n: 2, items: [1, 2] }));
+			flushSync(() => set(trigger, 1));
+
+			assert.deepEqual(seen, { n: 2, count: 2 });
+			assert.equal(source.reactions, null);
+			assert.equal(items.reactions, null);
+			assert.equal(count.reactions, null);
+			assert.equal(items.f & CONNECTED, 0);
+			assert.equal(count.f & CONNECTED, 0);
+
+			flushSync(() => set(show, true));
+			assert.equal(rendered, 2);
+			assert.equal(source.reactions?.length, 1);
+
+			flushSync(() => set(source, { n: 3, items: [1] }));
+			assert.equal(rendered, 1);
+
+			destroy();
+			flushSync();
+			assert.equal(source.reactions, null);
+		};
+	});
+
 	// https://github.com/sveltejs/svelte/issues/18414
 	test('a reaction that throws after first-reading a fresh derived does not leak it', () => {
 		const src = state(0);

From 7fb397e78f3c07908cb88ef894658d7433eb3938 Mon Sep 17 00:00:00 2001
From: "svelte-triage-bot[bot]"
 <316883489+svelte-triage-bot[bot]@users.noreply.github.com>
Date: Mon, 28 Sep 2026 14:32:59 +0200
Subject: [PATCH 08/14] fix: handle deferred transitions aborted before
 initialization (#18776)

- make deferred transition facade methods safe before the inner
animation initializes
- report the transition's initial position from the facade until
initialization
- add a runtime regression test for an out-only `crossfade` branch
restored in the same update

Fixes https://github.com/sveltejs/svelte/issues/18773

---------

Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>
---
 .changeset/tidy-ducks-reset.md                |  5 ++++
 .../client/dom/elements/transitions.js        |  6 ++---
 .../deferred-outro-restored/_config.js        | 13 ++++++++++
 .../deferred-outro-restored/main.svelte       | 24 +++++++++++++++++++
 4 files changed, 45 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/tidy-ducks-reset.md
 create mode 100644 packages/svelte/tests/runtime-runes/samples/deferred-outro-restored/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/deferred-outro-restored/main.svelte

diff --git a/.changeset/tidy-ducks-reset.md b/.changeset/tidy-ducks-reset.md
new file mode 100644
index 0000000000..41a00cf649
--- /dev/null
+++ b/.changeset/tidy-ducks-reset.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: handle deferred transitions aborted before initialization
diff --git a/packages/svelte/src/internal/client/dom/elements/transitions.js b/packages/svelte/src/internal/client/dom/elements/transitions.js
index 67b177841a..f6d36d86de 100644
--- a/packages/svelte/src/internal/client/dom/elements/transitions.js
+++ b/packages/svelte/src/internal/client/dom/elements/transitions.js
@@ -359,9 +359,9 @@ function animate(element, options, counterpart, t2, on_begin, on_finish) {
 				aborted = true;
 				a?.abort();
 			},
-			deactivate: () => a.deactivate(),
-			reset: () => a.reset(),
-			t: () => a.t()
+			deactivate: () => a?.deactivate(),
+			reset: () => a?.reset(),
+			t: () => a?.t() ?? 1 - t2
 		};
 	}
 
diff --git a/packages/svelte/tests/runtime-runes/samples/deferred-outro-restored/_config.js b/packages/svelte/tests/runtime-runes/samples/deferred-outro-restored/_config.js
new file mode 100644
index 0000000000..367da37815
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/deferred-outro-restored/_config.js
@@ -0,0 +1,13 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		const [button] = target.querySelectorAll('button');
+
+		button.click();
+		flushSync();
+
+		assert.htmlEqual(target.innerHTML, '<button>Reproduce</button><p>Deferred outro</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/deferred-outro-restored/main.svelte b/packages/svelte/tests/runtime-runes/samples/deferred-outro-restored/main.svelte
new file mode 100644
index 0000000000..396a8b2528
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/deferred-outro-restored/main.svelte
@@ -0,0 +1,24 @@
+<script>
+	import { crossfade } from 'svelte/transition';
+
+	let visible = $state(true);
+	let restore = $state(false);
+	const [send] = crossfade({});
+
+	$effect(() => {
+		if (restore) visible = true;
+	});
+</script>
+
+<button
+	onclick={() => {
+		visible = false;
+		restore = true;
+	}}
+>
+	Reproduce
+</button>
+
+{#if visible}
+	<p out:send={{ key: 'item' }}>Deferred outro</p>
+{/if}

From 7fe14a508adbfa85ba53e43b9e9c6700d6fde588 Mon Sep 17 00:00:00 2001
From: "svelte-triage-bot[bot]"
 <316883489+svelte-triage-bot[bot]@users.noreply.github.com>
Date: Mon, 28 Sep 2026 22:15:35 +0200
Subject: [PATCH 09/14] fix: ignore stale boundary resets after destruction
 (#18886)

- `destroy_effect` cleared a boundary's component context while retained
reset callbacks and queued error work could still re-enter its run path.
- Reset handling is intentionally shared with hydration by
[#18556](https://github.com/sveltejs/svelte/pull/18556), while `onerror`
is deferred for safe state mutation by
[#17561](https://github.com/sveltejs/svelte/pull/17561); neither path
checked the boundary lifetime.
- Make retained and deferred boundary continuations inert during
destruction instead of masking null contexts in `bind:this` or `#run`,
which would still let dead effects and callbacks restart.
- Cover resets from `onerror` and failed snippets, cleanup ordering,
delayed error transforms, DOM rendering, and hydration.

Fixes https://github.com/sveltejs/svelte/issues/18885
---
 .changeset/stale-boundary-reset.md            |  5 ++
 .../internal/client/dom/blocks/boundary.js    | 26 ++++++++--
 .../error-boundary-reset-destroyed/_config.js | 50 +++++++++++++++++++
 .../main.svelte                               | 47 +++++++++++++++++
 4 files changed, 125 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/stale-boundary-reset.md
 create mode 100644 packages/svelte/tests/runtime-runes/samples/error-boundary-reset-destroyed/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/error-boundary-reset-destroyed/main.svelte

diff --git a/.changeset/stale-boundary-reset.md b/.changeset/stale-boundary-reset.md
new file mode 100644
index 0000000000..1f158c5713
--- /dev/null
+++ b/.changeset/stale-boundary-reset.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: ignore stale boundary reset callbacks
diff --git a/packages/svelte/src/internal/client/dom/blocks/boundary.js b/packages/svelte/src/internal/client/dom/blocks/boundary.js
index 979d3e50b4..7ca0c47a81 100644
--- a/packages/svelte/src/internal/client/dom/blocks/boundary.js
+++ b/packages/svelte/src/internal/client/dom/blocks/boundary.js
@@ -1,5 +1,11 @@
 /** @import { Effect, Source, TemplateNode, } from '#client' */
-import { BOUNDARY_EFFECT, EFFECT_PRESERVED, EFFECT_TRANSPARENT } from '#client/constants';
+import {
+	BOUNDARY_EFFECT,
+	DESTROYED,
+	DESTROYING,
+	EFFECT_PRESERVED,
+	EFFECT_TRANSPARENT
+} from '#client/constants';
 import {
 	HYDRATION_ERROR,
 	HYDRATION_START_ELSE,
@@ -224,6 +230,8 @@ export class Boundary {
 		var calling_on_error = false;
 
 		const reset = () => {
+			if (this.#is_destroyed()) return;
+
 			if (did_reset) {
 				w.svelte_boundary_reset_noop();
 				return;
@@ -247,6 +255,8 @@ export class Boundary {
 		};
 
 		const invoke_onerror = () => {
+			if (this.#is_destroyed()) return;
+
 			try {
 				calling_on_error = true;
 				this.#props.onerror?.(error, reset);
@@ -259,6 +269,10 @@ export class Boundary {
 		return { reset, invoke_onerror };
 	}
 
+	#is_destroyed() {
+		return (this.#effect.f & (DESTROYED | DESTROYING)) !== 0;
+	}
+
 	#hydrate_pending_content() {
 		const pending = this.#props.pending;
 		if (!pending) return;
@@ -267,6 +281,8 @@ export class Boundary {
 		this.#pending_effect = branch(() => pending(this.#anchor));
 
 		queue_micro_task(() => {
+			if (this.#is_destroyed()) return;
+
 			var fragment = (this.#offscreen_fragment = document.createDocumentFragment());
 			var anchor = create_text();
 			var handled = false;
@@ -465,7 +481,7 @@ export class Boundary {
 			if (this.#failed_effect) current_batch.skip_effect(this.#failed_effect);
 
 			current_batch.oncommit(() => {
-				this.#handle_error(error);
+				if (!this.#is_destroyed()) this.#handle_error(error);
 			});
 		} else {
 			this.#handle_error(error);
@@ -501,11 +517,13 @@ export class Boundary {
 
 		/** @param {unknown} transformed_error */
 		const handle_error_result = (transformed_error) => {
+			if (this.#is_destroyed()) return;
+
 			const { reset, invoke_onerror } = this.#create_reset(transformed_error);
 
 			invoke_onerror();
 
-			if (failed) {
+			if (failed && !this.#is_destroyed()) {
 				this.#failed_effect = this.#run(() => {
 					try {
 						return branch(() => {
@@ -531,6 +549,8 @@ export class Boundary {
 		};
 
 		queue_micro_task(() => {
+			if (this.#is_destroyed()) return;
+
 			// Run the error through the API-level transformError transform (e.g. SvelteKit's handleError)
 			/** @type {unknown} */
 			var result;
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-reset-destroyed/_config.js b/packages/svelte/tests/runtime-runes/samples/error-boundary-reset-destroyed/_config.js
new file mode 100644
index 0000000000..01d57158bf
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-reset-destroyed/_config.js
@@ -0,0 +1,50 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+/** @type {Array<() => void>} */
+const resolvers = [];
+
+export default test({
+	transformError: (error) => new Promise((resolve) => resolvers.push(() => resolve(error))),
+
+	async test({ assert, target, logs }) {
+		const [error, toggle, reset, destroy] = target.querySelectorAll('button');
+		const paragraph = /** @type {HTMLParagraphElement} */ (target.querySelector('p'));
+
+		error.click();
+		await tick();
+		resolvers.shift()?.();
+		await tick();
+		assert.htmlEqual(paragraph.innerHTML, 'boom');
+
+		// A retained reset is inert after its boundary has been destroyed
+		toggle.click();
+		await tick();
+		reset.click();
+		await tick();
+		assert.htmlEqual(paragraph.innerHTML, 'boom');
+
+		// Resolving an error transform cannot resume a destroyed boundary
+		toggle.click();
+		await tick();
+		error.click();
+		await tick();
+		toggle.click();
+		await tick();
+		resolvers.shift()?.();
+		await tick();
+		assert.htmlEqual(paragraph.innerHTML, 'boom');
+
+		// A failed snippet's reset is also inert while the boundary is being destroyed
+		toggle.click();
+		await tick();
+		error.click();
+		await tick();
+		resolvers.shift()?.();
+		await tick();
+		destroy.click();
+		await tick();
+		assert.htmlEqual(paragraph.innerHTML, 'boom,boom');
+		assert.deepEqual(logs, ['render', 'render', 'render']);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-reset-destroyed/main.svelte b/packages/svelte/tests/runtime-runes/samples/error-boundary-reset-destroyed/main.svelte
new file mode 100644
index 0000000000..e8a1db83d8
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-reset-destroyed/main.svelte
@@ -0,0 +1,47 @@
+<script>
+	let show = $state(true);
+	let must_throw = $state(false);
+	let reset;
+	let element;
+	let errors = $state([]);
+	let reset_during_cleanup = false;
+
+	function throw_error() {
+		throw new Error('boom');
+	}
+
+	function toggle() {
+		must_throw = false;
+		show = !show;
+	}
+
+	function reset_on_cleanup(_, reset_boundary) {
+		return {
+			destroy() {
+				if (reset_during_cleanup) reset_boundary();
+			}
+		};
+	}
+
+	function track_render() {
+		console.log('render');
+	}
+</script>
+
+<button onclick={() => (must_throw = true)}>error</button>
+<button onclick={toggle}>toggle</button>
+<button onclick={() => reset()}>reset</button>
+<button onclick={() => { reset_during_cleanup = true; toggle(); }}>destroy</button>
+<p>{errors.join(',')}</p>
+
+{#if show}
+	<svelte:boundary onerror={(error, fn) => { errors.push(error.message); reset = fn; }}>
+		{track_render()}
+		<input bind:this={element} />
+		{must_throw ? throw_error() : ''}
+
+		{#snippet failed(_, failed_reset)}
+			<input bind:this={element} use:reset_on_cleanup={failed_reset} />
+		{/snippet}
+	</svelte:boundary>
+{/if}

From 688a4e49b8d82bb344d7ad5d635e97913d46e63a Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 28 Sep 2026 16:17:40 -0400
Subject: [PATCH 10/14] fix: preserve location information for `await` wrappers
 (#18859)

Helps with code coverage tools:
https://github.com/sveltejs/esrap/pull/124
---
 .changeset/major-roses-help.md                               | 5 +++++
 .../phases/3-transform/client/visitors/AwaitExpression.js    | 3 ++-
 2 files changed, 7 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/major-roses-help.md

diff --git a/.changeset/major-roses-help.md b/.changeset/major-roses-help.md
new file mode 100644
index 0000000000..c3c06792a4
--- /dev/null
+++ b/.changeset/major-roses-help.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: preserve location information for `await` wrappers
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/AwaitExpression.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/AwaitExpression.js
index 9fcc33287c..a3602bbce5 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/AwaitExpression.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/AwaitExpression.js
@@ -18,7 +18,8 @@ export function AwaitExpression(node, context) {
 	// in dev, note which values are read inside a reactive expression,
 	// but don't track them
 	else if (dev && !is_ignored(node, 'await_reactivity_loss')) {
-		return b.call(b.await(b.call('$.track_reactivity_loss', argument)));
+		// don't use b.await here, this way we preserve location information
+		return b.call({ ...node, argument: b.call('$.track_reactivity_loss', argument) });
 	}
 
 	return argument === node.argument ? node : { ...node, argument };

From 8ef693e94eddca38d92c62357efed877afd41ddf Mon Sep 17 00:00:00 2001
From: Nic Polumeyv <nicolas.polum@outlook.com>
Date: Mon, 28 Sep 2026 16:55:39 -0400
Subject: [PATCH 11/14] fix: don't hang `migrate` on a declaration that shares
 a line with its script tag (#18816)

`migrate()` never returned when a declaration shared a line with its
`<script>` tag:

```svelte
<script>export let answer</script>
```

The scan that removes a migrated `export let` line looked for a newline
in both directions with no bound. It now stops at the script's edges.
---
 .changeset/migrate-tag-line.md                              | 5 +++++
 packages/svelte/src/compiler/migrate/index.js               | 6 ++++--
 .../migrate/samples/props-on-script-tag-line/input.svelte   | 2 ++
 .../migrate/samples/props-on-script-tag-line/output.svelte  | 3 +++
 4 files changed, 14 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/migrate-tag-line.md
 create mode 100644 packages/svelte/tests/migrate/samples/props-on-script-tag-line/input.svelte
 create mode 100644 packages/svelte/tests/migrate/samples/props-on-script-tag-line/output.svelte

diff --git a/.changeset/migrate-tag-line.md b/.changeset/migrate-tag-line.md
new file mode 100644
index 0000000000..414e4a249c
--- /dev/null
+++ b/.changeset/migrate-tag-line.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: don't hang `migrate` on a declaration that shares a line with its script tag
diff --git a/packages/svelte/src/compiler/migrate/index.js b/packages/svelte/src/compiler/migrate/index.js
index 3baef3ecae..00f997e054 100644
--- a/packages/svelte/src/compiler/migrate/index.js
+++ b/packages/svelte/src/compiler/migrate/index.js
@@ -910,8 +910,10 @@ const instance_script = {
 				start = /** @type {number} */ (parent.start);
 				end = /** @type {number} */ (parent.end);
 			}
-			while (state.str.original[start] !== '\n') start--;
-			while (state.str.original[end] !== '\n') end++;
+			// remove the declaration's whole line, or what there is of it inside the script
+			const script = /** @type {{ start: number; end: number }} */ (state.analysis.instance.ast);
+			while (start > script.start && state.str.original[start] !== '\n') start--;
+			while (end < script.end && state.str.original[end] !== '\n') end++;
 			state.str.update(start, end, '');
 		}
 	},
diff --git a/packages/svelte/tests/migrate/samples/props-on-script-tag-line/input.svelte b/packages/svelte/tests/migrate/samples/props-on-script-tag-line/input.svelte
new file mode 100644
index 0000000000..dd623897bd
--- /dev/null
+++ b/packages/svelte/tests/migrate/samples/props-on-script-tag-line/input.svelte
@@ -0,0 +1,2 @@
+<script>export let answer</script>
+<p>{answer}</p>
diff --git a/packages/svelte/tests/migrate/samples/props-on-script-tag-line/output.svelte b/packages/svelte/tests/migrate/samples/props-on-script-tag-line/output.svelte
new file mode 100644
index 0000000000..add32531da
--- /dev/null
+++ b/packages/svelte/tests/migrate/samples/props-on-script-tag-line/output.svelte
@@ -0,0 +1,3 @@
+<script>
+	let { answer } = $props();</script>
+<p>{answer}</p>
\ No newline at end of file

From 5b44f26bc286ccbcd0602031e4a48fbdbb605dcd Mon Sep 17 00:00:00 2001
From: Nic Polumeyv <nicolas.polum@outlook.com>
Date: Mon, 28 Sep 2026 16:57:36 -0400
Subject: [PATCH 12/14] fix: keep a reactive assignment with no dependencies
 when `migrate` cannot turn it into a declaration (#18817)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`migrate()` dropped a reactive assignment that has no dependencies and
put nothing in its place:

```svelte
$: count = 7;          →  (gone, `{count}` now undeclared)
$: obj.x = 1;          →  (gone)
```

A binding the statement declares now always gets its `let`, and the
statement is only removed once every target has one; otherwise it
becomes `run()`:

```svelte
let count = $state(7);
run(() => { obj.x = 1; });
```
---
 .changeset/migrate-keep-assignment.md              |  5 +++++
 packages/svelte/src/compiler/migrate/index.js      | 13 +++++++++++--
 .../input.svelte                                   |  8 ++++++++
 .../output.svelte                                  | 14 ++++++++++++++
 4 files changed, 38 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/migrate-keep-assignment.md
 create mode 100644 packages/svelte/tests/migrate/samples/labeled-assignment-without-dependencies/input.svelte
 create mode 100644 packages/svelte/tests/migrate/samples/labeled-assignment-without-dependencies/output.svelte

diff --git a/.changeset/migrate-keep-assignment.md b/.changeset/migrate-keep-assignment.md
new file mode 100644
index 0000000000..6b5be9d6be
--- /dev/null
+++ b/.changeset/migrate-keep-assignment.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: keep a reactive assignment with no dependencies when `migrate` cannot turn it into a declaration
diff --git a/packages/svelte/src/compiler/migrate/index.js b/packages/svelte/src/compiler/migrate/index.js
index 00f997e054..68d5171237 100644
--- a/packages/svelte/src/compiler/migrate/index.js
+++ b/packages/svelte/src/compiler/migrate/index.js
@@ -989,8 +989,11 @@ const instance_script = {
 					return;
 				}
 
+				let declared = 0;
 				for (const binding of bindings) {
-					if (binding.reassigned && (ids.includes(binding.node) || expression_ids.length === 0)) {
+					// a binding this statement declares needs its `let` whether or not it is reassigned
+					if (ids.includes(binding.node) || (binding.reassigned && expression_ids.length === 0)) {
+						declared++;
 						check_rune_binding('state');
 						const init =
 							binding.kind === 'state'
@@ -1006,7 +1009,13 @@ const instance_script = {
 					}
 				}
 
-				if (expression_ids.length === 0 && bindings.every((b) => b.kind !== 'store_sub')) {
+				// the statement goes only once every target has a declaration standing in for it
+				if (
+					expression_ids.length === 0 &&
+					bindings.length > 0 &&
+					declared === bindings.length &&
+					bindings.every((b) => b.kind !== 'store_sub')
+				) {
 					state.str.remove(/** @type {number} */ (node.start), /** @type {number} */ (node.end));
 					return;
 				}
diff --git a/packages/svelte/tests/migrate/samples/labeled-assignment-without-dependencies/input.svelte b/packages/svelte/tests/migrate/samples/labeled-assignment-without-dependencies/input.svelte
new file mode 100644
index 0000000000..552dc3ff55
--- /dev/null
+++ b/packages/svelte/tests/migrate/samples/labeled-assignment-without-dependencies/input.svelte
@@ -0,0 +1,8 @@
+<script>
+	$: count = 7;
+	$: other = 8;
+	let obj = {};
+	$: obj.x = 1;
+</script>
+
+<p>{count} {other} {obj.x}</p>
diff --git a/packages/svelte/tests/migrate/samples/labeled-assignment-without-dependencies/output.svelte b/packages/svelte/tests/migrate/samples/labeled-assignment-without-dependencies/output.svelte
new file mode 100644
index 0000000000..b2ec179aec
--- /dev/null
+++ b/packages/svelte/tests/migrate/samples/labeled-assignment-without-dependencies/output.svelte
@@ -0,0 +1,14 @@
+<script>
+	import { run } from 'svelte/legacy';
+
+	let count = $state(7);
+	
+	let other = $state(8);
+	
+	let obj = $state({});
+	run(() => {
+		obj.x = 1;
+	});
+</script>
+
+<p>{count} {other} {obj.x}</p>
\ No newline at end of file

From 28b99aa8e66e50c80d1b7fd77502333a7e02bc72 Mon Sep 17 00:00:00 2001
From: Nic Polumeyv <nicolas.polum@outlook.com>
Date: Mon, 28 Sep 2026 17:05:21 -0400
Subject: [PATCH 13/14] fix: error at compile time when a declaration in a
 snippet redeclares one of its parameters (#18842)

`{const item = 1}` inside `{#snippet row(item)}` compiles, and the
output declares `item` twice in one function, so it does not parse:

```js
const row = ($$anchor, item = $.noop) => {
	const item = 1;
```

`{let}`, `{@const}` and a nested snippet with the parameter's name do
the same. In `phases/scope.js`, `EachBlock` visits its body's children
in the item's own scope, so a tag that reuses the item name is a
`declaration_duplicate`. `SnippetBlock` calls `context.next({ scope:
child_scope })`, the `Fragment` visitor opens another scope for the
body, and the tag never meets the parameter.

After visiting the body, `SnippetBlock` now reports any name in the
body's scope that `child_scope` also declares. A declaration in a nested
block or element still shadows the parameter.

---------

Co-authored-by: Simon Holthausen <simon.holthausen@vercel.com>
---
 .changeset/snippet-parameter-redeclared.md      |  5 +++++
 packages/svelte/src/compiler/phases/scope.js    |  8 ++++++++
 .../errors.json                                 | 14 ++++++++++++++
 .../input.svelte                                | 17 +++++++++++++++++
 4 files changed, 44 insertions(+)
 create mode 100644 .changeset/snippet-parameter-redeclared.md
 create mode 100644 packages/svelte/tests/validator/samples/declaration-tag-snippet-parameter/errors.json
 create mode 100644 packages/svelte/tests/validator/samples/declaration-tag-snippet-parameter/input.svelte

diff --git a/.changeset/snippet-parameter-redeclared.md b/.changeset/snippet-parameter-redeclared.md
new file mode 100644
index 0000000000..9bb14cf3af
--- /dev/null
+++ b/.changeset/snippet-parameter-redeclared.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: error at compile time when a declaration in a snippet redeclares one of its parameters
diff --git a/packages/svelte/src/compiler/phases/scope.js b/packages/svelte/src/compiler/phases/scope.js
index 77c9119364..0d8e570772 100644
--- a/packages/svelte/src/compiler/phases/scope.js
+++ b/packages/svelte/src/compiler/phases/scope.js
@@ -1343,6 +1343,14 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
 			}
 
 			context.next({ scope: child_scope });
+
+			// the parameters and what the body declares end up in the same function
+			const body_scope = /** @type {Scope} */ (scopes.get(node.body));
+			for (const [name, binding] of body_scope.declarations) {
+				if (child_scope.declarations.has(name)) {
+					e.declaration_duplicate(binding.node, name);
+				}
+			}
 		},
 
 		Fragment: (node, context) => {
diff --git a/packages/svelte/tests/validator/samples/declaration-tag-snippet-parameter/errors.json b/packages/svelte/tests/validator/samples/declaration-tag-snippet-parameter/errors.json
new file mode 100644
index 0000000000..45e51d5f01
--- /dev/null
+++ b/packages/svelte/tests/validator/samples/declaration-tag-snippet-parameter/errors.json
@@ -0,0 +1,14 @@
+[
+	{
+		"code": "declaration_duplicate",
+		"message": "`item` has already been declared",
+		"start": {
+			"line": 13,
+			"column": 8
+		},
+		"end": {
+			"line": 13,
+			"column": 12
+		}
+	}
+]
diff --git a/packages/svelte/tests/validator/samples/declaration-tag-snippet-parameter/input.svelte b/packages/svelte/tests/validator/samples/declaration-tag-snippet-parameter/input.svelte
new file mode 100644
index 0000000000..b59496dda1
--- /dev/null
+++ b/packages/svelte/tests/validator/samples/declaration-tag-snippet-parameter/input.svelte
@@ -0,0 +1,17 @@
+<!-- this is ok -->
+{#snippet row1(item)}
+{#if item}
+{const item = 1}
+<p>{item}</p>
+{/if}
+{/snippet}
+
+{@render row1(5)}
+
+<!-- this is not -->
+{#snippet row2(item)}
+	{const item = 1}
+	<p>{item}</p>
+{/snippet}
+
+{@render row2(5)}

From 020242d6bef059df9ae8c13dc8dbff4c9b31e0ff Mon Sep 17 00:00:00 2001
From: Minh Vu <vuhoangminh97@gmail.com>
Date: Mon, 28 Sep 2026 23:31:46 +0200
Subject: [PATCH 14/14] fix: ensure hydration state restoration for custom
 element attribute updates (#18467)

### Problem
While hydrating custom elements, set_attributes temporarily disables
global hydration state via set_hydrating(false) and restores it only at
the end. If a prop setter or attribute operation throws partway through,
hydration mode can remain disabled globally.

### Fix
Wrap the temporary hydration-state override in a try/finally block in
set_attributes so set_hydrating(true) always runs when
is_hydrating_custom_element is true.

---------

Co-authored-by: Simon Holthausen <simon.holthausen@vercel.com>
---
 ...hydration-custom-element-error-boundary.md |   5 +
 .../client/dom/elements/attributes.js         | 330 +++++++++---------
 .../_config.js                                |  11 +
 .../main.svelte                               |  22 ++
 4 files changed, 206 insertions(+), 162 deletions(-)
 create mode 100644 .changeset/hydration-custom-element-error-boundary.md
 create mode 100644 packages/svelte/tests/runtime-runes/samples/hydration-custom-element-error-boundary/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/hydration-custom-element-error-boundary/main.svelte

diff --git a/.changeset/hydration-custom-element-error-boundary.md b/.changeset/hydration-custom-element-error-boundary.md
new file mode 100644
index 0000000000..f94aa6265a
--- /dev/null
+++ b/.changeset/hydration-custom-element-error-boundary.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: restore hydration state when custom element attribute updates throw
diff --git a/packages/svelte/src/internal/client/dom/elements/attributes.js b/packages/svelte/src/internal/client/dom/elements/attributes.js
index 7d2dd62baf..982a405f98 100644
--- a/packages/svelte/src/internal/client/dom/elements/attributes.js
+++ b/packages/svelte/src/internal/client/dom/elements/attributes.js
@@ -298,196 +298,202 @@ function set_attributes(
 	var is_option_element = element.nodeName === OPTION_TAG;
 	var is_select_element = element.nodeName === SELECT_TAG;
 
-	for (var key in prev) {
-		// don't null our internal $$onX listeners
-		if (!(key in next) && key[0] + key[1] !== '$$') {
-			next[key] = null;
-		}
-	}
-
-	if (next.class) {
-		next.class = clsx(next.class);
-	} else if (css_hash || next[CLASS]) {
-		next.class = null; /* force call to set_class() */
-	}
-
-	if (next[STYLE]) {
-		next.style ??= null; /* force call to set_style() */
-	}
-
-	var setters = get_setters(element);
-
-	if (element.nodeName === INPUT_TAG && 'type' in next && ('value' in next || '__value' in next)) {
-		var type = next.type;
-
-		if (type !== current.type || (type === undefined && element.hasAttribute('type'))) {
-			current.type = type;
-			set_attribute(element, 'type', type, skip_warning);
+	try {
+		for (var key in prev) {
+			// don't null our internal $$onX listeners
+			if (!(key in next) && key[0] + key[1] !== '$$') {
+				next[key] = null;
+			}
 		}
-	}
 
-	// since key is captured we use const
-	for (const key in next) {
-		// let instead of var because referenced in a closure
-		let value = next[key];
-
-		// Up here because we want to do this for the initial value, too, even if it's undefined,
-		// and this wouldn't be reached in case of undefined because of the equality check below
-		if (is_option_element && key === 'value' && value == null) {
-			// The <option> element is a special case because removing the value attribute means
-			// the value is set to the text content of the option element, and setting the value
-			// to null or undefined means the value is set to the string "null" or "undefined".
-			// To align with how we handle this case in non-spread-scenarios, this logic is needed.
-			// There's a super-edge-case bug here that is left in in favor of smaller code size:
-			// Because of the "set missing props to null" logic above, we can't differentiate
-			// between a missing value and an explicitly set value of null or undefined. That means
-			// that once set, the value attribute of an <option> element can't be removed. This is
-			// a very rare edge case, and removing the attribute altogether isn't possible either
-			// for the <option value={undefined}> case, so we're not losing any functionality here.
-			// @ts-ignore
-			element.value = element.__value = '';
-			current[key] = value;
-			continue;
+		if (next.class) {
+			next.class = clsx(next.class);
+		} else if (css_hash || next[CLASS]) {
+			next.class = null; /* force call to set_class() */
 		}
 
-		if (key === 'class') {
-			var is_html = element.namespaceURI === 'http://www.w3.org/1999/xhtml';
-			set_class(element, is_html, value, css_hash, prev?.[CLASS], next[CLASS]);
-			current[key] = value;
-			current[CLASS] = next[CLASS];
-			continue;
+		if (next[STYLE]) {
+			next.style ??= null; /* force call to set_style() */
 		}
 
-		if (key === 'style') {
-			set_style(element, value, prev?.[STYLE], next[STYLE]);
-			current[key] = value;
-			current[STYLE] = next[STYLE];
-			continue;
-		}
+		var setters = get_setters(element);
 
-		var prev_value = current[key];
+		if (
+			element.nodeName === INPUT_TAG &&
+			'type' in next &&
+			('value' in next || '__value' in next)
+		) {
+			var type = next.type;
 
-		// Skip if value is unchanged, unless it's `undefined` and the element still has the attribute
-		if (value === prev_value && !(value === undefined && element.hasAttribute(key))) {
-			continue;
+			if (type !== current.type || (type === undefined && element.hasAttribute('type'))) {
+				current.type = type;
+				set_attribute(element, 'type', type, skip_warning);
+			}
 		}
 
-		current[key] = value;
-
-		var prefix = key[0] + key[1]; // this is faster than key.slice(0, 2)
-		if (prefix === '$$') continue;
+		// since key is captured we use const
+		for (const key in next) {
+			// let instead of var because referenced in a closure
+			let value = next[key];
+
+			// Up here because we want to do this for the initial value, too, even if it's undefined,
+			// and this wouldn't be reached in case of undefined because of the equality check below
+			if (is_option_element && key === 'value' && value == null) {
+				// The <option> element is a special case because removing the value attribute means
+				// the value is set to the text content of the option element, and setting the value
+				// to null or undefined means the value is set to the string "null" or "undefined".
+				// To align with how we handle this case in non-spread-scenarios, this logic is needed.
+				// There's a super-edge-case bug here that is left in in favor of smaller code size:
+				// Because of the "set missing props to null" logic above, we can't differentiate
+				// between a missing value and an explicitly set value of null or undefined. That means
+				// that once set, the value attribute of an <option> element can't be removed. This is
+				// a very rare edge case, and removing the attribute altogether isn't possible either
+				// for the <option value={undefined}> case, so we're not losing any functionality here.
+				// @ts-ignore
+				element.value = element.__value = '';
+				current[key] = value;
+				continue;
+			}
 
-		if (prefix === 'on') {
-			/** @type {{ capture?: true }} */
-			const opts = {};
-			const event_handle_key = '$$' + key;
-			let event_name = key.slice(2);
-			var is_delegated = can_delegate_event(event_name);
+			if (key === 'class') {
+				var is_html = element.namespaceURI === 'http://www.w3.org/1999/xhtml';
+				set_class(element, is_html, value, css_hash, prev?.[CLASS], next[CLASS]);
+				current[key] = value;
+				current[CLASS] = next[CLASS];
+				continue;
+			}
 
-			if (is_capture_event(event_name)) {
-				event_name = event_name.slice(0, -7);
-				opts.capture = true;
+			if (key === 'style') {
+				set_style(element, value, prev?.[STYLE], next[STYLE]);
+				current[key] = value;
+				current[STYLE] = next[STYLE];
+				continue;
 			}
 
-			if (!is_delegated && prev_value) {
-				// Listening to same event but different handler -> our handle function below takes care of this
-				// If we were to remove and add listeners in this case, it could happen that the event is "swallowed"
-				// (the browser seems to not know yet that a new one exists now) and doesn't reach the handler
-				// https://github.com/sveltejs/svelte/issues/11903
-				if (value != null) continue;
+			var prev_value = current[key];
 
-				element.removeEventListener(event_name, current[event_handle_key], opts);
-				current[event_handle_key] = null;
+			// Skip if value is unchanged, unless it's `undefined` and the element still has the attribute
+			if (value === prev_value && !(value === undefined && element.hasAttribute(key))) {
+				continue;
 			}
 
-			if (is_delegated) {
-				delegated(event_name, element, value);
-				delegate([event_name]);
-			} else if (value != null) {
-				/**
-				 * @this {any}
-				 * @param {Event} evt
-				 */
-				function handle(evt) {
-					current[key].call(this, evt);
+			current[key] = value;
+
+			var prefix = key[0] + key[1]; // this is faster than key.slice(0, 2)
+			if (prefix === '$$') continue;
+
+			if (prefix === 'on') {
+				/** @type {{ capture?: true }} */
+				const opts = {};
+				const event_handle_key = '$$' + key;
+				let event_name = key.slice(2);
+				var is_delegated = can_delegate_event(event_name);
+
+				if (is_capture_event(event_name)) {
+					event_name = event_name.slice(0, -7);
+					opts.capture = true;
 				}
 
-				current[event_handle_key] = create_event(event_name, element, handle, opts);
-			}
-		} else if (key === 'style') {
-			// avoid using the setter
-			set_attribute(element, key, value);
-		} else if (key === 'autofocus') {
-			autofocus(/** @type {HTMLElement} */ (element), Boolean(value));
-		} else if (!is_custom_element && (key === '__value' || (key === 'value' && value != null))) {
-			// @ts-ignore We're not running this for custom elements because __value is actually
-			// how Lit stores the current value on the element, and messing with that would break things.
-			element.__value = value;
-			// we don't set the value if it hasn't changed. This supports invalid number inputs like `1e` because
-			// 1. user types 1e
-			// 2. the state is updated reading e.target.value which is ''
-			// 3. the spreaded value is ''
-			// 4. updating input.value would thus, clear the user value
-			if (
-				prev_value == null ||
-				// @ts-ignore
-				element.value !== value ||
-				(value === 0 && element.nodeName === PROGRESS_TAG)
-			) {
-				// @ts-ignore
-				element.value = value;
-			}
-		} else if (key === 'selected' && is_option_element) {
-			set_selected(/** @type {HTMLOptionElement} */ (element), value);
-		} else {
-			var name = key;
-			if (!preserve_attribute_case) {
-				name = normalize_attribute(name);
-			}
+				if (!is_delegated && prev_value) {
+					// Listening to same event but different handler -> our handle function below takes care of this
+					// If we were to remove and add listeners in this case, it could happen that the event is "swallowed"
+					// (the browser seems to not know yet that a new one exists now) and doesn't reach the handler
+					// https://github.com/sveltejs/svelte/issues/11903
+					if (value != null) continue;
 
-			var is_default = name === 'defaultValue' || name === 'defaultChecked';
+					element.removeEventListener(event_name, current[event_handle_key], opts);
+					current[event_handle_key] = null;
+				}
 
-			// A select's default value is represented by selected options, not a property.
-			if (is_select_element && name === 'defaultValue') continue;
+				if (is_delegated) {
+					delegated(event_name, element, value);
+					delegate([event_name]);
+				} else if (value != null) {
+					/**
+					 * @this {any}
+					 * @param {Event} evt
+					 */
+					function handle(evt) {
+						current[key].call(this, evt);
+					}
 
-			if (value == null && !is_custom_element && !is_default) {
-				attributes[key] = null;
+					current[event_handle_key] = create_event(event_name, element, handle, opts);
+				}
+			} else if (key === 'style') {
+				// avoid using the setter
+				set_attribute(element, key, value);
+			} else if (key === 'autofocus') {
+				autofocus(/** @type {HTMLElement} */ (element), Boolean(value));
+			} else if (!is_custom_element && (key === '__value' || (key === 'value' && value != null))) {
+				// @ts-ignore We're not running this for custom elements because __value is actually
+				// how Lit stores the current value on the element, and messing with that would break things.
+				element.__value = value;
+				// we don't set the value if it hasn't changed. This supports invalid number inputs like `1e` because
+				// 1. user types 1e
+				// 2. the state is updated reading e.target.value which is ''
+				// 3. the spreaded value is ''
+				// 4. updating input.value would thus, clear the user value
+				if (
+					prev_value == null ||
+					// @ts-ignore
+					element.value !== value ||
+					(value === 0 && element.nodeName === PROGRESS_TAG)
+				) {
+					// @ts-ignore
+					element.value = value;
+				}
+			} else if (key === 'selected' && is_option_element) {
+				set_selected(/** @type {HTMLOptionElement} */ (element), value);
+			} else {
+				var name = key;
+				if (!preserve_attribute_case) {
+					name = normalize_attribute(name);
+				}
 
-				if (name === 'value' || name === 'checked') {
-					// removing value/checked also removes defaultValue/defaultChecked — preserve
-					let input = /** @type {HTMLInputElement} */ (element);
-					const use_default = prev === undefined;
-					if (name === 'value') {
-						let previous = input.defaultValue;
-						input.removeAttribute(name);
-						input.defaultValue = previous;
-						// @ts-ignore
-						input.value = input.__value = use_default ? previous : null;
+				var is_default = name === 'defaultValue' || name === 'defaultChecked';
+
+				// A select's default value is represented by selected options, not a property.
+				if (is_select_element && name === 'defaultValue') continue;
+
+				if (value == null && !is_custom_element && !is_default) {
+					attributes[key] = null;
+
+					if (name === 'value' || name === 'checked') {
+						// removing value/checked also removes defaultValue/defaultChecked — preserve
+						let input = /** @type {HTMLInputElement} */ (element);
+						const use_default = prev === undefined;
+						if (name === 'value') {
+							let previous = input.defaultValue;
+							input.removeAttribute(name);
+							input.defaultValue = previous;
+							// @ts-ignore
+							input.value = input.__value = use_default ? previous : null;
+						} else {
+							let previous = input.defaultChecked;
+							input.removeAttribute(name);
+							input.defaultChecked = previous;
+							input.checked = use_default ? previous : false;
+						}
 					} else {
-						let previous = input.defaultChecked;
-						input.removeAttribute(name);
-						input.defaultChecked = previous;
-						input.checked = use_default ? previous : false;
+						element.removeAttribute(key);
 					}
-				} else {
-					element.removeAttribute(key);
+				} else if (
+					is_default ||
+					((is_custom_element || typeof value !== 'string') && setters.has(name))
+				) {
+					// @ts-ignore
+					element[name] = value;
+					// remove it from attributes's cache
+					if (name in attributes) attributes[name] = UNINITIALIZED;
+				} else if (typeof value !== 'function') {
+					set_attribute(element, name, value, skip_warning);
 				}
-			} else if (
-				is_default ||
-				((is_custom_element || typeof value !== 'string') && setters.has(name))
-			) {
-				// @ts-ignore
-				element[name] = value;
-				// remove it from attributes's cache
-				if (name in attributes) attributes[name] = UNINITIALIZED;
-			} else if (typeof value !== 'function') {
-				set_attribute(element, name, value, skip_warning);
 			}
 		}
-	}
-
-	if (is_hydrating_custom_element) {
-		set_hydrating(true);
+	} finally {
+		if (is_hydrating_custom_element) {
+			set_hydrating(true);
+		}
 	}
 
 	return current;
diff --git a/packages/svelte/tests/runtime-runes/samples/hydration-custom-element-error-boundary/_config.js b/packages/svelte/tests/runtime-runes/samples/hydration-custom-element-error-boundary/_config.js
new file mode 100644
index 0000000000..dd20992c26
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/hydration-custom-element-error-boundary/_config.js
@@ -0,0 +1,11 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['hydrate'],
+
+	async test({ assert, target }) {
+		await tick();
+		assert.htmlEqual(target.innerHTML, '<p>failed: setter error</p><p>after</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/hydration-custom-element-error-boundary/main.svelte b/packages/svelte/tests/runtime-runes/samples/hydration-custom-element-error-boundary/main.svelte
new file mode 100644
index 0000000000..a47217d7a9
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/hydration-custom-element-error-boundary/main.svelte
@@ -0,0 +1,22 @@
+<script module>
+	if (!customElements.get('throwing-element')) {
+		customElements.define(
+			'throwing-element',
+			class extends HTMLElement {
+				set value(_) {
+					throw new Error('setter error');
+				}
+			}
+		);
+	}
+</script>
+
+<svelte:boundary>
+	<throwing-element {...{ value: 'boom' }}></throwing-element>
+
+	{#snippet failed(error)}
+		<p>failed: {error.message}</p>
+	{/snippet}
+</svelte:boundary>
+
+<p>after</p>