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 01/26] 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 02/26] 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 03/26] 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 04/26] 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 05/26] 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 06/26] 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 07/26] 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 08/26] 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 09/26] 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 10/26] 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 11/26] 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>

From 4c884722f86ac8f71d2dc1675151ff3cce9f3ce1 Mon Sep 17 00:00:00 2001
From: Paolo Ricciuti <ricciutipaolo@gmail.com>
Date: Sat, 3 Oct 2026 12:36:21 +0200
Subject: [PATCH 12/26] docs: fix mention of svelte config in best practices
 (#18917)

Closes https://github.com/sveltejs/ai-tools/issues/279
---
 documentation/docs/07-misc/01-best-practices.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/docs/07-misc/01-best-practices.md b/documentation/docs/07-misc/01-best-practices.md
index e2cb72828f..d6d0cfcadc 100644
--- a/documentation/docs/07-misc/01-best-practices.md
+++ b/documentation/docs/07-misc/01-best-practices.md
@@ -167,7 +167,7 @@ Use `createContext` rather than `setContext` and `getContext`, as it provides ty
 
 ## Async Svelte
 
-If using version 5.36 or higher, you can use [await expressions](await-expressions) and [hydratable](hydratable) to use promises directly inside components. Note that these require the `experimental.async` option to be enabled in `svelte.config.js` as they are not yet considered fully stable.
+If using version 5.36 or higher, you can use [await expressions](await-expressions) and [hydratable](hydratable) to use promises directly inside components. Note that these require the `experimental.async` option to be enabled in the plugin options in `vite.config.js` or in the `svelte.config.js` as they are not yet considered fully stable.
 
 ## Avoid legacy features
 

From 7c2fcdae6a29fb3b36855dc8e86eb7ce4c56b93a Mon Sep 17 00:00:00 2001
From: Paolo Ricciuti <ricciutipaolo@gmail.com>
Date: Sat, 3 Oct 2026 13:35:20 +0200
Subject: [PATCH 13/26] docs: add note about `#key` in best-practices (#18851)

We had this discussion with @teemingc about Astra using a key block as a
way to re-render the whole component, which is very inefficient.

When you think about it, a key block is actually almost never the right
solution unless you want, for example, to rerun the animations.

I propose to add this line here in the best practices skill/doc, which,
in my opinion, makes sense.

We should probably also add the same suggestions whenever we encounter a
key block in the MCP Auto Fixer. What do you think about it?

---------

Co-authored-by: Rich Harris <rich.harris@vercel.com>
---
 documentation/docs/07-misc/01-best-practices.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/documentation/docs/07-misc/01-best-practices.md b/documentation/docs/07-misc/01-best-practices.md
index d6d0cfcadc..ed7ddcbf7e 100644
--- a/documentation/docs/07-misc/01-best-practices.md
+++ b/documentation/docs/07-misc/01-best-practices.md
@@ -70,6 +70,10 @@ let color = type === 'danger' ? 'red' : 'green';
 
 `$inspect.trace` is a debugging tool for reactivity. If something is not updating properly or running more than it should you can add `$inspect.trace(label)` as the first line of an `$effect` or `$derived.by` (or any function they call) to trace their dependencies and discover which one triggered an update.
 
+## `#key` block
+
+While the `#key` block is useful when you want transitions/animations to run when a certain expression changes, it can be very expensive — it unmounts every element/component inside each time, so should be used sparingly. Instead of using `#key` to cause expressions in a child component's `<script>` block to re-run, for example, consider wrapping those expressions in `$derived`.
+
 ## Events
 
 Any element attribute starting with `on` is treated as an event listener:

From 7e83327400eeaa7e054935439792b696c282c1cf Mon Sep 17 00:00:00 2001
From: cui fliter <imcusg@gmail.com>
Date: Tue, 6 Oct 2026 13:22:22 +0800
Subject: [PATCH 14/26] fix: avoid tracking SvelteURLSearchParams during URL
 updates (#18791)

### 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:`.
- [ ] This message body should clearly illustrate what problems it
solves.
- [ ] Ideally, include a test that fails without this PR but passes with
it.
- [ ] 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`


---


Avoids creating an unintended reactive dependency when
`SvelteURLSearchParams` synchronizes its owning `SvelteURL`.

`#update_url()` now uses `super.toString()` instead of the reactive
`toString()` method. URL synchronization only needs native serialization
and should not subscribe the current reaction to the params version
signal.


Before this change, code such as:

```js
render_effect(() => {
	url.searchParams.set('foo', 'bar');
});
```


could cause the effect to run twice:

1. set() calls #update_url()
2. #update_url() calls reactive toString()
3. toString() subscribes the effect to #version
4. set() increments #version
5. The effect is scheduled again

Signed-off-by: cuishuang <imcusg@gmail.com>
---
 .changeset/fuzzy-urls-rest.md                  |  5 +++++
 .../svelte/src/reactivity/url-search-params.js |  2 +-
 packages/svelte/src/reactivity/url.test.ts     | 18 ++++++++++++++++++
 3 files changed, 24 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/fuzzy-urls-rest.md

diff --git a/.changeset/fuzzy-urls-rest.md b/.changeset/fuzzy-urls-rest.md
new file mode 100644
index 0000000000..c49215278e
--- /dev/null
+++ b/.changeset/fuzzy-urls-rest.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: avoid tracking SvelteURLSearchParams during URL updates
diff --git a/packages/svelte/src/reactivity/url-search-params.js b/packages/svelte/src/reactivity/url-search-params.js
index d745bb6b08..0b87820bfc 100644
--- a/packages/svelte/src/reactivity/url-search-params.js
+++ b/packages/svelte/src/reactivity/url-search-params.js
@@ -42,7 +42,7 @@ export class SvelteURLSearchParams extends URLSearchParams {
 		if (!this.#url || this.#updating) return;
 		this.#updating = true;
 
-		const search = this.toString();
+		const search = super.toString();
 		this.#url.search = search && `?${search}`;
 
 		this.#updating = false;
diff --git a/packages/svelte/src/reactivity/url.test.ts b/packages/svelte/src/reactivity/url.test.ts
index 72518d730a..4f597526be 100644
--- a/packages/svelte/src/reactivity/url.test.ts
+++ b/packages/svelte/src/reactivity/url.test.ts
@@ -115,6 +115,24 @@ test('url.searchParams', () => {
 	cleanup();
 });
 
+test('url.searchParams writes do not create a reactive dependency', () => {
+	const url = new SvelteURL('https://svelte.dev');
+	let runs = 0;
+
+	const cleanup = effect_root(() => {
+		render_effect(() => {
+			runs += 1;
+			url.searchParams.set('foo', 'bar');
+		});
+	});
+
+	flushSync();
+
+	assert.equal(runs, 1);
+
+	cleanup();
+});
+
 test('url.searchParams.set updates url when duplicate values collapse to the same joined string', () => {
 	const url = new SvelteURL('https://svelte.dev?a=ab&a=c');
 	const log: any = [];

From e5169f26c58cb9dbe49a8832e8e5639f915b686d Mon Sep 17 00:00:00 2001
From: Satvik Mishra <89024979+SatvikMishra08@users.noreply.github.com>
Date: Tue, 6 Oct 2026 14:04:26 +0530
Subject: [PATCH 15/26] docs: note that a pending snippet skips SSR of boundary
 content (#18922)

also remove an outdated note about needing a pending snippet for await

---------

Co-authored-by: Satvik Mishra <satvikmishra08@gmail.com>
Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>
---
 documentation/docs/05-special-elements/01-svelte-boundary.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/docs/05-special-elements/01-svelte-boundary.md b/documentation/docs/05-special-elements/01-svelte-boundary.md
index 41ebee1564..8af7edfbd1 100644
--- a/documentation/docs/05-special-elements/01-svelte-boundary.md
+++ b/documentation/docs/05-special-elements/01-svelte-boundary.md
@@ -38,7 +38,7 @@ This snippet will be shown when the boundary is first created, and will remain v
 
 The `pending` snippet will _not_ be shown for subsequent async updates — for these, you can use [`$effect.pending()`]($effect#$effect.pending).
 
-> [!NOTE] In the [playground](/playground), your app is rendered inside a boundary with an empty pending snippet, so that you can use `await` without having to create one.
+> [!NOTE] During server-side rendering, a boundary with a `pending` snippet renders that snippet and ignores the rest of its content. See [Server-side rendering](await-expressions#Server-side-rendering).
 
 
 ### `failed`

From 5cbdd34374379a40ade66bb7d528821c409b3fb1 Mon Sep 17 00:00:00 2001
From: nimbly1 <nimbly1@gmail.com>
Date: Tue, 6 Oct 2026 04:09:05 -0500
Subject: [PATCH 16/26] fix: recover when an unexpected node replaces a nested
 boundary comment (#18925)

Fixes #18924


---------

Co-authored-by: nimbly1 <258366730+nimbly1@users.noreply.github.com>
Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>
---
 .changeset/nested-boundary-hydrate.md              |  5 +++++
 .../src/internal/client/dom/blocks/boundary.js     | 11 +++++++----
 .../samples/boundary-nested-extra-node/_config.js  |  6 ++++++
 .../boundary-nested-extra-node/_expected.html      |  1 +
 .../boundary-nested-extra-node/_override.html      |  1 +
 .../samples/boundary-nested-extra-node/main.svelte | 14 ++++++++++++++
 6 files changed, 34 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/nested-boundary-hydrate.md
 create mode 100644 packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_config.js
 create mode 100644 packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_expected.html
 create mode 100644 packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_override.html
 create mode 100644 packages/svelte/tests/hydration/samples/boundary-nested-extra-node/main.svelte

diff --git a/.changeset/nested-boundary-hydrate.md b/.changeset/nested-boundary-hydrate.md
new file mode 100644
index 0000000000..dbbf545a5d
--- /dev/null
+++ b/.changeset/nested-boundary-hydrate.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: recover when an unexpected node replaces a nested boundary comment during hydration
diff --git a/packages/svelte/src/internal/client/dom/blocks/boundary.js b/packages/svelte/src/internal/client/dom/blocks/boundary.js
index 7ca0c47a81..88e8caae56 100644
--- a/packages/svelte/src/internal/client/dom/blocks/boundary.js
+++ b/packages/svelte/src/internal/client/dom/blocks/boundary.js
@@ -32,6 +32,7 @@ import {
 	hydrate_node,
 	hydrating,
 	next,
+	read_hydration_instruction,
 	skip_nodes,
 	set_hydrate_node
 } from '../hydration.js';
@@ -164,16 +165,18 @@ export class Boundary {
 
 		this.#effect = block(() => {
 			if (hydrating) {
-				const comment = /** @type {Comment} */ (this.#hydrate_open);
+				const comment_data = read_hydration_instruction(
+					/** @type {TemplateNode} */ (this.#hydrate_open)
+				);
 				hydrate_next();
 
-				const server_rendered_pending = comment.data === HYDRATION_START_ELSE;
-				const server_rendered_failed = comment.data.startsWith(HYDRATION_START_FAILED);
+				const server_rendered_pending = comment_data === HYDRATION_START_ELSE;
+				const server_rendered_failed = comment_data.startsWith(HYDRATION_START_FAILED);
 
 				if (server_rendered_failed) {
 					// Server rendered the failed snippet - hydrate it.
 					// The serialized error is embedded in the comment: <!--[?<json>-->
-					const serialized_error = JSON.parse(comment.data.slice(HYDRATION_START_FAILED.length));
+					const serialized_error = JSON.parse(comment_data.slice(HYDRATION_START_FAILED.length));
 					this.#hydrate_failed_content(serialized_error);
 				} else if (server_rendered_pending) {
 					this.#hydrate_pending_content();
diff --git a/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_config.js b/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_config.js
new file mode 100644
index 0000000000..d5b5a00c0d
--- /dev/null
+++ b/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_config.js
@@ -0,0 +1,6 @@
+import { test } from '../../test';
+
+// https://github.com/sveltejs/svelte/issues/18924
+export default test({
+	expect_hydration_error: true
+});
diff --git a/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_expected.html b/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_expected.html
new file mode 100644
index 0000000000..0d29b99446
--- /dev/null
+++ b/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_expected.html
@@ -0,0 +1 @@
+<div><p>inner</p></div>
diff --git a/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_override.html b/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_override.html
new file mode 100644
index 0000000000..e68995cf64
--- /dev/null
+++ b/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/_override.html
@@ -0,0 +1 @@
+<!--[--><!--[--><div><span></span><!--[--><p>inner</p><!--]--></div><!--]--><!--]-->
diff --git a/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/main.svelte b/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/main.svelte
new file mode 100644
index 0000000000..7cbf8a47fb
--- /dev/null
+++ b/packages/svelte/tests/hydration/samples/boundary-nested-extra-node/main.svelte
@@ -0,0 +1,14 @@
+<svelte:boundary>
+	<div>
+		<svelte:boundary>
+			<p>inner</p>
+			{#snippet failed()}
+				<p>inner failed</p>
+			{/snippet}
+		</svelte:boundary>
+	</div>
+
+	{#snippet failed()}
+		<p>outer failed</p>
+	{/snippet}
+</svelte:boundary>

From f3827053284672787a51d564de69d537c493daf6 Mon Sep 17 00:00:00 2001
From: Abhinav Prakash <60460989+AbhiPra24@users.noreply.github.com>
Date: Tue, 6 Oct 2026 14:48:21 +0530
Subject: [PATCH 17/26] docs: link svelte/transition module to transition
 directive (#18918)

---
 documentation/docs/98-reference/21-svelte-transition.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/documentation/docs/98-reference/21-svelte-transition.md b/documentation/docs/98-reference/21-svelte-transition.md
index e2ff6dbd0e..54134a91a1 100644
--- a/documentation/docs/98-reference/21-svelte-transition.md
+++ b/documentation/docs/98-reference/21-svelte-transition.md
@@ -3,4 +3,6 @@ title: svelte/transition
 tags: transitions
 ---
 
+This module provides built-in transition functions for use with the [`transition:`](transition) directive.
+
 > MODULE: svelte/transition

From 14136f88fc81b10611f46d475932b5dcbea96653 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fatih=20=C3=87ak=C4=B1r?=
 <108465492+wfatih@users.noreply.github.com>
Date: Tue, 6 Oct 2026 12:18:44 +0300
Subject: [PATCH 18/26] fix: print `{#await}` blocks that only have a pending
 branch (#18908)

---
 .changeset/print-await-pending-only.md                       | 5 +++++
 packages/svelte/src/compiler/print/index.js                  | 4 +++-
 packages/svelte/tests/print/samples/await-block/input.svelte | 4 ++++
 .../svelte/tests/print/samples/await-block/output.svelte     | 4 ++++
 4 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/print-await-pending-only.md

diff --git a/.changeset/print-await-pending-only.md b/.changeset/print-await-pending-only.md
new file mode 100644
index 0000000000..677dc73fc0
--- /dev/null
+++ b/.changeset/print-await-pending-only.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: print `{#await}` blocks that only have a pending branch
diff --git a/packages/svelte/src/compiler/print/index.js b/packages/svelte/src/compiler/print/index.js
index 554e788654..5696a68462 100644
--- a/packages/svelte/src/compiler/print/index.js
+++ b/packages/svelte/src/compiler/print/index.js
@@ -754,7 +754,9 @@ const svelte_visitors = (comments, state) => ({
 		if (node.pending) {
 			context.write('}');
 			block(context, node.pending, state.preserve_whitespace > 0);
-			context.write('{:');
+			if (node.then || node.catch) {
+				context.write('{:');
+			}
 		} else {
 			context.write(' ');
 		}
diff --git a/packages/svelte/tests/print/samples/await-block/input.svelte b/packages/svelte/tests/print/samples/await-block/input.svelte
index ba0ba8c882..029f31bf53 100644
--- a/packages/svelte/tests/print/samples/await-block/input.svelte
+++ b/packages/svelte/tests/print/samples/await-block/input.svelte
@@ -34,3 +34,7 @@
 {:catch}
 	<p>Something went wrong</p>
 {/await}
+
+{#await promise}
+	<p>waiting for the promise to resolve...</p>
+{/await}
diff --git a/packages/svelte/tests/print/samples/await-block/output.svelte b/packages/svelte/tests/print/samples/await-block/output.svelte
index ba0ba8c882..029f31bf53 100644
--- a/packages/svelte/tests/print/samples/await-block/output.svelte
+++ b/packages/svelte/tests/print/samples/await-block/output.svelte
@@ -34,3 +34,7 @@
 {:catch}
 	<p>Something went wrong</p>
 {/await}
+
+{#await promise}
+	<p>waiting for the promise to resolve...</p>
+{/await}

From 79a0c0d4d8faf305a1c1c536712139f569c9e431 Mon Sep 17 00:00:00 2001
From: jarrednorris <58517737+jarrednorrisdev@users.noreply.github.com>
Date: Tue, 6 Oct 2026 10:30:52 +0100
Subject: [PATCH 19/26] fix: attach event handlers that are assigned after a
 top-level `await` in production (#18933)

Fixes #18932
---
 .changeset/late-handlers-wait.md              |  5 +++++
 .../client/visitors/shared/events.js          |  5 +++--
 .../async-event-handler-blockers/_config.js   | 19 +++++++++++++++++++
 .../async-event-handler-blockers/main.svelte  | 19 +++++++++++++++++++
 4 files changed, 46 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/late-handlers-wait.md
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-event-handler-blockers/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-event-handler-blockers/main.svelte

diff --git a/.changeset/late-handlers-wait.md b/.changeset/late-handlers-wait.md
new file mode 100644
index 0000000000..306a950c43
--- /dev/null
+++ b/.changeset/late-handlers-wait.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: attach event handlers that are assigned after a top-level `await` in production
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/events.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/events.js
index f01bf08694..83c73a0279 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/events.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/events.js
@@ -119,8 +119,9 @@ export function build_event_handler(node, metadata, context) {
 
 		// local variable can be assigned directly
 		// except in dev mode where when need $.apply()
-		// in order to handle warnings.
-		if (!dev && binding?.declaration_kind !== 'import') {
+		// in order to handle warnings, or when it is
+		// assigned after a top-level `await`
+		if (!dev && binding?.declaration_kind !== 'import' && !binding?.blocker) {
 			return handler;
 		}
 	}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-event-handler-blockers/_config.js b/packages/svelte/tests/runtime-runes/samples/async-event-handler-blockers/_config.js
new file mode 100644
index 0000000000..f4dcbef823
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-event-handler-blockers/_config.js
@@ -0,0 +1,19 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['client', 'hydrate'],
+	async test({ assert, target, window, logs }) {
+		await new Promise((r) => setTimeout(r));
+		await tick();
+
+		const button = target.querySelector('button');
+		const div = target.querySelector('div');
+
+		button?.click();
+		div?.dispatchEvent(new window.MouseEvent('mouseenter'));
+		window.dispatchEvent(new window.Event('resize'));
+
+		assert.deepEqual(logs, ['click', 'mouseenter', 'resize']);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-event-handler-blockers/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-event-handler-blockers/main.svelte
new file mode 100644
index 0000000000..16bbac14a8
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-event-handler-blockers/main.svelte
@@ -0,0 +1,19 @@
+<script>
+	// Wait a macrotask to make sure the handlers aren't read before the microtask-Promise.resolve() resolves, masking a bug
+	await new Promise((r) => setTimeout(r));
+
+	function create_handler(name) {
+		return () => {
+			console.log(name);
+		};
+	}
+
+	const onclick = create_handler('click');
+	const onmouseenter = create_handler('mouseenter');
+	const onresize = create_handler('resize');
+</script>
+
+<svelte:window {onresize} />
+
+<button {onclick}>click</button>
+<div {onmouseenter}>hover</div>

From 179f66b297a1cfd943ad31dcd575587d629c412c Mon Sep 17 00:00:00 2001
From: jarrednorris <58517737+jarrednorrisdev@users.noreply.github.com>
Date: Tue, 6 Oct 2026 10:50:59 +0100
Subject: [PATCH 20/26] fix: don't create async deriveds for a component
 destroyed while waiting for its top-level `await` (#18931)

Fixes #18930

---------

Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>
---
 .changeset/brave-owls-wait.md                 |  5 +++
 .../src/internal/client/reactivity/async.js   |  5 +++
 .../Child.svelte                              |  7 +++++
 .../_config.js                                | 31 +++++++++++++++++++
 .../main.svelte                               | 20 ++++++++++++
 5 files changed, 68 insertions(+)
 create mode 100644 .changeset/brave-owls-wait.md
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/Child.svelte
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/main.svelte

diff --git a/.changeset/brave-owls-wait.md b/.changeset/brave-owls-wait.md
new file mode 100644
index 0000000000..827868b8c3
--- /dev/null
+++ b/.changeset/brave-owls-wait.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: don't create async deriveds for a component destroyed while waiting for its top-level `await`
diff --git a/packages/svelte/src/internal/client/reactivity/async.js b/packages/svelte/src/internal/client/reactivity/async.js
index a75f97a54f..efdfe6625c 100644
--- a/packages/svelte/src/internal/client/reactivity/async.js
+++ b/packages/svelte/src/internal/client/reactivity/async.js
@@ -103,6 +103,11 @@ export function flatten(blockers, sync, async, fn) {
 
 	if (blocker_promise) {
 		blocker_promise.then(() => {
+			if ((parent.f & DESTROYED) !== 0) {
+				decrement_pending();
+				return;
+			}
+
 			restore();
 			run();
 			unset_context();
diff --git a/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/Child.svelte
new file mode 100644
index 0000000000..63a16dde43
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/Child.svelte
@@ -0,0 +1,7 @@
+<script>
+	let { promise } = $props();
+
+	const value = await promise;
+</script>
+
+<p>{await Promise.resolve(value)}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/_config.js b/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/_config.js
new file mode 100644
index 0000000000..096f90e2df
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/_config.js
@@ -0,0 +1,31 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		const [hide, resolve] = target.querySelectorAll('button');
+
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+				<button>hide</button>
+				<button>resolve</button>
+				<p>loading...</p>
+			`
+		);
+
+		hide.click();
+		await tick();
+
+		resolve.click();
+		await tick();
+
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+				<button>hide</button>
+				<button>resolve</button>
+			`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/main.svelte
new file mode 100644
index 0000000000..3bc50e5d24
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-destroyed-before-blockers-settle/main.svelte
@@ -0,0 +1,20 @@
+<script>
+	import Child from './Child.svelte';
+
+	const deferred = Promise.withResolvers();
+
+	let show = $state(true);
+</script>
+
+<button onclick={() => (show = false)}>hide</button>
+<button onclick={() => deferred.resolve(1)}>resolve</button>
+
+<svelte:boundary>
+	{#if show}
+		<Child promise={deferred.promise} />
+	{/if}
+
+	{#snippet pending()}
+		<p>loading...</p>
+	{/snippet}
+</svelte:boundary>

From fe4fb460b1b0bb1373684541c7cbc107b582e789 Mon Sep 17 00:00:00 2001
From: Maksim Romanov <romanov.maxim.98@gmail.com>
Date: Tue, 6 Oct 2026 12:01:44 +0200
Subject: [PATCH 21/26] fix: error if `{:else}` is followed by another
 `{:else}` or `{:else if ...}` (#18900)

Fixes #18202
---
 .changeset/duplicate-else-clause.md                      | 5 +++++
 packages/svelte/src/compiler/phases/1-parse/state/tag.js | 2 ++
 .../samples/each-block-duplicate-else/_config.js         | 9 +++++++++
 .../samples/each-block-duplicate-else/main.svelte        | 7 +++++++
 .../samples/if-block-else-before-else-if/_config.js      | 9 +++++++++
 .../samples/if-block-else-before-else-if/main.svelte     | 7 +++++++
 6 files changed, 39 insertions(+)
 create mode 100644 .changeset/duplicate-else-clause.md
 create mode 100644 packages/svelte/tests/compiler-errors/samples/each-block-duplicate-else/_config.js
 create mode 100644 packages/svelte/tests/compiler-errors/samples/each-block-duplicate-else/main.svelte
 create mode 100644 packages/svelte/tests/compiler-errors/samples/if-block-else-before-else-if/_config.js
 create mode 100644 packages/svelte/tests/compiler-errors/samples/if-block-else-before-else-if/main.svelte

diff --git a/.changeset/duplicate-else-clause.md b/.changeset/duplicate-else-clause.md
new file mode 100644
index 0000000000..5b2ecbbbd5
--- /dev/null
+++ b/.changeset/duplicate-else-clause.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: error if `{:else}` is followed by another `{:else}` or `{:else if ...}`
diff --git a/packages/svelte/src/compiler/phases/1-parse/state/tag.js b/packages/svelte/src/compiler/phases/1-parse/state/tag.js
index 97095e993a..24b74699f6 100644
--- a/packages/svelte/src/compiler/phases/1-parse/state/tag.js
+++ b/packages/svelte/src/compiler/phases/1-parse/state/tag.js
@@ -532,6 +532,7 @@ function next(parser) {
 	if (block.type === 'IfBlock') {
 		if (!parser.eat('else')) e.expected_token(start, '{:else} or {:else if}');
 		if (parser.eat('if')) e.block_invalid_elseif(start);
+		if (block.alternate) e.block_duplicate_clause(start, '{:else}');
 
 		parser.allow_whitespace();
 
@@ -580,6 +581,7 @@ function next(parser) {
 
 	if (block.type === 'EachBlock') {
 		if (!parser.eat('else')) e.expected_token(start, '{:else}');
+		if (block.fallback) e.block_duplicate_clause(start, '{:else}');
 
 		parser.allow_whitespace();
 		parser.eat('}', true);
diff --git a/packages/svelte/tests/compiler-errors/samples/each-block-duplicate-else/_config.js b/packages/svelte/tests/compiler-errors/samples/each-block-duplicate-else/_config.js
new file mode 100644
index 0000000000..fe6bb3c006
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/each-block-duplicate-else/_config.js
@@ -0,0 +1,9 @@
+import { test } from '../../test';
+
+export default test({
+	error: {
+		code: 'block_duplicate_clause',
+		message: '{:else} cannot appear more than once within a block',
+		position: [42, 42]
+	}
+});
diff --git a/packages/svelte/tests/compiler-errors/samples/each-block-duplicate-else/main.svelte b/packages/svelte/tests/compiler-errors/samples/each-block-duplicate-else/main.svelte
new file mode 100644
index 0000000000..6f9a0d7c68
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/each-block-duplicate-else/main.svelte
@@ -0,0 +1,7 @@
+{#each items as item}
+	{item}
+{:else}
+	A
+{:else}
+	B
+{/each}
diff --git a/packages/svelte/tests/compiler-errors/samples/if-block-else-before-else-if/_config.js b/packages/svelte/tests/compiler-errors/samples/if-block-else-before-else-if/_config.js
new file mode 100644
index 0000000000..aec5973c83
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/if-block-else-before-else-if/_config.js
@@ -0,0 +1,9 @@
+import { test } from '../../test';
+
+export default test({
+	error: {
+		code: 'block_duplicate_clause',
+		message: '{:else} cannot appear more than once within a block',
+		position: [23, 23]
+	}
+});
diff --git a/packages/svelte/tests/compiler-errors/samples/if-block-else-before-else-if/main.svelte b/packages/svelte/tests/compiler-errors/samples/if-block-else-before-else-if/main.svelte
new file mode 100644
index 0000000000..5b1e5d559b
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/if-block-else-before-else-if/main.svelte
@@ -0,0 +1,7 @@
+{#if a}
+	A
+{:else}
+	B
+{:else if b}
+	C
+{/if}

From 3f885e30161bebd61939fb02065d539c76369398 Mon Sep 17 00:00:00 2001
From: 911RS <x20v20@gmail.com>
Date: Tue, 6 Oct 2026 12:57:31 +0100
Subject: [PATCH 22/26] fix: don't throw state_unsafe_mutation when the focused
 element is removed with bind:activeElement (#18921)

Fixes #15742

With `<svelte:document bind:activeElement />`, clicking a button that
removes itself throws `state_unsafe_mutation`. Removing the focused
element makes the browser fire `focusout` while the `{#if}` block effect
is running, and the binding's listener sets the state from inside that
effect.

`bind_active_element` now calls `update` inside
`without_reactive_context`, like event handlers created with
`create_event` and `bind_window_scroll` already do.
---
 .changeset/quiet-foxes-focus.md               |  5 ++++
 .../client/dom/elements/bindings/document.js  |  5 ++--
 .../_config.js                                | 27 +++++++++++++++++++
 .../main.svelte                               | 10 +++++++
 4 files changed, 45 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/quiet-foxes-focus.md
 create mode 100644 packages/svelte/tests/runtime-browser/samples/bind-active-element-remove-focused/_config.js
 create mode 100644 packages/svelte/tests/runtime-browser/samples/bind-active-element-remove-focused/main.svelte

diff --git a/.changeset/quiet-foxes-focus.md b/.changeset/quiet-foxes-focus.md
new file mode 100644
index 0000000000..283e88f525
--- /dev/null
+++ b/.changeset/quiet-foxes-focus.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: don't throw `state_unsafe_mutation` when the focused element is removed while `bind:activeElement` is used
diff --git a/packages/svelte/src/internal/client/dom/elements/bindings/document.js b/packages/svelte/src/internal/client/dom/elements/bindings/document.js
index 420e4359ed..8b238fc3cb 100644
--- a/packages/svelte/src/internal/client/dom/elements/bindings/document.js
+++ b/packages/svelte/src/internal/client/dom/elements/bindings/document.js
@@ -1,4 +1,4 @@
-import { listen } from './shared.js';
+import { listen, without_reactive_context } from './shared.js';
 
 /**
  * @param {(activeElement: Element | null) => void} update
@@ -12,6 +12,7 @@ export function bind_active_element(update) {
 			return;
 		}
 
-		update(document.activeElement);
+		// Removing the focused element fires `focusout` while an effect is running
+		without_reactive_context(() => update(document.activeElement));
 	});
 }
diff --git a/packages/svelte/tests/runtime-browser/samples/bind-active-element-remove-focused/_config.js b/packages/svelte/tests/runtime-browser/samples/bind-active-element-remove-focused/_config.js
new file mode 100644
index 0000000000..86a0f65551
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/bind-active-element-remove-focused/_config.js
@@ -0,0 +1,27 @@
+import { test, ok } from '../../assert';
+
+export default test({
+	mode: ['client'],
+	async test({ assert, target }) {
+		/** @type {string[]} */
+		const errors = [];
+		/** @param {ErrorEvent} event */
+		const on_error = (event) => {
+			errors.push(event.message);
+			event.preventDefault();
+		};
+		window.addEventListener('error', on_error);
+
+		const button = target.querySelector('button');
+		ok(button);
+
+		button.focus();
+		button.click();
+		await new Promise((r) => setTimeout(r, 0));
+
+		window.removeEventListener('error', on_error);
+
+		assert.equal(errors.length, 0, errors.join('\n'));
+		assert.equal(target.querySelector('button'), null);
+	}
+});
diff --git a/packages/svelte/tests/runtime-browser/samples/bind-active-element-remove-focused/main.svelte b/packages/svelte/tests/runtime-browser/samples/bind-active-element-remove-focused/main.svelte
new file mode 100644
index 0000000000..93e6e8f308
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/bind-active-element-remove-focused/main.svelte
@@ -0,0 +1,10 @@
+<script>
+	let activeElement = $state();
+	let show = $state(true);
+</script>
+
+<svelte:document bind:activeElement />
+
+{#if show}
+	<button onclick={() => (show = false)}>hide</button>
+{/if}

From c580b381f78ebf8d92bf04ca999bfc2b28516ead Mon Sep 17 00:00:00 2001
From: "svelte-triage-bot[bot]"
 <316883489+svelte-triage-bot[bot]@users.noreply.github.com>
Date: Tue, 6 Oct 2026 15:36:21 +0200
Subject: [PATCH 23/26] fix: prevent duplicate derived subscriptions on
 reconnect (#18899)

- A dirty disconnected derived registered newly reached dependencies
during evaluation, then `reconnect()` registered them again and retained
disposed graphs.
- The connection model from
[#17105](https://github.com/sveltejs/svelte/pull/17105) and reconnection
added in [#17362](https://github.com/sveltejs/svelte/pull/17362) restore
skipped old dependencies; recursive unfreezing from
[#17682](https://github.com/sveltejs/svelte/pull/17682) requires
preserving that lifecycle.
- Made reconnection idempotent instead of skipping or moving it,
preserving unchanged subscriptions and frozen-effect ordering.
- Covered direct and nested derived graphs, existing and newly reached
dependencies, and complete teardown across client rendering modes.

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


---------

Co-authored-by: svelte-triage-bot <team@svelte.com>
---
 .changeset/neat-derived-reconnections.md      |  5 ++
 .../svelte/src/internal/client/runtime.js     |  8 ++-
 packages/svelte/tests/signals/test.ts         | 69 +++++++++++++++++++
 3 files changed, 81 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/neat-derived-reconnections.md

diff --git a/.changeset/neat-derived-reconnections.md b/.changeset/neat-derived-reconnections.md
new file mode 100644
index 0000000000..fb6888de67
--- /dev/null
+++ b/.changeset/neat-derived-reconnections.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: prevent duplicate subscriptions when reconnecting deriveds
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 31d6ebc9ae..f09aaf34ee 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -719,7 +719,13 @@ function reconnect(derived) {
 	if (derived.deps === null) return;
 
 	for (const dep of derived.deps) {
-		(dep.reactions ??= []).push(derived);
+		var reactions = dep.reactions;
+
+		if (reactions === null) {
+			dep.reactions = [derived];
+		} else if (!includes.call(reactions, derived)) {
+			reactions.push(derived);
+		}
 
 		if ((dep.f & DERIVED) !== 0 && (dep.f & CONNECTED) === 0) {
 			unfreeze_derived_effects(/** @type {Derived} */ (dep));
diff --git a/packages/svelte/tests/signals/test.ts b/packages/svelte/tests/signals/test.ts
index afc866951f..2d2d653c03 100644
--- a/packages/svelte/tests/signals/test.ts
+++ b/packages/svelte/tests/signals/test.ts
@@ -1578,6 +1578,75 @@ describe('signals', () => {
 		};
 	});
 
+	test('reconnecting deriveds does not duplicate subscriptions', () => {
+		const enabled = state(false);
+		const shared = state(1);
+		let value!: Derived<number>;
+
+		const destroy_owner = effect_root(() => {
+			value = derived(() => ($.get(enabled) ? $.get(shared) : 0));
+			$.untrack(() => $.get(value));
+		});
+
+		const nested_enabled = state(false);
+		const nested_shared = state(1);
+		let inner!: Derived<number>;
+		let outer!: Derived<number>;
+
+		const destroy_nested_owner = effect_root(() => {
+			inner = derived(() => ($.get(nested_enabled) ? $.get(nested_shared) : 0));
+			outer = derived(() => $.get(inner));
+			$.untrack(() => $.get(outer));
+		});
+
+		return () => {
+			flushSync(() => set(enabled, true));
+			const destroy_reader = effect_root(() => {
+				render_effect(() => {
+					$.get(value);
+				});
+			});
+
+			const enabled_subscriptions = enabled.reactions?.length;
+			const shared_subscriptions = shared.reactions?.length;
+			const enabled_reaction = enabled.reactions?.[0];
+			const shared_reaction = shared.reactions?.[0];
+
+			destroy_reader();
+			destroy_owner();
+
+			assert.equal(enabled_subscriptions, 1);
+			assert.equal(shared_subscriptions, 1);
+			assert.equal(enabled_reaction, shared_reaction);
+			assert.equal(enabled.reactions, null);
+			assert.equal(shared.reactions, null);
+
+			flushSync(() => set(nested_enabled, true));
+			const destroy_nested_reader = effect_root(() => {
+				render_effect(() => {
+					$.get(outer);
+				});
+			});
+
+			const nested_enabled_subscriptions = nested_enabled.reactions?.length;
+			const nested_shared_subscriptions = nested_shared.reactions?.length;
+			const nested_enabled_reaction = nested_enabled.reactions?.[0] as Derived<number> | undefined;
+			const nested_shared_reaction = nested_shared.reactions?.[0];
+			const inner_subscriptions = nested_enabled_reaction?.reactions?.length;
+
+			destroy_nested_reader();
+			destroy_nested_owner();
+
+			assert.equal(nested_enabled_subscriptions, 1);
+			assert.equal(nested_shared_subscriptions, 1);
+			assert.equal(inner_subscriptions, 1);
+			assert.equal(nested_enabled_reaction, nested_shared_reaction);
+			assert.equal(nested_enabled.reactions, null);
+			assert.equal(nested_shared.reactions, null);
+			assert.equal(nested_enabled_reaction?.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 10fdca7d705081cae17bf7d609d46ee6eb237d17 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 6 Oct 2026 16:15:14 +0200
Subject: [PATCH 24/26] Version Packages (#18858)

This PR was opened by the [Changesets
release](https://github.com/changesets/action) GitHub action. When
you're ready to do a release, you can merge this and the packages will
be published to npm automatically. If you're not ready to do a release
yet, that's fine, whenever you add more changesets to main, this PR will
be updated.


# Releases
## svelte@5.57.2

### Patch Changes

- fix: don't create async deriveds for a component destroyed while
waiting for its top-level `await`
([#18931](https://github.com/sveltejs/svelte/pull/18931))

- fix: prevent untracked derived reads from retaining disconnected
dependencies ([#18829](https://github.com/sveltejs/svelte/pull/18829))

- fix: error if `{:else}` is followed by another `{:else}` or `{:else if
...}` ([#18900](https://github.com/sveltejs/svelte/pull/18900))

- fix: avoid tracking SvelteURLSearchParams during URL updates
([#18791](https://github.com/sveltejs/svelte/pull/18791))

- fix: restore hydration state when custom element attribute updates
throw ([#18467](https://github.com/sveltejs/svelte/pull/18467))

- fix: attach event handlers that are assigned after a top-level `await`
in production ([#18933](https://github.com/sveltejs/svelte/pull/18933))

- fix: flush anything pending before invoking flushSync callback
function ([#18878](https://github.com/sveltejs/svelte/pull/18878))

- fix: preserve location information for `await` wrappers
([#18859](https://github.com/sveltejs/svelte/pull/18859))

- fix: keep a reactive assignment with no dependencies when `migrate`
cannot turn it into a declaration
([#18817](https://github.com/sveltejs/svelte/pull/18817))

- fix: don't hang `migrate` on a declaration that shares a line with its
script tag ([#18816](https://github.com/sveltejs/svelte/pull/18816))

- fix: prevent duplicate subscriptions when reconnecting deriveds
([#18899](https://github.com/sveltejs/svelte/pull/18899))

- fix: recover when an unexpected node replaces a nested boundary
comment during hydration
([#18925](https://github.com/sveltejs/svelte/pull/18925))

- fix: print `{#await}` blocks that only have a pending branch
([#18908](https://github.com/sveltejs/svelte/pull/18908))

- fix: don't warn about a redundant `link` role on `<area>` elements
without an `href`
([#18872](https://github.com/sveltejs/svelte/pull/18872))

- fix: don't throw `state_unsafe_mutation` when the focused element is
removed while `bind:activeElement` is used
([#18921](https://github.com/sveltejs/svelte/pull/18921))

- fix: don't overwrite an unchanged spread `value`, preserving
incomplete number input
([#18864](https://github.com/sveltejs/svelte/pull/18864))

- fix: read batch-local array on each-block commit
([#18879](https://github.com/sveltejs/svelte/pull/18879))

- fix: error at compile time when a declaration in a snippet redeclares
one of its parameters
([#18842](https://github.com/sveltejs/svelte/pull/18842))

- fix: error when using `let:` directives on a component with a
`children` snippet
([#18873](https://github.com/sveltejs/svelte/pull/18873))

- fix: ignore stale boundary reset callbacks
([#18886](https://github.com/sveltejs/svelte/pull/18886))

- fix: handle deferred transitions aborted before initialization
([#18776](https://github.com/sveltejs/svelte/pull/18776))

- fix: prevent hydration mismatch recovery from being intercepted by
error boundaries
([#18841](https://github.com/sveltejs/svelte/pull/18841))

- fix: preserve dynamic element connections during hydration
([#18855](https://github.com/sveltejs/svelte/pull/18855))

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
---
 .changeset/brave-owls-wait.md                 |  5 --
 .changeset/calm-derived-connections.md        |  5 --
 .changeset/duplicate-else-clause.md           |  5 --
 .changeset/fuzzy-urls-rest.md                 |  5 --
 ...hydration-custom-element-error-boundary.md |  5 --
 .changeset/late-handlers-wait.md              |  5 --
 .changeset/major-papayas-run.md               |  5 --
 .changeset/major-roses-help.md                |  5 --
 .changeset/migrate-keep-assignment.md         |  5 --
 .changeset/migrate-tag-line.md                |  5 --
 .changeset/neat-derived-reconnections.md      |  5 --
 .changeset/nested-boundary-hydrate.md         |  5 --
 .changeset/print-await-pending-only.md        |  5 --
 .changeset/quiet-areas-link.md                |  5 --
 .changeset/quiet-foxes-focus.md               |  5 --
 .changeset/quiet-inputs-keep.md               |  5 --
 .changeset/short-radios-sneeze.md             |  5 --
 .changeset/snippet-parameter-redeclared.md    |  5 --
 .changeset/sour-lets-hide.md                  |  5 --
 .changeset/stale-boundary-reset.md            |  5 --
 .changeset/tidy-ducks-reset.md                |  5 --
 .changeset/tidy-pandas-hydrate.md             |  5 --
 .changeset/tidy-trees-stay.md                 |  5 --
 packages/svelte/CHANGELOG.md                  | 50 +++++++++++++++++++
 packages/svelte/package.json                  |  2 +-
 packages/svelte/src/version.js                |  2 +-
 26 files changed, 52 insertions(+), 117 deletions(-)
 delete mode 100644 .changeset/brave-owls-wait.md
 delete mode 100644 .changeset/calm-derived-connections.md
 delete mode 100644 .changeset/duplicate-else-clause.md
 delete mode 100644 .changeset/fuzzy-urls-rest.md
 delete mode 100644 .changeset/hydration-custom-element-error-boundary.md
 delete mode 100644 .changeset/late-handlers-wait.md
 delete mode 100644 .changeset/major-papayas-run.md
 delete mode 100644 .changeset/major-roses-help.md
 delete mode 100644 .changeset/migrate-keep-assignment.md
 delete mode 100644 .changeset/migrate-tag-line.md
 delete mode 100644 .changeset/neat-derived-reconnections.md
 delete mode 100644 .changeset/nested-boundary-hydrate.md
 delete mode 100644 .changeset/print-await-pending-only.md
 delete mode 100644 .changeset/quiet-areas-link.md
 delete mode 100644 .changeset/quiet-foxes-focus.md
 delete mode 100644 .changeset/quiet-inputs-keep.md
 delete mode 100644 .changeset/short-radios-sneeze.md
 delete mode 100644 .changeset/snippet-parameter-redeclared.md
 delete mode 100644 .changeset/sour-lets-hide.md
 delete mode 100644 .changeset/stale-boundary-reset.md
 delete mode 100644 .changeset/tidy-ducks-reset.md
 delete mode 100644 .changeset/tidy-pandas-hydrate.md
 delete mode 100644 .changeset/tidy-trees-stay.md

diff --git a/.changeset/brave-owls-wait.md b/.changeset/brave-owls-wait.md
deleted file mode 100644
index 827868b8c3..0000000000
--- a/.changeset/brave-owls-wait.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: don't create async deriveds for a component destroyed while waiting for its top-level `await`
diff --git a/.changeset/calm-derived-connections.md b/.changeset/calm-derived-connections.md
deleted file mode 100644
index 4ce38365ff..0000000000
--- a/.changeset/calm-derived-connections.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: prevent untracked derived reads from retaining disconnected dependencies
diff --git a/.changeset/duplicate-else-clause.md b/.changeset/duplicate-else-clause.md
deleted file mode 100644
index 5b2ecbbbd5..0000000000
--- a/.changeset/duplicate-else-clause.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: error if `{:else}` is followed by another `{:else}` or `{:else if ...}`
diff --git a/.changeset/fuzzy-urls-rest.md b/.changeset/fuzzy-urls-rest.md
deleted file mode 100644
index c49215278e..0000000000
--- a/.changeset/fuzzy-urls-rest.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: avoid tracking SvelteURLSearchParams during URL updates
diff --git a/.changeset/hydration-custom-element-error-boundary.md b/.changeset/hydration-custom-element-error-boundary.md
deleted file mode 100644
index f94aa6265a..0000000000
--- a/.changeset/hydration-custom-element-error-boundary.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: restore hydration state when custom element attribute updates throw
diff --git a/.changeset/late-handlers-wait.md b/.changeset/late-handlers-wait.md
deleted file mode 100644
index 306a950c43..0000000000
--- a/.changeset/late-handlers-wait.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: attach event handlers that are assigned after a top-level `await` in production
diff --git a/.changeset/major-papayas-run.md b/.changeset/major-papayas-run.md
deleted file mode 100644
index 59909fb448..0000000000
--- a/.changeset/major-papayas-run.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: flush anything pending before invoking flushSync callback function
diff --git a/.changeset/major-roses-help.md b/.changeset/major-roses-help.md
deleted file mode 100644
index c3c06792a4..0000000000
--- a/.changeset/major-roses-help.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: preserve location information for `await` wrappers
diff --git a/.changeset/migrate-keep-assignment.md b/.changeset/migrate-keep-assignment.md
deleted file mode 100644
index 6b5be9d6be..0000000000
--- a/.changeset/migrate-keep-assignment.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: keep a reactive assignment with no dependencies when `migrate` cannot turn it into a declaration
diff --git a/.changeset/migrate-tag-line.md b/.changeset/migrate-tag-line.md
deleted file mode 100644
index 414e4a249c..0000000000
--- a/.changeset/migrate-tag-line.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: don't hang `migrate` on a declaration that shares a line with its script tag
diff --git a/.changeset/neat-derived-reconnections.md b/.changeset/neat-derived-reconnections.md
deleted file mode 100644
index fb6888de67..0000000000
--- a/.changeset/neat-derived-reconnections.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: prevent duplicate subscriptions when reconnecting deriveds
diff --git a/.changeset/nested-boundary-hydrate.md b/.changeset/nested-boundary-hydrate.md
deleted file mode 100644
index dbbf545a5d..0000000000
--- a/.changeset/nested-boundary-hydrate.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: recover when an unexpected node replaces a nested boundary comment during hydration
diff --git a/.changeset/print-await-pending-only.md b/.changeset/print-await-pending-only.md
deleted file mode 100644
index 677dc73fc0..0000000000
--- a/.changeset/print-await-pending-only.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: print `{#await}` blocks that only have a pending branch
diff --git a/.changeset/quiet-areas-link.md b/.changeset/quiet-areas-link.md
deleted file mode 100644
index af4e31f3cb..0000000000
--- a/.changeset/quiet-areas-link.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: don't warn about a redundant `link` role on `<area>` elements without an `href`
diff --git a/.changeset/quiet-foxes-focus.md b/.changeset/quiet-foxes-focus.md
deleted file mode 100644
index 283e88f525..0000000000
--- a/.changeset/quiet-foxes-focus.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: don't throw `state_unsafe_mutation` when the focused element is removed while `bind:activeElement` is used
diff --git a/.changeset/quiet-inputs-keep.md b/.changeset/quiet-inputs-keep.md
deleted file mode 100644
index 0efcfcc058..0000000000
--- a/.changeset/quiet-inputs-keep.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: don't overwrite an unchanged spread `value`, preserving incomplete number input
diff --git a/.changeset/short-radios-sneeze.md b/.changeset/short-radios-sneeze.md
deleted file mode 100644
index 847c3eef17..0000000000
--- a/.changeset/short-radios-sneeze.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: read batch-local array on each-block commit
diff --git a/.changeset/snippet-parameter-redeclared.md b/.changeset/snippet-parameter-redeclared.md
deleted file mode 100644
index 9bb14cf3af..0000000000
--- a/.changeset/snippet-parameter-redeclared.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: error at compile time when a declaration in a snippet redeclares one of its parameters
diff --git a/.changeset/sour-lets-hide.md b/.changeset/sour-lets-hide.md
deleted file mode 100644
index 6175027cff..0000000000
--- a/.changeset/sour-lets-hide.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: error when using `let:` directives on a component with a `children` snippet
diff --git a/.changeset/stale-boundary-reset.md b/.changeset/stale-boundary-reset.md
deleted file mode 100644
index 1f158c5713..0000000000
--- a/.changeset/stale-boundary-reset.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: ignore stale boundary reset callbacks
diff --git a/.changeset/tidy-ducks-reset.md b/.changeset/tidy-ducks-reset.md
deleted file mode 100644
index 41a00cf649..0000000000
--- a/.changeset/tidy-ducks-reset.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: handle deferred transitions aborted before initialization
diff --git a/.changeset/tidy-pandas-hydrate.md b/.changeset/tidy-pandas-hydrate.md
deleted file mode 100644
index 944797a760..0000000000
--- a/.changeset/tidy-pandas-hydrate.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: prevent hydration mismatch recovery from being intercepted by error boundaries
diff --git a/.changeset/tidy-trees-stay.md b/.changeset/tidy-trees-stay.md
deleted file mode 100644
index 65bf7de619..0000000000
--- a/.changeset/tidy-trees-stay.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-'svelte': patch
----
-
-fix: preserve dynamic element connections during hydration
diff --git a/packages/svelte/CHANGELOG.md b/packages/svelte/CHANGELOG.md
index 75592eba84..77a6cbbd6b 100644
--- a/packages/svelte/CHANGELOG.md
+++ b/packages/svelte/CHANGELOG.md
@@ -1,5 +1,55 @@
 # svelte
 
+## 5.57.2
+
+### Patch Changes
+
+- fix: don't create async deriveds for a component destroyed while waiting for its top-level `await` ([#18931](https://github.com/sveltejs/svelte/pull/18931))
+
+- fix: prevent untracked derived reads from retaining disconnected dependencies ([#18829](https://github.com/sveltejs/svelte/pull/18829))
+
+- fix: error if `{:else}` is followed by another `{:else}` or `{:else if ...}` ([#18900](https://github.com/sveltejs/svelte/pull/18900))
+
+- fix: avoid tracking SvelteURLSearchParams during URL updates ([#18791](https://github.com/sveltejs/svelte/pull/18791))
+
+- fix: restore hydration state when custom element attribute updates throw ([#18467](https://github.com/sveltejs/svelte/pull/18467))
+
+- fix: attach event handlers that are assigned after a top-level `await` in production ([#18933](https://github.com/sveltejs/svelte/pull/18933))
+
+- fix: flush anything pending before invoking flushSync callback function ([#18878](https://github.com/sveltejs/svelte/pull/18878))
+
+- fix: preserve location information for `await` wrappers ([#18859](https://github.com/sveltejs/svelte/pull/18859))
+
+- fix: keep a reactive assignment with no dependencies when `migrate` cannot turn it into a declaration ([#18817](https://github.com/sveltejs/svelte/pull/18817))
+
+- fix: don't hang `migrate` on a declaration that shares a line with its script tag ([#18816](https://github.com/sveltejs/svelte/pull/18816))
+
+- fix: prevent duplicate subscriptions when reconnecting deriveds ([#18899](https://github.com/sveltejs/svelte/pull/18899))
+
+- fix: recover when an unexpected node replaces a nested boundary comment during hydration ([#18925](https://github.com/sveltejs/svelte/pull/18925))
+
+- fix: print `{#await}` blocks that only have a pending branch ([#18908](https://github.com/sveltejs/svelte/pull/18908))
+
+- fix: don't warn about a redundant `link` role on `<area>` elements without an `href` ([#18872](https://github.com/sveltejs/svelte/pull/18872))
+
+- fix: don't throw `state_unsafe_mutation` when the focused element is removed while `bind:activeElement` is used ([#18921](https://github.com/sveltejs/svelte/pull/18921))
+
+- fix: don't overwrite an unchanged spread `value`, preserving incomplete number input ([#18864](https://github.com/sveltejs/svelte/pull/18864))
+
+- fix: read batch-local array on each-block commit ([#18879](https://github.com/sveltejs/svelte/pull/18879))
+
+- fix: error at compile time when a declaration in a snippet redeclares one of its parameters ([#18842](https://github.com/sveltejs/svelte/pull/18842))
+
+- fix: error when using `let:` directives on a component with a `children` snippet ([#18873](https://github.com/sveltejs/svelte/pull/18873))
+
+- fix: ignore stale boundary reset callbacks ([#18886](https://github.com/sveltejs/svelte/pull/18886))
+
+- fix: handle deferred transitions aborted before initialization ([#18776](https://github.com/sveltejs/svelte/pull/18776))
+
+- fix: prevent hydration mismatch recovery from being intercepted by error boundaries ([#18841](https://github.com/sveltejs/svelte/pull/18841))
+
+- fix: preserve dynamic element connections during hydration ([#18855](https://github.com/sveltejs/svelte/pull/18855))
+
 ## 5.57.1
 
 ### Patch Changes
diff --git a/packages/svelte/package.json b/packages/svelte/package.json
index 6404eb0596..7b66c0c3fe 100644
--- a/packages/svelte/package.json
+++ b/packages/svelte/package.json
@@ -2,7 +2,7 @@
   "name": "svelte",
   "description": "Cybernetically enhanced web apps",
   "license": "MIT",
-  "version": "5.57.1",
+  "version": "5.57.2",
   "type": "module",
   "types": "./types/index.d.ts",
   "engines": {
diff --git a/packages/svelte/src/version.js b/packages/svelte/src/version.js
index d925d3eb2e..80c49e17ac 100644
--- a/packages/svelte/src/version.js
+++ b/packages/svelte/src/version.js
@@ -4,5 +4,5 @@
  * The current version, as set in package.json.
  * @type {string}
  */
-export const VERSION = '5.57.1';
+export const VERSION = '5.57.2';
 export const PUBLIC_VERSION = '5';

From c85120fb9fb4ff500bef189368f31b680421c4ba Mon Sep 17 00:00:00 2001
From: "svelte-triage-bot[bot]"
 <316883489+svelte-triage-bot[bot]@users.noreply.github.com>
Date: Wed, 7 Oct 2026 11:44:42 +0200
Subject: [PATCH 25/26] fix: track missing proxy keys in unowned deriveds
 (#18944)

Co-authored-by: svelte-triage-bot <team@svelte.com>
---
 .../reactive-missing-property-checks.md       |  5 +++
 packages/svelte/src/internal/client/proxy.js  |  3 +-
 packages/svelte/tests/signals/test.ts         | 40 +++++++++++++++++++
 3 files changed, 46 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/reactive-missing-property-checks.md

diff --git a/.changeset/reactive-missing-property-checks.md b/.changeset/reactive-missing-property-checks.md
new file mode 100644
index 0000000000..c4b5f7105c
--- /dev/null
+++ b/.changeset/reactive-missing-property-checks.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: track missing state property checks in unowned deriveds
diff --git a/packages/svelte/src/internal/client/proxy.js b/packages/svelte/src/internal/client/proxy.js
index d7e8c98896..db58459fd9 100644
--- a/packages/svelte/src/internal/client/proxy.js
+++ b/packages/svelte/src/internal/client/proxy.js
@@ -2,7 +2,6 @@
 import { DEV } from 'esm-env';
 import {
 	get,
-	active_effect,
 	update_version,
 	active_reaction,
 	set_update_version,
@@ -241,7 +240,7 @@ export function proxy(value) {
 
 			if (
 				s !== undefined ||
-				(active_effect !== null && (!has || get_descriptor(target, prop)?.writable))
+				(active_reaction !== null && (!has || get_descriptor(target, prop)?.writable))
 			) {
 				if (s === undefined) {
 					s = with_parent(() => {
diff --git a/packages/svelte/tests/signals/test.ts b/packages/svelte/tests/signals/test.ts
index 2d2d653c03..b83e75a767 100644
--- a/packages/svelte/tests/signals/test.ts
+++ b/packages/svelte/tests/signals/test.ts
@@ -153,6 +153,46 @@ describe('signals', () => {
 		};
 	});
 
+	test('unowned deriveds track missing property checks on proxies', () => {
+		const value = proxy<Record<string, boolean>>({});
+
+		return () => {
+			const has_x = derived(() => 'x' in value);
+			const owns_y = derived(() => Object.hasOwn(value, 'y'));
+
+			assert.isFalse($.get(has_x));
+			assert.isFalse($.get(owns_y));
+
+			value.x = true;
+			value.y = true;
+
+			assert.isTrue($.get(has_x));
+			assert.isTrue($.get(owns_y));
+
+			delete value.x;
+			delete value.y;
+
+			assert.isFalse($.get(has_x));
+			assert.isFalse($.get(owns_y));
+		};
+	});
+
+	test('unowned deriveds track missing array indexes', () => {
+		const value = proxy<boolean[]>([]);
+
+		return () => {
+			const has_first = derived(() => 0 in value);
+
+			assert.isFalse($.get(has_first));
+
+			value.push(true);
+			assert.isTrue($.get(has_first));
+
+			value.length = 0;
+			assert.isFalse($.get(has_first));
+		};
+	});
+
 	test('derived from state', () => {
 		const log: number[] = [];
 

From 707c28146b0f0a6d5404a1bd4769874c3c24851a Mon Sep 17 00:00:00 2001
From: Serghei <xyrolle@gmail.com>
Date: Wed, 7 Oct 2026 17:50:37 +0300
Subject: [PATCH 26/26] fix: keep creating state sources for property checks
 during component init (#18949)

---
 .changeset/keep-has-check-sources.md          |  5 ++
 packages/svelte/src/internal/client/proxy.js  |  4 +-
 .../_config.js                                | 18 +++++++
 .../main.svelte                               | 49 +++++++++++++++++++
 4 files changed, 75 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/keep-has-check-sources.md
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-fork-discard-after-in-check/_config.js
 create mode 100644 packages/svelte/tests/runtime-runes/samples/async-fork-discard-after-in-check/main.svelte

diff --git a/.changeset/keep-has-check-sources.md b/.changeset/keep-has-check-sources.md
new file mode 100644
index 0000000000..2ba811c4e8
--- /dev/null
+++ b/.changeset/keep-has-check-sources.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: keep creating state sources for property checks during component init
diff --git a/packages/svelte/src/internal/client/proxy.js b/packages/svelte/src/internal/client/proxy.js
index db58459fd9..08233472dd 100644
--- a/packages/svelte/src/internal/client/proxy.js
+++ b/packages/svelte/src/internal/client/proxy.js
@@ -2,6 +2,7 @@
 import { DEV } from 'esm-env';
 import {
 	get,
+	active_effect,
 	update_version,
 	active_reaction,
 	set_update_version,
@@ -240,7 +241,8 @@ export function proxy(value) {
 
 			if (
 				s !== undefined ||
-				(active_reaction !== null && (!has || get_descriptor(target, prop)?.writable))
+				((active_effect !== null || active_reaction !== null) &&
+					(!has || get_descriptor(target, prop)?.writable))
 			) {
 				if (s === undefined) {
 					s = with_parent(() => {
diff --git a/packages/svelte/tests/runtime-runes/samples/async-fork-discard-after-in-check/_config.js b/packages/svelte/tests/runtime-runes/samples/async-fork-discard-after-in-check/_config.js
new file mode 100644
index 0000000000..cf3cd1b1a3
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-fork-discard-after-in-check/_config.js
@@ -0,0 +1,18 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target, logs }) {
+		await tick();
+
+		const [rerun, discard] = target.querySelectorAll('button');
+
+		rerun.click();
+		await tick();
+
+		discard.click();
+		await tick();
+
+		assert.deepEqual(logs, [1, false, 1, 1, 1]);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-fork-discard-after-in-check/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-fork-discard-after-in-check/main.svelte
new file mode 100644
index 0000000000..95e0bf09f4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-fork-discard-after-in-check/main.svelte
@@ -0,0 +1,49 @@
+<script>
+	import { fork } from 'svelte';
+
+	const init = $state({ x: 1 });
+	const init_missing = $state({});
+	const root = $state({ x: 1 });
+	const teardown = $state({ x: 1 });
+	const after_await = $state({ x: 1 });
+
+	let count = $state(0);
+
+	// each object is first checked with `in` while an effect is active but no reaction is
+	'x' in init;
+	'y' in init_missing;
+
+	$effect.root(() => {
+		'x' in root;
+	});
+
+	$effect(() => {
+		count;
+
+		return () => {
+			'x' in teardown;
+		};
+	});
+
+	await Promise.resolve();
+
+	'x' in after_await;
+</script>
+
+<button onclick={() => count++}>rerun</button>
+
+<button
+	onclick={() => {
+		fork(() => {
+			init.x = 2;
+			init_missing.y = 1;
+			root.x = 2;
+			teardown.x = 2;
+			after_await.x = 2;
+		}).discard();
+
+		console.log(init.x, 'y' in init_missing, root.x, teardown.x, after_await.x);
+	}}
+>
+	discard
+</button>