diff --git a/.changeset/async-store-sub-blocker.md b/.changeset/async-store-sub-blocker.md
new file mode 100644
index 0000000000..0222dac846
--- /dev/null
+++ b/.changeset/async-store-sub-blocker.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: block template store subscriptions on the promise that assigns the store
diff --git a/.changeset/boundary-teardown-error-routing.md b/.changeset/boundary-teardown-error-routing.md
new file mode 100644
index 0000000000..0b2249bf22
--- /dev/null
+++ b/.changeset/boundary-teardown-error-routing.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: route $derived teardown errors through invoke_error_boundary
diff --git a/.changeset/calm-dates-track.md b/.changeset/calm-dates-track.md
new file mode 100644
index 0000000000..e7275ae556
--- /dev/null
+++ b/.changeset/calm-dates-track.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: track SvelteDate snapshots in reactions
diff --git a/.changeset/clean-head-anchors.md b/.changeset/clean-head-anchors.md
new file mode 100644
index 0000000000..d58283f502
--- /dev/null
+++ b/.changeset/clean-head-anchors.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: remove `<svelte:head>` anchors on unmount
diff --git a/.changeset/config.json b/.changeset/config.json
index b56077a922..785aa01e70 100644
--- a/.changeset/config.json
+++ b/.changeset/config.json
@@ -1,6 +1,6 @@
 {
 	"$schema": "https://unpkg.com/@changesets/config@2.3.0/schema.json",
-	"changelog": ["@svitejs/changesets-changelog-github-compact", { "repo": "sveltejs/svelte" }],
+	"changelog": ["@changesets/changelog-github", { "repo": "sveltejs/svelte", "template": "\n- {summary} {ref}" }],
 	"commit": false,
 	"fixed": [],
 	"linked": [],
diff --git a/.changeset/cool-spoons-tap.md b/.changeset/cool-spoons-tap.md
new file mode 100644
index 0000000000..461db03a81
--- /dev/null
+++ b/.changeset/cool-spoons-tap.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: warn on undeclared shorthand event handlers on `<svelte:window>`, `<svelte:document>` and `<svelte:body>`
diff --git a/.changeset/eighty-moons-happen.md b/.changeset/eighty-moons-happen.md
new file mode 100644
index 0000000000..94fb3d313d
--- /dev/null
+++ b/.changeset/eighty-moons-happen.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+perf: reuse the cached value in the `<option>`/`<select>` value guard
diff --git a/.changeset/every-rabbits-rule.md b/.changeset/every-rabbits-rule.md
new file mode 100644
index 0000000000..e78df191a5
--- /dev/null
+++ b/.changeset/every-rabbits-rule.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: prevent malformed AST output for `<select>` with static `value` attribute
diff --git a/.changeset/fix-binding-ownership-ignore.md b/.changeset/fix-binding-ownership-ignore.md
new file mode 100644
index 0000000000..13c9c797e3
--- /dev/null
+++ b/.changeset/fix-binding-ownership-ignore.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: apply ownership mutation ignores to binding assignments
diff --git a/.changeset/fix-hmr-onoutroend-double-fire.md b/.changeset/fix-hmr-onoutroend-double-fire.md
new file mode 100644
index 0000000000..0eafbfa731
--- /dev/null
+++ b/.changeset/fix-hmr-onoutroend-double-fire.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: prevent onoutroend from firing twice when compilerOptions.hmr is true
diff --git a/.changeset/gentle-spaces-print.md b/.changeset/gentle-spaces-print.md
new file mode 100644
index 0000000000..70b337fcd7
--- /dev/null
+++ b/.changeset/gentle-spaces-print.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: preserve whitespace after inline elements when printing
diff --git a/.changeset/gold-moons-shave.md b/.changeset/gold-moons-shave.md
new file mode 100644
index 0000000000..9ee98321b7
--- /dev/null
+++ b/.changeset/gold-moons-shave.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+perf: fold SSR block-open markers into the branch's first push
diff --git a/.changeset/great-hoops-tickle.md b/.changeset/great-hoops-tickle.md
new file mode 100644
index 0000000000..94b32588f1
--- /dev/null
+++ b/.changeset/great-hoops-tickle.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: run `onDestroy` callbacks when a server render throws
diff --git a/.changeset/heavy-pumas-report.md b/.changeset/heavy-pumas-report.md
new file mode 100644
index 0000000000..71a9422828
--- /dev/null
+++ b/.changeset/heavy-pumas-report.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: report `derived_invalid_export` for `export let x = $derived(...)` in runes mode
diff --git a/.changeset/hungry-plums-roll.md b/.changeset/hungry-plums-roll.md
new file mode 100644
index 0000000000..b5e3688eb5
--- /dev/null
+++ b/.changeset/hungry-plums-roll.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: never apply class hash to elements inside `<svelte:head>`
diff --git a/.changeset/keep-radio-default-checked.md b/.changeset/keep-radio-default-checked.md
new file mode 100644
index 0000000000..b3b32afda6
--- /dev/null
+++ b/.changeset/keep-radio-default-checked.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: keep `defaultChecked` on hydrated radio inputs with spread attributes
diff --git a/.changeset/large-schools-smell.md b/.changeset/large-schools-smell.md
new file mode 100644
index 0000000000..61ef571f02
--- /dev/null
+++ b/.changeset/large-schools-smell.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: accept `onfocusin`/`onfocusout` in `a11y_mouse_events_have_key_events`
diff --git a/.changeset/legacy-reactive-map-lookups.md b/.changeset/legacy-reactive-map-lookups.md
new file mode 100644
index 0000000000..ec6f4fbf9d
--- /dev/null
+++ b/.changeset/legacy-reactive-map-lookups.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+perf: O(n²)→O(n) Map lookups for legacy `$:` reactive statement ordering
diff --git a/.changeset/lemon-bikes-marry.md b/.changeset/lemon-bikes-marry.md
new file mode 100644
index 0000000000..6b1c431a30
--- /dev/null
+++ b/.changeset/lemon-bikes-marry.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: distinct memoizer on style/class directives
diff --git a/.changeset/moody-lamps-slide.md b/.changeset/moody-lamps-slide.md
new file mode 100644
index 0000000000..5832f12e42
--- /dev/null
+++ b/.changeset/moody-lamps-slide.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: measure nested transitions before applying their starting styles
diff --git a/.changeset/olive-crabs-refuse.md b/.changeset/olive-crabs-refuse.md
new file mode 100644
index 0000000000..a928ae7f19
--- /dev/null
+++ b/.changeset/olive-crabs-refuse.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: don't turn component instances stored in `$state` into state proxies
diff --git a/.changeset/olive-jars-repeat.md b/.changeset/olive-jars-repeat.md
new file mode 100644
index 0000000000..815b5adf71
--- /dev/null
+++ b/.changeset/olive-jars-repeat.md
@@ -0,0 +1,5 @@
+---
+'svelte': minor
+---
+
+feat: export `RenderOutput`, `SyncRenderOutput`, `Csp` and `Sha256Source` from `svelte/server`
diff --git a/.changeset/olive-pugs-shake.md b/.changeset/olive-pugs-shake.md
new file mode 100644
index 0000000000..abd0db2152
--- /dev/null
+++ b/.changeset/olive-pugs-shake.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+perf: emit `$.only_child` for elements with a single child
diff --git a/.changeset/open-parents-stare.md b/.changeset/open-parents-stare.md
new file mode 100644
index 0000000000..cb94267ea0
--- /dev/null
+++ b/.changeset/open-parents-stare.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: more robust rendering of Svelte custom element slots
diff --git a/.changeset/optimize-const-tag.md b/.changeset/optimize-const-tag.md
new file mode 100644
index 0000000000..90c6a6b5d2
--- /dev/null
+++ b/.changeset/optimize-const-tag.md
@@ -0,0 +1,5 @@
+---
+"svelte": patch
+---
+
+perf: optimize simple object destructuring in `@const` tags
diff --git a/.changeset/quiet-context-segment.md b/.changeset/quiet-context-segment.md
new file mode 100644
index 0000000000..7af36f8ed3
--- /dev/null
+++ b/.changeset/quiet-context-segment.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: end a restored reaction context at the end of its synchronous segment
diff --git a/.changeset/quiet-deriveds-unwind.md b/.changeset/quiet-deriveds-unwind.md
new file mode 100644
index 0000000000..8036bdb781
--- /dev/null
+++ b/.changeset/quiet-deriveds-unwind.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: keep the dependencies of a reaction that throws, so deriveds it read are neither leaked nor stuck in their error
diff --git a/.changeset/quiet-falcons-search.md b/.changeset/quiet-falcons-search.md
new file mode 100644
index 0000000000..8c5c4dedca
--- /dev/null
+++ b/.changeset/quiet-falcons-search.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: don't resurrect outroing elements when an ancestor block is paused and resumed
diff --git a/.changeset/quiet-swans-invent.md b/.changeset/quiet-swans-invent.md
new file mode 100644
index 0000000000..3b35a933d5
--- /dev/null
+++ b/.changeset/quiet-swans-invent.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+perf: use `$.comment()` for single-comment templates
diff --git a/.changeset/setters-cache-set.md b/.changeset/setters-cache-set.md
new file mode 100644
index 0000000000..2013446bc5
--- /dev/null
+++ b/.changeset/setters-cache-set.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+perf: store setters cache as `Set` instead of `Array`
diff --git a/.changeset/slow-dots-smile.md b/.changeset/slow-dots-smile.md
new file mode 100644
index 0000000000..18d2517b6c
--- /dev/null
+++ b/.changeset/slow-dots-smile.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: transform derived assignments and select function bindings correctly during server-side rendering
diff --git a/.changeset/svelte-url-protocol-port.md b/.changeset/svelte-url-protocol-port.md
new file mode 100644
index 0000000000..2c37fce4ab
--- /dev/null
+++ b/.changeset/svelte-url-protocol-port.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: sync `SvelteURL` port signal when the protocol setter clears the port
diff --git a/.changeset/tall-hounds-tap.md b/.changeset/tall-hounds-tap.md
new file mode 100644
index 0000000000..3a9f7d79cb
--- /dev/null
+++ b/.changeset/tall-hounds-tap.md
@@ -0,0 +1,5 @@
+---
+'svelte': minor
+---
+
+feat: support `defaultValue` on `<select>`
diff --git a/.changeset/thick-plums-wave.md b/.changeset/thick-plums-wave.md
new file mode 100644
index 0000000000..d8b454bb90
--- /dev/null
+++ b/.changeset/thick-plums-wave.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: block declaration tags and `{@const}` on async values read inside closures
diff --git a/.changeset/three-peas-smoke.md b/.changeset/three-peas-smoke.md
new file mode 100644
index 0000000000..9a151c0046
--- /dev/null
+++ b/.changeset/three-peas-smoke.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: avoid css tree-shaking for exported Snippet
diff --git a/.changeset/tidy-owls-repeat.md b/.changeset/tidy-owls-repeat.md
new file mode 100644
index 0000000000..2ef02e2051
--- /dev/null
+++ b/.changeset/tidy-owls-repeat.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+perf: treat `<img loading>` as a static element again
diff --git a/.changeset/tidy-pandas-refuse.md b/.changeset/tidy-pandas-refuse.md
new file mode 100644
index 0000000000..7034a3e267
--- /dev/null
+++ b/.changeset/tidy-pandas-refuse.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: prevent `selectedcontent` mutation from changing the selected option
diff --git a/.changeset/tough-pandas-shout.md b/.changeset/tough-pandas-shout.md
new file mode 100644
index 0000000000..b0f6ea64fd
--- /dev/null
+++ b/.changeset/tough-pandas-shout.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: avoid `NaN` keyframe values in `slide` transition for elements without a layout box
diff --git a/.changeset/tricky-donkeys-clap.md b/.changeset/tricky-donkeys-clap.md
new file mode 100644
index 0000000000..b363b4ff57
--- /dev/null
+++ b/.changeset/tricky-donkeys-clap.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: preserve line feed character references in attribute values
diff --git a/.changeset/uppercase-hex-entities.md b/.changeset/uppercase-hex-entities.md
new file mode 100644
index 0000000000..e6e13d5df5
--- /dev/null
+++ b/.changeset/uppercase-hex-entities.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: decode uppercase-`X` hex numeric character references (`&#X...;`)
diff --git a/.changeset/witty-donuts-explain.md b/.changeset/witty-donuts-explain.md
new file mode 100644
index 0000000000..6ee8f66da6
--- /dev/null
+++ b/.changeset/witty-donuts-explain.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+chore: clarify when `$effect.pre` runs relative to DOM updates
diff --git a/.changeset/young-papers-hide.md b/.changeset/young-papers-hide.md
new file mode 100644
index 0000000000..7df1f114b9
--- /dev/null
+++ b/.changeset/young-papers-hide.md
@@ -0,0 +1,5 @@
+---
+'svelte': patch
+---
+
+fix: scope SSR boundary failed snippets to their boundary
diff --git a/.github/workflows/autofix.yml b/.github/workflows/autofix.yml
index b6c26e0792..5cdbd34e5b 100644
--- a/.github/workflows/autofix.yml
+++ b/.github/workflows/autofix.yml
@@ -28,7 +28,7 @@ jobs:
       - name: Get PR ref
         if: github.event_name != 'workflow_dispatch'
         id: pr
-        uses: actions/github-script@v8
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
         with:
           script: |
             const { data: pull } = await github.rest.pulls.get({
@@ -46,12 +46,12 @@ jobs:
               core.setFailed('PR is from a fork');
             }
             core.setOutput('ref', pull.head.ref);
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         if: github.event_name == 'workflow_dispatch' || steps.pr.outcome == 'success'
         with:
           ref: ${{ github.event_name == 'workflow_dispatch' && github.ref || steps.pr.outputs.ref }}
-      - uses: pnpm/action-setup@b906affcce14559ad1aafd4ab0e942779e9f58b1 # v4.3.0
-      - uses: actions/setup-node@v6
+      - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6.0.8
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: 24
           cache: pnpm
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 365717755e..3846690135 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -32,9 +32,9 @@ jobs:
             os: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v4
-      - uses: actions/setup-node@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6.0.8
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: ${{ matrix.node-version }}
           cache: pnpm
@@ -48,9 +48,9 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v4
-      - uses: actions/setup-node@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6.0.8
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: 22
           cache: pnpm
@@ -65,9 +65,9 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v4
-      - uses: actions/setup-node@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6.0.8
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: 24
           cache: pnpm
@@ -82,9 +82,9 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v4
-      - uses: actions/setup-node@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6.0.8
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: 24
           cache: pnpm
@@ -105,9 +105,9 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v4
-      - uses: actions/setup-node@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6.0.8
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: 24
           cache: pnpm
diff --git a/.github/workflows/ecosystem-ci-trigger.yml b/.github/workflows/ecosystem-ci-trigger.yml
index 8a6d1bf345..8691a64ca4 100644
--- a/.github/workflows/ecosystem-ci-trigger.yml
+++ b/.github/workflows/ecosystem-ci-trigger.yml
@@ -17,7 +17,7 @@ jobs:
       contents: read # to clone the repo
     steps:
       - name: Check User Permissions
-        uses: actions/github-script@v8
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
         id: check-permissions
         with:
           script: |
@@ -56,7 +56,7 @@ jobs:
             }
 
       - name: Get PR Data
-        uses: actions/github-script@v8
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
         id: get-pr-data
         with:
           script: |
@@ -106,7 +106,7 @@ jobs:
 
       - name: Generate Token
         id: generate-token
-        uses: actions/create-github-app-token@v2
+        uses: actions/create-github-app-token@fee1f7d63c2ff003460e3d139729b119787bc349 # v2
         with:
           app-id: ${{ secrets.ECOSYSTEM_CI_GITHUB_APP_ID }}
           private-key: ${{ secrets.ECOSYSTEM_CI_GITHUB_APP_PRIVATE_KEY }}
@@ -115,7 +115,7 @@ jobs:
             svelte-ecosystem-ci
 
       - name: Trigger Downstream Workflow
-        uses: actions/github-script@v8
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
         id: trigger
         env:
           COMMENT: ${{ github.event.comment.body }}
diff --git a/.github/workflows/pkg.pr.new.yml b/.github/workflows/pkg.pr.new.yml
deleted file mode 100644
index 0fcda5a778..0000000000
--- a/.github/workflows/pkg.pr.new.yml
+++ /dev/null
@@ -1,229 +0,0 @@
-name: pkg.pr.new
-on:
-  pull_request_target:
-    types: [opened, synchronize]
-  push:
-    branches: [main]
-  workflow_dispatch:
-    inputs:
-      sha:
-        description: 'Commit SHA to build'
-        required: true
-        type: string
-      pr:
-        description: 'PR number to comment on'
-        required: true
-        type: number
-
-permissions: {}
-
-jobs:
-  build:
-    # Skip pull_request_target events from forks — maintainers can use workflow_dispatch instead
-    if: >
-      github.event_name != 'pull_request_target' ||
-      github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
-    # No permissions — this job runs user-controlled code
-    permissions: {}
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          # For pull_request_target, check out the PR head.
-          # For workflow_dispatch, check out the manually specified SHA.
-          # For push, fall back to the push SHA.
-          ref: ${{ github.event.pull_request.head.sha || inputs.sha || github.sha }}
-
-      - uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v4
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 22.x
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build
-        run: pnpm build
-
-      - run: pnpx pkg-pr-new publish --comment=off --json output.json --compact --no-template './packages/svelte'
-
-      - name: Upload output
-        uses: actions/upload-artifact@v4
-        with:
-          name: output
-          path: ./output.json
-
-  # Sanitizes the untrusted output from the build job before it's consumed by
-  # jobs with elevated permissions. This ensures that only known package names
-  # and valid SHA prefixes make it through.
-  sanitize:
-    needs: build
-    runs-on: ubuntu-latest
-
-    permissions: {}
-
-    steps:
-      - name: Download artifact
-        uses: actions/download-artifact@v7
-        with:
-          name: output
-
-      - name: Sanitize output
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const fs = require('fs');
-            const raw = JSON.parse(fs.readFileSync('output.json', 'utf8'));
-
-            const ALLOWED_PACKAGES = new Set(['svelte']);
-            const SHA_PATTERN = /^[0-9a-f]{7}$/;
-
-            const packages = (raw.packages || [])
-              .filter(p => {
-                if (!ALLOWED_PACKAGES.has(p.name)) {
-                  console.log(`Skipping unexpected package: ${JSON.stringify(p.name)}`);
-                  return false;
-                }
-                const sha = p.url?.replace(/^.+@([^@]+)$/, '$1');
-                if (!sha || !SHA_PATTERN.test(sha)) {
-                  console.log(`Skipping package with invalid SHA: ${JSON.stringify(p.url)}`);
-                  return false;
-                }
-                return true;
-              })
-              .map(p => ({
-                name: p.name,
-                sha: p.url.replace(/^.+@([^@]+)$/, '$1'),
-              }));
-
-            fs.writeFileSync('sanitized-output.json', JSON.stringify({ packages }), 'utf8');
-
-      - name: Upload sanitized output
-        uses: actions/upload-artifact@v4
-        with:
-          name: sanitized-output
-          path: ./sanitized-output.json
-
-  comment:
-    needs: sanitize
-    if: github.event_name == 'pull_request_target' || github.event_name == 'workflow_dispatch'
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-      pull-requests: write
-
-    steps:
-      - name: Download sanitized artifact
-        uses: actions/download-artifact@v7
-        with:
-          name: sanitized-output
-
-      - name: Resolve PR number
-        id: pr
-        uses: actions/github-script@v8
-        with:
-          script: |
-            if (context.eventName === 'pull_request_target') {
-              core.setOutput('number', context.issue.number);
-              return;
-            }
-
-            // For workflow_dispatch, use the explicitly provided PR number.
-            // We can't use listPullRequestsAssociatedWithCommit because fork
-            // commits don't exist in the base repo, so the API returns nothing.
-            const pr = Number('${{ inputs.pr }}');
-            if (!pr || isNaN(pr)) {
-              core.setFailed('workflow_dispatch requires a valid pr input');
-              return;
-            }
-
-            core.setOutput('number', pr);
-
-      - name: Post or update comment
-        uses: actions/github-script@v8
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const fs = require('fs');
-            const { packages } = JSON.parse(fs.readFileSync('sanitized-output.json', 'utf8'));
-
-            if (packages.length === 0) {
-              console.log('No valid packages found. Skipping comment.');
-              return;
-            }
-
-            const issue_number = parseInt('${{ steps.pr.outputs.number }}', 10);
-
-            const bot_comment_identifier = `<!-- pkg.pr.new comment -->`;
-
-            const body = `${bot_comment_identifier}
-
-            [Playground](https://svelte.dev/playground?version=pr-${issue_number})
-
-            \`\`\`
-            ${packages.map(p => `pnpm add https://pkg.pr.new/${p.name}@${issue_number}`).join('\n')}
-            \`\`\`
-            `;
-
-            const comments = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number,
-            });
-            const existing = comments.data.find(c => c.body.includes(bot_comment_identifier));
-
-            if (existing) {
-              await github.rest.issues.updateComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                comment_id: existing.id,
-                body,
-              });
-            } else {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number,
-                body,
-              });
-            }
-
-  log:
-    needs: sanitize
-    if: github.event_name == 'push'
-    runs-on: ubuntu-latest
-
-    permissions: {}
-
-    steps:
-      - name: Download sanitized artifact
-        uses: actions/download-artifact@v7
-        with:
-          name: sanitized-output
-
-      - name: Log publish info
-        uses: actions/github-script@v8
-        with:
-          script: |
-            const fs = require('fs');
-            const { packages } = JSON.parse(fs.readFileSync('sanitized-output.json', 'utf8'));
-
-            if (packages.length === 0) {
-              console.log('No valid packages found.');
-              return;
-            }
-
-            console.log('\n' + '='.repeat(50));
-            console.log('Publish Information');
-            console.log('='.repeat(50));
-            for (const p of packages) {
-              console.log(`${p.name} - pnpm add https://pkg.pr.new/${p.name}@${p.sha}`);
-            }
-            const svelte = packages.find(p => p.name === 'svelte');
-            if (svelte) {
-              console.log(`\nPlayground: https://svelte.dev/playground?version=commit-${svelte.sha}`);
-            }
-            console.log('='.repeat(50));
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 359fcb7eea..12fe17582e 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -23,13 +23,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           # This makes Actions fetch all Git history so that Changesets can generate changelogs with the correct commits
           fetch-depth: 0
-      - uses: pnpm/action-setup@fc06bc1257f339d1d5d8b3a19a8cae5388b55320 # v4
+      - uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6.0.8
       - name: Setup Node.js
-        uses: actions/setup-node@v6
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: 24.x
           cache: pnpm
diff --git a/.gitignore b/.gitignore
index 556cae6344..e4f9f9cf87 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,3 +27,4 @@ packages/svelte/scripts/_baseline/
 benchmarking/.profiles
 benchmarking/compare/.results
 benchmarking/compare/.profiles
+benchmarking/compare/results.html
diff --git a/benchmarking/benchmarks/reactivity/tests/kairo_broad_block.bench.js b/benchmarking/benchmarks/reactivity/tests/kairo_broad_block.bench.js
new file mode 100644
index 0000000000..e8451ec3fa
--- /dev/null
+++ b/benchmarking/benchmarks/reactivity/tests/kairo_broad_block.bench.js
@@ -0,0 +1,47 @@
+import assert from 'node:assert';
+import * as $ from 'svelte/internal/client';
+import { block } from '../../../../packages/svelte/src/internal/client/reactivity/effects.js';
+
+// Like `kairo_broad`, but each derived is also read by a block effect, as
+// happens with e.g. `{#if derived}` in a component. Measures our #traverse perf better.
+export default () => {
+	let head = $.state(0);
+	let last = head;
+	let counter = 0;
+
+	const destroy = $.effect_root(() => {
+		for (let i = 0; i < 50; i++) {
+			let current = $.derived(() => {
+				return $.get(head) + i;
+			});
+			let current2 = $.derived(() => {
+				return $.get(current) + 1;
+			});
+			block(() => {
+				$.get(current2);
+			});
+			$.render_effect(() => {
+				$.get(current2);
+				counter++;
+			});
+			last = current2;
+		}
+	});
+
+	return {
+		destroy,
+		run() {
+			$.flush(() => {
+				$.set(head, 1);
+			});
+			counter = 0;
+			for (let i = 0; i < 50; i++) {
+				$.flush(() => {
+					$.set(head, i);
+				});
+				assert.equal($.get(last), i + 50);
+			}
+			assert.equal(counter, 50 * 50);
+		}
+	};
+};
diff --git a/benchmarking/benchmarks/reactivity/tests/kairo_deep_block.bench.js b/benchmarking/benchmarks/reactivity/tests/kairo_deep_block.bench.js
new file mode 100644
index 0000000000..a8d9fa8c35
--- /dev/null
+++ b/benchmarking/benchmarks/reactivity/tests/kairo_deep_block.bench.js
@@ -0,0 +1,48 @@
+import assert from 'node:assert';
+import * as $ from 'svelte/internal/client';
+import { block } from '../../../../packages/svelte/src/internal/client/reactivity/effects.js';
+
+let len = 50;
+const iter = 50;
+
+// Like `kairo_deep`, but the derived chain is also read by a block effect, as
+// happens with e.g. `{#if derived}` in a component. Measures our #traverse perf better.
+export default () => {
+	let head = $.state(0);
+	let current = head;
+	for (let i = 0; i < len; i++) {
+		let c = current;
+		current = $.derived(() => {
+			return $.get(c) + 1;
+		});
+	}
+	let counter = 0;
+
+	const destroy = $.effect_root(() => {
+		block(() => {
+			$.get(current);
+		});
+
+		$.render_effect(() => {
+			$.get(current);
+			counter++;
+		});
+	});
+
+	return {
+		destroy,
+		run() {
+			$.flush(() => {
+				$.set(head, 1);
+			});
+			counter = 0;
+			for (let i = 0; i < iter; i++) {
+				$.flush(() => {
+					$.set(head, i);
+				});
+				assert.equal($.get(current), len + i);
+			}
+			assert.equal(counter, iter);
+		}
+	};
+};
diff --git a/benchmarking/compare/generate-report.js b/benchmarking/compare/generate-report.js
index a61f58909b..70f7b30fbb 100644
--- a/benchmarking/compare/generate-report.js
+++ b/benchmarking/compare/generate-report.js
@@ -2,15 +2,27 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
-export function generate_report(outdir) {
+const REPORT_DATA_PLACEHOLDER = '%%REPORT_DATA%%';
+const report_template = fs.readFileSync(
+	new URL('./results.template.html', import.meta.url),
+	'utf-8'
+);
+
+if (!report_template.includes(REPORT_DATA_PLACEHOLDER)) {
+	throw new Error(`Missing ${REPORT_DATA_PLACEHOLDER} in results.template.html`);
+}
+
+export function generate_report(outdir, branches) {
 	const result_files = fs
 		.readdirSync(outdir)
-		.filter((file) => file.endsWith('.json'))
+		.filter((file) => file.endsWith('.json') && (!branches || branches.includes(file.slice(0, -5))))
 		.sort((a, b) => a.localeCompare(b));
 
-	const branches = result_files.map((file) => file.slice(0, -5));
+	// always do this so that ordering lines up (branches argument might be passed in a different order than the result files are sorted
+	branches = result_files.map((file) => file.slice(0, -5));
+
 	const results = result_files.map((file) =>
-		JSON.parse(fs.readFileSync(`${outdir}/${file}`, 'utf-8'))
+		JSON.parse(fs.readFileSync(path.join(outdir, file), 'utf-8'))
 	);
 
 	if (results.length === 0) {
@@ -33,11 +45,38 @@ export function generate_report(outdir) {
 
 	write('');
 
-	for (let i = 0; i < results[0].length; i += 1) {
-		write(`${results[0][i].benchmark}`);
+	// match results by benchmark name — branches may have different benchmark
+	// lists (e.g. a benchmark that only exists on one of the branches), so
+	// pairing by array index would misattribute results
+	const by_name = results.map((result) => new Map(result.map((r) => [r.benchmark, r])));
+
+	/** @type {string[]} */
+	const names = [];
+
+	for (const result of results) {
+		for (const { benchmark } of result) {
+			if (!names.includes(benchmark)) {
+				names.push(benchmark);
+			}
+		}
+	}
+
+	for (const name of names) {
+		const entries = by_name.map((map) => map.get(name));
+		const missing = entries
+			.map((entry, b) => (entry === undefined ? branches[b] : null))
+			.filter((branch) => branch !== null);
+
+		write(`${name}`);
+
+		if (missing.length > 0) {
+			write(`  skipped (missing on ${missing.join(', ')})`);
+			write('');
+			continue;
+		}
 
 		for (const metric of ['time', 'gc_time']) {
-			const times = results.map((result) => +result[i][metric]);
+			const times = entries.map((entry) => +entry[metric]);
 			let min = Infinity;
 			let max = -Infinity;
 			let min_index = -1;
@@ -68,6 +107,32 @@ export function generate_report(outdir) {
 
 		write('');
 	}
+
+	const benchmarks = names.map((name) => ({
+		name,
+		values: by_name.map((map) => {
+			const entry = map.get(name);
+
+			if (entry === undefined) return null;
+
+			return {
+				time: Number(entry.time),
+				gc_time: Number(entry.gc_time)
+			};
+		})
+	}));
+	const data = JSON.stringify({
+		generated_at: new Date().toISOString(),
+		branches,
+		benchmarks
+	})
+		.replaceAll('<', '\\u003c')
+		.replaceAll('\u2028', '\\u2028')
+		.replaceAll('\u2029', '\\u2029');
+	const html_file = path.resolve(outdir, '../results.html');
+
+	fs.writeFileSync(html_file, report_template.replace(REPORT_DATA_PLACEHOLDER, data));
+	console.log(`\nHTML report written to ${html_file}`);
 }
 
 function char(i) {
diff --git a/benchmarking/compare/index.js b/benchmarking/compare/index.js
index 9064ee7da9..2e76f46e1b 100644
--- a/benchmarking/compare/index.js
+++ b/benchmarking/compare/index.js
@@ -85,4 +85,4 @@ if (PROFILE_DIR !== null) {
 	console.log(`\nCPU profiles written to ${PROFILE_DIR}`);
 }
 
-generate_report(outdir);
+generate_report(outdir, requested_branches);
diff --git a/benchmarking/compare/results.template.html b/benchmarking/compare/results.template.html
new file mode 100644
index 0000000000..02f208ac4f
--- /dev/null
+++ b/benchmarking/compare/results.template.html
@@ -0,0 +1,741 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<title>Benchmark comparison</title>
+		<style>
+			:root {
+				color-scheme: light;
+				font-family:
+					Inter,
+					ui-sans-serif,
+					system-ui,
+					-apple-system,
+					BlinkMacSystemFont,
+					'Segoe UI',
+					sans-serif;
+				font-variant-numeric: tabular-nums;
+				background: #f6f8fa;
+				color: #1f2328;
+			}
+
+			* {
+				box-sizing: border-box;
+			}
+
+			body {
+				margin: 0;
+				background: #f6f8fa;
+			}
+
+			main {
+				width: min(1600px, 100%);
+				margin: 0 auto;
+				padding: 40px clamp(16px, 3vw, 48px) 64px;
+			}
+
+			h1,
+			h2,
+			p {
+				margin-top: 0;
+			}
+
+			h1 {
+				margin-bottom: 8px;
+				font-size: clamp(28px, 4vw, 48px);
+				letter-spacing: -0.04em;
+			}
+
+			h2 {
+				margin-bottom: 14px;
+				font-size: 18px;
+				letter-spacing: -0.01em;
+			}
+
+			.intro {
+				max-width: 780px;
+				margin-bottom: 28px;
+				color: #59636e;
+				line-height: 1.6;
+			}
+
+			.summary {
+				display: grid;
+				grid-template-columns: repeat(3, minmax(0, 1fr));
+				gap: 12px;
+				margin-bottom: 32px;
+			}
+
+			.card,
+			.panel {
+				border: 1px solid #d0d7de;
+				background: #ffffff;
+				box-shadow: 0 8px 24px rgb(140 149 159 / 16%);
+			}
+
+			.card {
+				min-height: 112px;
+				padding: 18px 20px;
+				border-radius: 8px;
+			}
+
+			.card-label {
+				margin-bottom: 10px;
+				color: #59636e;
+				font-size: 12px;
+				font-weight: 700;
+				letter-spacing: 0.08em;
+				text-transform: uppercase;
+			}
+
+			.card-value {
+				font-size: 21px;
+				font-weight: 750;
+				letter-spacing: -0.02em;
+			}
+
+			.card-detail {
+				margin-top: 7px;
+				color: #59636e;
+				font-size: 13px;
+			}
+
+			.panel {
+				margin-bottom: 24px;
+				border-radius: 8px;
+				overflow: hidden;
+			}
+
+			.panel-heading {
+				display: flex;
+				align-items: end;
+				justify-content: space-between;
+				gap: 20px;
+				padding: 18px 20px;
+				border-bottom: 1px solid #d8dee4;
+			}
+
+			.panel-heading h2,
+			.panel-heading p {
+				margin-bottom: 0;
+			}
+
+			.help {
+				max-width: 720px;
+				color: #59636e;
+				font-size: 13px;
+				line-height: 1.5;
+			}
+
+			.controls {
+				display: flex;
+				flex-wrap: wrap;
+				gap: 12px;
+				padding: 14px 20px;
+				border-bottom: 1px solid #d8dee4;
+				background: #f6f8fa;
+			}
+
+			label {
+				display: flex;
+				align-items: center;
+				gap: 8px;
+				color: #59636e;
+				font-size: 13px;
+				font-weight: 650;
+			}
+
+			select {
+				max-width: 250px;
+				padding: 7px 30px 7px 9px;
+				border: 1px solid #afb8c1;
+				border-radius: 5px;
+				background: #ffffff;
+				color: #1f2328;
+				font: inherit;
+			}
+
+			.table-wrap {
+				overflow: auto;
+			}
+
+			table {
+				width: 100%;
+				border-collapse: separate;
+				border-spacing: 0;
+			}
+
+			th,
+			td {
+				padding: 11px 14px;
+				border-right: 1px solid #d8dee4;
+				border-bottom: 1px solid #d8dee4;
+				text-align: left;
+				vertical-align: middle;
+			}
+
+			th:last-child,
+			td:last-child {
+				border-right: 0;
+			}
+
+			tr:last-child td {
+				border-bottom: 0;
+			}
+
+			th {
+				background: #f6f8fa;
+				color: #59636e;
+				font-size: 12px;
+				font-weight: 700;
+				letter-spacing: 0.04em;
+				text-transform: uppercase;
+			}
+
+			th button {
+				width: 100%;
+				padding: 0;
+				border: 0;
+				background: transparent;
+				color: inherit;
+				font: inherit;
+				letter-spacing: inherit;
+				text-align: inherit;
+				text-transform: inherit;
+				cursor: pointer;
+			}
+
+			th button:hover,
+			th button:focus-visible {
+				color: #1f2328;
+			}
+
+			.standings td:nth-child(n + 2),
+			.standings th:nth-child(n + 2) {
+				text-align: right;
+			}
+
+			.rank {
+				display: inline-grid;
+				width: 24px;
+				height: 24px;
+				margin-right: 10px;
+				place-items: center;
+				border-radius: 50%;
+				background: #eaeef2;
+				color: #424a53;
+				font-size: 12px;
+				font-weight: 750;
+			}
+
+			.branch-name,
+			.benchmark-name {
+				font-weight: 700;
+			}
+
+			.benchmark-table {
+				min-width: max(900px, 100%);
+			}
+
+			.benchmark-table thead {
+				position: sticky;
+				top: 0;
+				z-index: 3;
+			}
+
+			.benchmark-table th:first-child,
+			.benchmark-table td:first-child {
+				position: sticky;
+				left: 0;
+				z-index: 2;
+				min-width: 220px;
+				background: #ffffff;
+			}
+
+			.benchmark-table th:first-child {
+				z-index: 4;
+				background: #f6f8fa;
+			}
+
+			.benchmark-table th:nth-child(2),
+			.benchmark-table td:nth-child(2) {
+				min-width: 150px;
+			}
+
+			.benchmark-table th:not(:first-child),
+			.benchmark-table td:not(:first-child) {
+				min-width: 175px;
+			}
+
+			.metric {
+				position: relative;
+				isolation: isolate;
+				background: hsl(var(--heat, 210) 74% 94%);
+			}
+
+			.metric::after {
+				position: absolute;
+				z-index: -1;
+				inset: auto 0 0;
+				height: 3px;
+				background: hsl(var(--heat, 210) 65% 43%);
+				content: '';
+			}
+
+			.time {
+				font-size: 15px;
+				font-weight: 750;
+			}
+
+			.delta {
+				margin-left: 7px;
+				color: #424a53;
+				font-size: 12px;
+				font-weight: 650;
+			}
+
+			.secondary {
+				margin-top: 5px;
+				color: #59636e;
+				font-size: 12px;
+			}
+
+			.winner {
+				color: #1a7f37;
+				font-weight: 700;
+			}
+
+			.missing {
+				background: #f6f8fa;
+				color: #6e7781;
+				font-style: italic;
+			}
+
+			footer {
+				color: #6e7781;
+				font-size: 12px;
+				text-align: right;
+			}
+
+			@media (max-width: 760px) {
+				main {
+					padding-top: 24px;
+				}
+
+				.summary {
+					grid-template-columns: 1fr;
+				}
+
+				.panel-heading {
+					align-items: start;
+					flex-direction: column;
+				}
+
+				.controls,
+				label {
+					align-items: stretch;
+					flex-direction: column;
+				}
+
+				select {
+					max-width: none;
+					width: 100%;
+				}
+			}
+		</style>
+	</head>
+	<body>
+		<main>
+			<h1>Benchmark comparison</h1>
+			<p class="intro">
+				Runtime results across branches. Green cells are fastest for an entry and red cells expose
+				the largest regressions. Overall runtime normalizes every benchmark to its fastest result
+				before averaging, so long-running entries do not outweigh short ones.
+			</p>
+
+			<section class="summary" id="summary" aria-label="Comparison summary"></section>
+
+			<section class="panel">
+				<div class="panel-heading">
+					<div>
+						<h2>Branch standings</h2>
+						<p class="help">
+							Wins count the fastest branch for each comparable entry. Normalized runtime is the
+							average slowdown against each entry's fastest result; lower is better. Click a heading
+							to sort.
+						</p>
+					</div>
+				</div>
+				<div class="table-wrap">
+					<table class="standings">
+						<thead>
+							<tr>
+								<th><button type="button" data-standing-sort="name">Branch</button></th>
+								<th><button type="button" data-standing-sort="wins">Wins</button></th>
+								<th>
+									<button type="button" data-standing-sort="score">Normalized runtime</button>
+								</th>
+							</tr>
+						</thead>
+						<tbody id="standings"></tbody>
+					</table>
+				</div>
+			</section>
+
+			<section class="panel">
+				<div class="panel-heading">
+					<div>
+						<h2>Results by benchmark</h2>
+						<p class="help">
+							Each cell shows runtime, difference from the winner, and GC time. Missing entries are
+							excluded from both standings.
+						</p>
+					</div>
+				</div>
+				<div class="controls">
+					<label
+						>Sort benchmarks
+						<select id="benchmark-sort"></select
+					></label>
+					<label
+						>Order branches
+						<select id="branch-order">
+							<option value="name">Branch name</option>
+							<option value="wins">Overall winner by wins</option>
+							<option value="score" selected>Overall winner by normalized runtime</option>
+						</select></label
+					>
+				</div>
+				<div class="table-wrap">
+					<table class="benchmark-table" id="benchmark-table"></table>
+				</div>
+			</section>
+
+			<footer id="generated"></footer>
+		</main>
+
+		<script type="application/json" id="report-data">
+			%%REPORT_DATA%%
+		</script>
+		<script>
+			const report = JSON.parse(document.querySelector('#report-data').textContent);
+			const number = new Intl.NumberFormat('en', {
+				maximumFractionDigits: 2,
+				minimumFractionDigits: 2
+			});
+			const score_number = new Intl.NumberFormat('en', {
+				maximumFractionDigits: 3,
+				minimumFractionDigits: 3
+			});
+
+			function analyze(benchmark) {
+				const complete =
+					benchmark.values.length === report.branches.length &&
+					benchmark.values.every(function (value) {
+						return value !== null && Number.isFinite(value.time) && value.time > 0;
+					});
+
+				if (!complete) return { comparable: false, min: 0, max: 0, winners: [], ratios: [] };
+
+				const times = benchmark.values.map(function (value) {
+					return value.time;
+				});
+				const min = Math.min.apply(null, times);
+				const max = Math.max.apply(null, times);
+				const winners = [];
+
+				times.forEach(function (time, index) {
+					if (time === min) winners.push(index);
+				});
+
+				return {
+					comparable: true,
+					min: min,
+					max: max,
+					winners: winners,
+					ratios: times.map(function (time) {
+						return time / min;
+					})
+				};
+			}
+
+			const analyzed = report.benchmarks.map(function (benchmark, index) {
+				return { benchmark: benchmark, stats: analyze(benchmark), index: index };
+			});
+			const comparable = analyzed.filter(function (entry) {
+				return entry.stats.comparable;
+			});
+			const standings = report.branches.map(function (name, index) {
+				let wins = 0;
+				let score = 0;
+
+				comparable.forEach(function (entry) {
+					if (entry.stats.winners.includes(index)) wins += 1;
+					score += entry.stats.ratios[index];
+				});
+
+				return {
+					name: name,
+					index: index,
+					wins: wins,
+					score: comparable.length === 0 ? Infinity : score / comparable.length
+				};
+			});
+
+			function compare_name(a, b) {
+				return a.name.localeCompare(b.name, undefined, { numeric: true });
+			}
+
+			function order_standings(key, direction) {
+				return standings.slice().sort(function (a, b) {
+					let result;
+					if (key === 'name') result = compare_name(a, b);
+					else result = a[key] - b[key];
+					return result === 0 ? compare_name(a, b) : result * direction;
+				});
+			}
+
+			function best(key, direction) {
+				const ordered = order_standings(key, direction);
+				if (ordered.length === 0) return [];
+				return ordered.filter(function (entry) {
+					return entry[key] === ordered[0][key];
+				});
+			}
+
+			function names(entries) {
+				return entries
+					.map(function (entry) {
+						return entry.name;
+					})
+					.join(', ');
+			}
+
+			function make(tag, class_name, text) {
+				const node = document.createElement(tag);
+				if (class_name) node.className = class_name;
+				if (text !== undefined) node.textContent = text;
+				return node;
+			}
+
+			const wins_best = best('wins', -1);
+			const score_best = best('score', 1);
+			const summary = document.querySelector('#summary');
+			[
+				{
+					label: 'Most benchmark wins',
+					value: comparable.length === 0 ? 'No comparable results' : names(wins_best),
+					detail:
+						comparable.length === 0
+							? ''
+							: wins_best[0].wins + ' of ' + comparable.length + ' entries'
+				},
+				{
+					label: 'Best normalized runtime',
+					value:
+						score_best.length === 0 || !Number.isFinite(score_best[0].score)
+							? 'No comparable results'
+							: names(score_best),
+					detail:
+						score_best.length === 0 || !Number.isFinite(score_best[0].score)
+							? ''
+							: score_number.format(score_best[0].score) + 'x average runtime'
+				},
+				{
+					label: 'Coverage',
+					value: comparable.length + ' comparable entries',
+					detail:
+						report.branches.length +
+						' branches, ' +
+						(report.benchmarks.length - comparable.length) +
+						' incomplete entries'
+				}
+			].forEach(function (item) {
+				const card = make('article', 'card');
+				card.append(
+					make('div', 'card-label', item.label),
+					make('div', 'card-value', item.value),
+					make('div', 'card-detail', item.detail)
+				);
+				summary.append(card);
+			});
+
+			let standing_sort = { key: 'score', direction: 1 };
+
+			function render_standings() {
+				const body = document.querySelector('#standings');
+				body.replaceChildren();
+				const score_order = order_standings('score', 1);
+
+				order_standings(standing_sort.key, standing_sort.direction).forEach(function (entry) {
+					const row = document.createElement('tr');
+					const branch = make('td');
+					branch.append(
+						make('span', 'rank', String(score_order.indexOf(entry) + 1)),
+						make('span', 'branch-name', entry.name)
+					);
+					row.append(
+						branch,
+						make('td', '', String(entry.wins)),
+						make(
+							'td',
+							'',
+							Number.isFinite(entry.score) ? score_number.format(entry.score) + 'x' : 'n/a'
+						)
+					);
+					body.append(row);
+				});
+
+				document.querySelectorAll('[data-standing-sort]').forEach(function (button) {
+					const active = button.dataset.standingSort === standing_sort.key;
+					button
+						.closest('th')
+						.setAttribute(
+							'aria-sort',
+							active ? (standing_sort.direction === 1 ? 'ascending' : 'descending') : 'none'
+						);
+					button.textContent =
+						button.dataset.standingSort === 'name'
+							? 'Branch'
+							: button.dataset.standingSort === 'wins'
+								? 'Wins'
+								: 'Normalized runtime';
+					if (active) button.textContent += standing_sort.direction === 1 ? ' ↑' : ' ↓';
+				});
+			}
+
+			document.querySelectorAll('[data-standing-sort]').forEach(function (button) {
+				button.addEventListener('click', function () {
+					const key = button.dataset.standingSort;
+					if (standing_sort.key === key) standing_sort.direction *= -1;
+					else standing_sort = { key: key, direction: key === 'wins' ? -1 : 1 };
+					render_standings();
+				});
+			});
+
+			const benchmark_sort = document.querySelector('#benchmark-sort');
+			[
+				['original', 'Original run order'],
+				['name', 'Benchmark name'],
+				['winner', 'Winner for entry'],
+				['spread', 'Largest spread']
+			]
+				.concat(
+					report.branches.map(function (branch, index) {
+						return ['branch:' + index, branch + ': slowest relative result'];
+					})
+				)
+				.forEach(function (option) {
+					const node = make('option', '', option[1]);
+					node.value = option[0];
+					benchmark_sort.append(node);
+				});
+
+			function branch_order() {
+				const key = document.querySelector('#branch-order').value;
+				if (key === 'name') return order_standings('name', 1);
+				if (key === 'wins') return order_standings('wins', -1);
+				return order_standings('score', 1);
+			}
+
+			function benchmark_order() {
+				const key = benchmark_sort.value;
+				return analyzed.slice().sort(function (a, b) {
+					if (key === 'original') return a.index - b.index;
+					if (key === 'name') return compare_name(a.benchmark, b.benchmark);
+					if (key === 'winner') {
+						const a_name = a.stats.comparable ? report.branches[a.stats.winners[0]] : '\uffff';
+						const b_name = b.stats.comparable ? report.branches[b.stats.winners[0]] : '\uffff';
+						return a_name.localeCompare(b_name) || compare_name(a.benchmark, b.benchmark);
+					}
+					if (key === 'spread') {
+						const a_spread = a.stats.comparable ? a.stats.max / a.stats.min : -1;
+						const b_spread = b.stats.comparable ? b.stats.max / b.stats.min : -1;
+						return b_spread - a_spread || compare_name(a.benchmark, b.benchmark);
+					}
+
+					const branch = Number(key.slice('branch:'.length));
+					const a_ratio = a.stats.comparable ? a.stats.ratios[branch] : -1;
+					const b_ratio = b.stats.comparable ? b.stats.ratios[branch] : -1;
+					return b_ratio - a_ratio || compare_name(a.benchmark, b.benchmark);
+				});
+			}
+
+			function render_benchmarks() {
+				const table = document.querySelector('#benchmark-table');
+				const branches = branch_order();
+				const head = document.createElement('thead');
+				const head_row = document.createElement('tr');
+				head_row.append(make('th', '', 'Benchmark'), make('th', '', 'Winner'));
+				branches.forEach(function (branch) {
+					head_row.append(make('th', '', branch.name));
+				});
+				head.append(head_row);
+
+				const body = document.createElement('tbody');
+				benchmark_order().forEach(function (entry) {
+					const row = document.createElement('tr');
+					row.append(make('td', 'benchmark-name', entry.benchmark.name));
+
+					const winner_names = entry.stats.winners.map(function (index) {
+						return report.branches[index];
+					});
+					row.append(
+						make(
+							'td',
+							winner_names.length === 0 ? 'missing' : 'winner',
+							winner_names.length === 0 ? 'Incomplete' : winner_names.join(', ')
+						)
+					);
+
+					branches.forEach(function (branch) {
+						const value = entry.benchmark.values[branch.index];
+						if (value === null || !Number.isFinite(value.time)) {
+							row.append(make('td', 'missing', 'Not available'));
+							return;
+						}
+
+						const cell = make('td', entry.stats.comparable ? 'metric' : 'missing');
+						const time = make('span', 'time', number.format(value.time) + ' ms');
+						cell.append(time);
+
+						if (entry.stats.comparable) {
+							const ratio = entry.stats.ratios[branch.index];
+							const heat =
+								entry.stats.max === entry.stats.min
+									? 0
+									: (value.time - entry.stats.min) / (entry.stats.max - entry.stats.min);
+							cell.style.setProperty('--heat', String(Math.round(142 - heat * 137)));
+							cell.append(
+								make(
+									'span',
+									'delta',
+									ratio === 1 ? 'fastest' : '+' + number.format((ratio - 1) * 100) + '%'
+								)
+							);
+						}
+
+						const gc = Number.isFinite(value.gc_time)
+							? number.format(value.gc_time) + ' ms'
+							: 'n/a';
+						cell.append(make('div', 'secondary', 'GC ' + gc));
+						row.append(cell);
+					});
+
+					body.append(row);
+				});
+
+				table.replaceChildren(head, body);
+			}
+
+			benchmark_sort.addEventListener('change', render_benchmarks);
+			document.querySelector('#branch-order').addEventListener('change', render_benchmarks);
+			document.querySelector('#generated').textContent =
+				'Generated ' + new Date(report.generated_at).toLocaleString();
+
+			render_standings();
+			render_benchmarks();
+		</script>
+	</body>
+</html>
diff --git a/benchmarking/compare/runner.js b/benchmarking/compare/runner.js
index 31a8e6b44b..fa746f9869 100644
--- a/benchmarking/compare/runner.js
+++ b/benchmarking/compare/runner.js
@@ -1,18 +1,67 @@
+import { fork } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 import { reactivity_benchmarks } from '../benchmarks/reactivity/index.js';
 import { with_cpu_profile } from '../utils.js';
 
-const results = [];
-const PROFILE_DIR = process.env.BENCH_PROFILE_DIR;
+const PROFILE_DIR = process.env.BENCH_PROFILE_DIR ?? null;
+const single = process.env.BENCH_SINGLE;
 
-for (let i = 0; i < reactivity_benchmarks.length; i += 1) {
-	const benchmark = reactivity_benchmarks[i];
+if (single) {
+	// child mode — run a single benchmark and report the result to the parent
+	const benchmark = reactivity_benchmarks.find((b) => b.label === single);
 
-	process.stderr.write(`Running ${i + 1}/${reactivity_benchmarks.length} ${benchmark.label} `);
-	results.push({
-		benchmark: benchmark.label,
-		...(await with_cpu_profile(PROFILE_DIR, benchmark.label, () => benchmark.fn()))
-	});
-	process.stderr.write('\x1b[2K\r');
-}
+	if (!benchmark) {
+		throw new Error(`Unknown benchmark ${single}`);
+	}
+
+	const result = await with_cpu_profile(PROFILE_DIR, benchmark.label, () => benchmark.fn());
+
+	// exit via the callback so the message is guaranteed to be delivered
+	/** @type {NodeJS.Process} */ (process).send(result, () => process.exit(0));
+} else {
+	// parent mode — run every benchmark in its own child process, so that
+	// heap/GC/JIT state from one benchmark cannot contaminate the others
+	const filename = fileURLToPath(import.meta.url);
+	const results = [];
+
+	for (let i = 0; i < reactivity_benchmarks.length; i += 1) {
+		const benchmark = reactivity_benchmarks[i];
+
+		process.stderr.write(`Running ${i + 1}/${reactivity_benchmarks.length} ${benchmark.label} `);
+
+		const result = await new Promise((fulfil, reject) => {
+			const child = fork(filename, [], {
+				env: {
+					...process.env,
+					BENCH_SINGLE: benchmark.label
+				}
+			});
+
+			/** @type {object | null} */
+			let message_received = null;
 
-process.send(results);
+			child.on('message', (message) => {
+				message_received = /** @type {object} */ (message);
+			});
+
+			child.on('error', reject);
+
+			child.on('exit', (code) => {
+				if (message_received === null) {
+					reject(new Error(`benchmark ${benchmark.label} exited with code ${code}`));
+				} else {
+					fulfil(message_received);
+				}
+			});
+		});
+
+		results.push({
+			benchmark: benchmark.label,
+			.../** @type {object} */ (result)
+		});
+
+		process.stderr.write('\x1b[2K\r');
+	}
+
+	/** @type {NodeJS.Process} */ (process).send(results);
+}
diff --git a/benchmarking/run.js b/benchmarking/run.js
index 80e40a5ff1..e44e816dd0 100644
--- a/benchmarking/run.js
+++ b/benchmarking/run.js
@@ -1,94 +1,149 @@
+import { fork } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 import * as $ from '../packages/svelte/src/internal/client/index.js';
 import { reactivity_benchmarks } from './benchmarks/reactivity/index.js';
 import { ssr_benchmarks } from './benchmarks/ssr/index.js';
 import { with_cpu_profile } from './utils.js';
 
-// e.g. `pnpm bench kairo` to only run the kairo benchmarks
-const filters = process.argv.slice(2);
-
 const PROFILE_DIR = './benchmarking/.profiles';
 
-const suites = [
-	{
-		benchmarks: reactivity_benchmarks.filter(
-			(b) => filters.length === 0 || filters.some((f) => b.label.includes(f))
-		),
-		name: 'reactivity benchmarks'
-	},
-	{
-		benchmarks: ssr_benchmarks.filter(
-			(b) => filters.length === 0 || filters.some((f) => b.label.includes(f))
-		),
-		name: 'server-side rendering benchmarks'
-	}
-].filter((suite) => suite.benchmarks.length > 0);
-
-if (suites.length === 0) {
-	console.log('No benchmarks matched provided filters');
-	process.exit(1);
-}
-
-const COLUMN_WIDTHS = [25, 9, 9];
-const TOTAL_WIDTH = COLUMN_WIDTHS.reduce((a, b) => a + b);
-
-const pad_right = (str, n) => str + ' '.repeat(n - str.length);
-const pad_left = (str, n) => ' '.repeat(n - str.length) + str;
+const single = process.env.BENCH_SINGLE;
 
-let total_time = 0;
-let total_gc_time = 0;
+if (single) {
+	// child mode — run a single benchmark and report the result to the parent
+	const benchmark = [...reactivity_benchmarks, ...ssr_benchmarks].find((b) => b.label === single);
 
-$.push({}, true);
+	if (!benchmark) {
+		throw new Error(`Unknown benchmark ${single}`);
+	}
 
-try {
-	for (const { benchmarks, name } of suites) {
-		let suite_time = 0;
-		let suite_gc_time = 0;
+	$.push({}, true);
+
+	const result = await with_cpu_profile(PROFILE_DIR, benchmark.label, () => benchmark.fn());
+
+	$.pop();
+
+	// exit via the callback so the message is guaranteed to be delivered
+	/** @type {NodeJS.Process} */ (process).send(result, () => process.exit(0));
+} else {
+	// parent mode — run every benchmark in its own child process, so that
+	// heap/GC/JIT state from one benchmark cannot contaminate the others
+
+	// e.g. `pnpm bench kairo` to only run the kairo benchmarks
+	const filters = process.argv.slice(2);
+
+	const suites = [
+		{
+			benchmarks: reactivity_benchmarks.filter(
+				(b) => filters.length === 0 || filters.some((f) => b.label.includes(f))
+			),
+			name: 'reactivity benchmarks'
+		},
+		{
+			benchmarks: ssr_benchmarks.filter(
+				(b) => filters.length === 0 || filters.some((f) => b.label.includes(f))
+			),
+			name: 'server-side rendering benchmarks'
+		}
+	].filter((suite) => suite.benchmarks.length > 0);
 
-		console.log(`\nRunning ${name}...\n`);
-		console.log(
-			pad_right('Benchmark', COLUMN_WIDTHS[0]) +
-				pad_left('Time', COLUMN_WIDTHS[1]) +
-				pad_left('GC time', COLUMN_WIDTHS[2])
-		);
-		console.log('='.repeat(TOTAL_WIDTH));
+	if (suites.length === 0) {
+		console.log('No benchmarks matched provided filters');
+		process.exit(1);
+	}
 
-		for (const benchmark of benchmarks) {
-			const results = await with_cpu_profile(PROFILE_DIR, benchmark.label, () => benchmark.fn());
+	const filename = fileURLToPath(import.meta.url);
+
+	/**
+	 * @param {string} label
+	 * @returns {Promise<{ time: number, gc_time: number }>}
+	 */
+	const run_benchmark = (label) => {
+		return new Promise((fulfil, reject) => {
+			const child = fork(filename, [], {
+				env: {
+					...process.env,
+					BENCH_SINGLE: label
+				}
+			});
+
+			/** @type {{ time: number, gc_time: number } | null} */
+			let result = null;
+
+			child.on('message', (message) => {
+				result = /** @type {{ time: number, gc_time: number }} */ (message);
+			});
+
+			child.on('error', reject);
+
+			child.on('exit', (code) => {
+				if (result === null) {
+					reject(new Error(`benchmark ${label} exited with code ${code}`));
+				} else {
+					fulfil(result);
+				}
+			});
+		});
+	};
+
+	const COLUMN_WIDTHS = [25, 9, 9];
+	const TOTAL_WIDTH = COLUMN_WIDTHS.reduce((a, b) => a + b);
+
+	/** @type {(str: string, n: number) => string} */
+	const pad_right = (str, n) => str + ' '.repeat(n - str.length);
+	/** @type {(str: string, n: number) => string} */
+	const pad_left = (str, n) => ' '.repeat(n - str.length) + str;
+
+	let total_time = 0;
+	let total_gc_time = 0;
+
+	try {
+		for (const { benchmarks, name } of suites) {
+			let suite_time = 0;
+			let suite_gc_time = 0;
+
+			console.log(`\nRunning ${name}...\n`);
+			console.log(
+				pad_right('Benchmark', COLUMN_WIDTHS[0]) +
+					pad_left('Time', COLUMN_WIDTHS[1]) +
+					pad_left('GC time', COLUMN_WIDTHS[2])
+			);
+			console.log('='.repeat(TOTAL_WIDTH));
+
+			for (const benchmark of benchmarks) {
+				const results = await run_benchmark(benchmark.label);
+				console.log(
+					pad_right(benchmark.label, COLUMN_WIDTHS[0]) +
+						pad_left(results.time.toFixed(2), COLUMN_WIDTHS[1]) +
+						pad_left(results.gc_time.toFixed(2), COLUMN_WIDTHS[2])
+				);
+				total_time += results.time;
+				total_gc_time += results.gc_time;
+				suite_time += results.time;
+				suite_gc_time += results.gc_time;
+			}
+
+			console.log('='.repeat(TOTAL_WIDTH));
 			console.log(
-				pad_right(benchmark.label, COLUMN_WIDTHS[0]) +
-					pad_left(results.time.toFixed(2), COLUMN_WIDTHS[1]) +
-					pad_left(results.gc_time.toFixed(2), COLUMN_WIDTHS[2])
+				pad_right('suite', COLUMN_WIDTHS[0]) +
+					pad_left(suite_time.toFixed(2), COLUMN_WIDTHS[1]) +
+					pad_left(suite_gc_time.toFixed(2), COLUMN_WIDTHS[2])
 			);
-			total_time += results.time;
-			total_gc_time += results.gc_time;
-			suite_time += results.time;
-			suite_gc_time += results.gc_time;
+			console.log('='.repeat(TOTAL_WIDTH));
 		}
 
-		console.log('='.repeat(TOTAL_WIDTH));
-		console.log(
-			pad_right('suite', COLUMN_WIDTHS[0]) +
-				pad_left(suite_time.toFixed(2), COLUMN_WIDTHS[1]) +
-				pad_left(suite_gc_time.toFixed(2), COLUMN_WIDTHS[2])
-		);
-		console.log('='.repeat(TOTAL_WIDTH));
-	}
-
-	if (PROFILE_DIR !== null) {
 		console.log(`\nCPU profiles written to ${PROFILE_DIR}`);
+	} catch (e) {
+		// eslint-disable-next-line no-console
+		console.error(e);
+		process.exit(1);
 	}
-} catch (e) {
-	// eslint-disable-next-line no-console
-	console.error(e);
-	process.exit(1);
-}
 
-$.pop();
+	console.log('');
 
-console.log('');
-
-console.log(
-	pad_right('total', COLUMN_WIDTHS[0]) +
-		pad_left(total_time.toFixed(2), COLUMN_WIDTHS[1]) +
-		pad_left(total_gc_time.toFixed(2), COLUMN_WIDTHS[2])
-);
+	console.log(
+		pad_right('total', COLUMN_WIDTHS[0]) +
+			pad_left(total_time.toFixed(2), COLUMN_WIDTHS[1]) +
+			pad_left(total_gc_time.toFixed(2), COLUMN_WIDTHS[2])
+	);
+}
diff --git a/documentation/docs/02-runes/04-$effect.md b/documentation/docs/02-runes/04-$effect.md
index a13fc7bc46..de18add08f 100644
--- a/documentation/docs/02-runes/04-$effect.md
+++ b/documentation/docs/02-runes/04-$effect.md
@@ -205,6 +205,8 @@ In rare cases, you may need to run code _before_ the DOM updates. For this we ca
 </div>
 ```
 
+`$effect.pre` runs before DOM updates that are scheduled after it, not before every DOM mutation in the flush - DOM of parent components may already be updated. When using [await expressions](await-expressions), block updates like `{#if ...}` and `{#each ...}` in the same component also run before `$effect.pre`.
+
 Apart from the timing, `$effect.pre` works exactly like `$effect`.
 
 ## `$effect.tracking`
diff --git a/documentation/docs/02-runes/06-$bindable.md b/documentation/docs/02-runes/06-$bindable.md
index 3675a56b16..a3be662785 100644
--- a/documentation/docs/02-runes/06-$bindable.md
+++ b/documentation/docs/02-runes/06-$bindable.md
@@ -52,3 +52,5 @@ In this case, you can specify a fallback value for when no prop is passed at all
 /// file: FancyInput.svelte
 let { value = $bindable('fallback'), ...props } = $props();
 ```
+
+When a bindable prop has a fallback value, the parent must pass a value other than `undefined` if it uses `bind:`. This avoids ambiguity about which value should apply, since the parent and child should share the same value for a binding.
diff --git a/documentation/docs/03-template-syntax/01-basic-markup.md b/documentation/docs/03-template-syntax/01-basic-markup.md
index feecfe033e..89e01cf1ed 100644
--- a/documentation/docs/03-template-syntax/01-basic-markup.md
+++ b/documentation/docs/03-template-syntax/01-basic-markup.md
@@ -202,7 +202,7 @@ You can add a special comment starting with `@component` that will show up when
 - You can also use code blocks here.
 - Usage:
   ```html
-  <Main name="Arethra">
+  <Main name="Aretha">
   ```
 -->
 <script>
@@ -215,3 +215,14 @@ You can add a special comment starting with `@component` that will show up when
 	</h1>
 </main>
 ````
+
+You can also put JavaScript-style comments within tags between attributes:
+
+```svelte
+<div
+  // this is a comment!
+  data-foo="bar"
+>
+  foo bar
+</div>
+```
diff --git a/documentation/docs/03-template-syntax/11-declaration-tags.md b/documentation/docs/03-template-syntax/11-declaration-tags.md
index e0edaf6a38..2ae1214b9c 100644
--- a/documentation/docs/03-template-syntax/11-declaration-tags.md
+++ b/documentation/docs/03-template-syntax/11-declaration-tags.md
@@ -13,7 +13,7 @@ Declaration tags define local variables inside markup with `const` or `let`:
 
 {#each boxes as box}
 	{const area = box.width * box.height}
-	{const label = `${box.width} ⨉ ${box.height} = ${area}`}
+	{const label = `${box.width} × ${box.height} = ${area}`}
 
 	<p>{label}</p>
 {/each}
diff --git a/documentation/docs/03-template-syntax/12-bind.md b/documentation/docs/03-template-syntax/12-bind.md
index b93f207e71..ee91d607f0 100644
--- a/documentation/docs/03-template-syntax/12-bind.md
+++ b/documentation/docs/03-template-syntax/12-bind.md
@@ -251,6 +251,19 @@ You can give the `<select>` a default value by adding a `selected` attribute to
 </select>
 ```
 
+Since 5.57.0, if a `<select>` has a `defaultValue` and is part of a form, it will revert to that value instead of the empty string when the form is reset. Note that for the initial render the value of the binding takes precedence unless it is `null` or `undefined`.
+
+```svelte
+<form>
+	<select bind:value defaultValue="b">
+		<option>a</option>
+		<option>b</option>
+		<option>c</option>
+	</select>
+	<input type="reset" value="Reset">
+</form>
+```
+
 ## `<audio>`
 
 `<audio>` elements have their own set of bindings — five two-way ones...
diff --git a/documentation/docs/03-template-syntax/14-transition.md b/documentation/docs/03-template-syntax/14-transition.md
index 9b14b7b25b..5f722259b5 100644
--- a/documentation/docs/03-template-syntax/14-transition.md
+++ b/documentation/docs/03-template-syntax/14-transition.md
@@ -53,6 +53,12 @@ Transitions can have parameters.
 {/if}
 ```
 
+## Accessibility
+
+Transitions are driven by the [Web Animations API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API) rather than by CSS. A global `@media (prefers-reduced-motion: reduce)` rule that zeroes `transition-duration` and `animation-duration` therefore has no effect on them.
+
+Use [`prefersReducedMotion`](svelte-motion#prefersReducedMotion) to adjust (or completely disable) the transition accordingly for devices who request reduced motion.
+
 ## Custom transition functions
 
 ```js
diff --git a/documentation/docs/05-special-elements/01-svelte-boundary.md b/documentation/docs/05-special-elements/01-svelte-boundary.md
index e1ad00a50b..41ebee1564 100644
--- a/documentation/docs/05-special-elements/01-svelte-boundary.md
+++ b/documentation/docs/05-special-elements/01-svelte-boundary.md
@@ -109,7 +109,7 @@ By default, error boundaries have no effect on the server — if an error occurs
 
 Since 5.51 you can control this behaviour for boundaries with a `failed` snippet, by calling [`render(...)`](imperative-component-api#render) with a `transformError` function.
 
-> [!NOTE] If you're using Svelte via a framework such as SvelteKit, you most likely don't have direct access to the `render(...)` call — the framework must configure `transformError` on your behalf. SvelteKit will add support for this in the near future, via the [`handleError`](../kit/hooks#Shared-hooks-handleError) hook.
+> [!NOTE] If you're using Svelte via a framework such as SvelteKit, you most likely don't have direct access to the `render(...)` call — the framework must configure `transformError` on your behalf. SvelteKit will add support for this in the near future, via the [`handleError`](../kit/hooks#handleError) hook.
 
 The `transformError` function must return a JSON-stringifiable object which will be used to render the `failed` snippet. This object will be serialized and used to hydrate the snippet in the browser:
 
diff --git a/documentation/docs/06-runtime/02-context.md b/documentation/docs/06-runtime/02-context.md
index 439272df8f..a1e0347b7b 100644
--- a/documentation/docs/06-runtime/02-context.md
+++ b/documentation/docs/06-runtime/02-context.md
@@ -165,9 +165,9 @@ Svelte will warn you if you get it wrong.
 
 Similarly, to pass primitive values through context, use functions as described in [Passing state into functions]($state#Passing-state-into-functions).
 
-## Component testing
+## Mounting components with context
 
-When writing [component tests](testing#Unit-and-component-tests-with-Vitest-Component-testing), it can be useful to create a wrapper component that sets the context in order to check the behaviour of a component that uses it. As of version 5.49, you can do this sort of thing:
+To mount a component with specific context, create a wrapper component that sets the context before rendering the component. This is useful for [component tests](testing#Unit-and-component-tests-with-Vitest-Component-testing), or any other scenario that needs to provide context through `mount`. As of version 5.49, you can do this sort of thing:
 
 ```js
 import { mount, unmount } from 'svelte';
@@ -193,6 +193,8 @@ test('MyComponent', () => {
 
 This approach also works with [`hydrate`](imperative-component-api#hydrate) and [`render`](imperative-component-api#render).
 
+The context set by the wrapper only applies to that mounted component tree. Each call to `mount`, `hydrate` or `render` creates a separate wrapper instance, so the context does not leak into other mounted components.
+
 ## Replacing global state
 
 When you have state shared by many different components, you might be tempted to put it in its own module and just import it wherever it's needed:
diff --git a/documentation/docs/06-runtime/03-lifecycle-hooks.md b/documentation/docs/06-runtime/03-lifecycle-hooks.md
index 95e1c260c1..c714dc2e52 100644
--- a/documentation/docs/06-runtime/03-lifecycle-hooks.md
+++ b/documentation/docs/06-runtime/03-lifecycle-hooks.md
@@ -102,7 +102,7 @@ To implement a chat window that autoscrolls to the bottom when new messages appe
 
 In Svelte 4, we do this with `beforeUpdate`, but this is a flawed approach — it fires before _every_ update, whether it's relevant or not. In the example below, we need to introduce checks like `updatingMessages` to make sure we don't mess with the scroll position when someone toggles dark mode.
 
-With runes, we can use `$effect.pre`, which behaves the same as `$effect` but runs before the DOM is updated. As long as we explicitly reference `messages` inside the effect body, it will run whenever `messages` changes, but _not_ when `theme` changes.
+With runes, we can use `$effect.pre`, which behaves the same as `$effect` but runs before DOM updates scheduled after it (see [$effect.pre]($effect#$effect.pre) for the exact ordering). As long as we explicitly reference `messages` inside the effect body, it will run whenever `messages` changes, but _not_ when `theme` changes.
 
 `beforeUpdate`, and its equally troublesome counterpart `afterUpdate`, are therefore deprecated in Svelte 5.
 
diff --git a/documentation/docs/07-misc/03-typescript.md b/documentation/docs/07-misc/03-typescript.md
index b7f49f9c6f..daa73b5e98 100644
--- a/documentation/docs/07-misc/03-typescript.md
+++ b/documentation/docs/07-misc/03-typescript.md
@@ -170,6 +170,12 @@ If you don't give `$state` an initial value, part of its types will be `undefine
 let count: number = $state();
 ```
 
+You can pass the type directly as a generic parameter to safely handle this. TypeScript will infer the variable as `number | undefined`.
+
+```ts
+let count = $state<number>();
+```
+
 If you know that the variable _will_ be defined before you first use it, use an `as` casting. This is especially useful in the context of classes:
 
 ```ts
diff --git a/documentation/docs/07-misc/99-faq.md b/documentation/docs/07-misc/99-faq.md
index 035629e5ae..a9067b0703 100644
--- a/documentation/docs/07-misc/99-faq.md
+++ b/documentation/docs/07-misc/99-faq.md
@@ -99,7 +99,9 @@ However, you can use any router library. A sampling of available routers are hig
 
 While most mobile apps are written without using JavaScript, if you'd like to leverage your existing Svelte components and knowledge of Svelte when building mobile apps, you can turn a [SvelteKit SPA](https://kit.svelte.dev/docs/single-page-apps) into a mobile app with [Tauri](https://v2.tauri.app/start/frontend/sveltekit/) or [Capacitor](https://capacitorjs.com/solution/svelte). Mobile features like the camera, geolocation, and push notifications are available via plugins for both platforms.
 
-Some work has been completed towards [custom renderer support in Svelte 5](https://github.com/sveltejs/svelte/issues/15470), but this feature is not yet available. The custom rendering API would support additional mobile frameworks like Lynx JS and Svelte Native. Svelte Native was an option available for Svelte 4, but Svelte 5 does not currently support it. Svelte Native lets you write NativeScript apps using Svelte components that contain [NativeScript UI components](https://docs.nativescript.org/ui/) rather than DOM elements, which may be familiar for users coming from React Native.
+You can also write apps in Svelte that compiles to native components by using [Symbiote Native](https://docs.symbiote-native.dev/), which leverages the infrastructure provided by React Native.
+
+Work has been completed towards [custom renderer support in Svelte 5](https://github.com/sveltejs/svelte/issues/15470), but this feature is not yet merged. The custom rendering API will allow support in additional mobile frameworks like Lynx JS and Svelte Native. Symbiote Native will also adopt this API. Svelte Native was an option available for Svelte 4, but Svelte 5 does not currently support it. Svelte Native lets you write NativeScript apps using Svelte components that contain [NativeScript UI components](https://docs.nativescript.org/ui/) rather than DOM elements.
 
 ## Can I tell Svelte not to remove my unused styles?
 
diff --git a/documentation/docs/98-reference/.generated/client-warnings.md b/documentation/docs/98-reference/.generated/client-warnings.md
index 73c97c253c..75eff181f9 100644
--- a/documentation/docs/98-reference/.generated/client-warnings.md
+++ b/documentation/docs/98-reference/.generated/client-warnings.md
@@ -339,27 +339,6 @@ Reactive `$state(...)` proxies and the values they proxy have different identiti
 
 To resolve this, ensure you're comparing values where both values were created with `$state(...)`, or neither were. Note that `$state.raw(...)` will _not_ create a state proxy.
 
-### state_proxy_unmount
-
-```
-Tried to unmount a state proxy, rather than a component
-```
-
-`unmount` was called with a state proxy:
-
-```js
-import { mount, unmount } from 'svelte';
-import Component from './Component.svelte';
-let target = document.body;
-// ---cut---
-let component = $state(mount(Component, { target }));
-
-// later...
-unmount(component);
-```
-
-Avoid using `$state` here. If `component` _does_ need to be reactive for some reason, use `$state.raw` instead.
-
 ### svelte_boundary_reset_noop
 
 ```
diff --git a/documentation/docs/98-reference/.generated/compile-errors.md b/documentation/docs/98-reference/.generated/compile-errors.md
index 0d25173711..02e762dc48 100644
--- a/documentation/docs/98-reference/.generated/compile-errors.md
+++ b/documentation/docs/98-reference/.generated/compile-errors.md
@@ -821,6 +821,18 @@ Cannot use `%rune%` rune in non-runes mode
 Cannot use rune without parentheses
 ```
 
+Runes are keywords rather than values — they can't be assigned to a variable or passed to a function, only called. Referencing one without parentheses is therefore an error...
+
+```js
+let count = $state;
+```
+
+...whether it's a rune like `$state` or one reached through a property, like `$derived.by`. Add the parentheses, along with any arguments the rune expects:
+
+```js
+let count = $state(0);
+```
+
 ### rune_removed
 
 ```
diff --git a/documentation/docs/98-reference/.generated/compile-warnings.md b/documentation/docs/98-reference/.generated/compile-warnings.md
index f372a010a5..237ec105f6 100644
--- a/documentation/docs/98-reference/.generated/compile-warnings.md
+++ b/documentation/docs/98-reference/.generated/compile-warnings.md
@@ -360,7 +360,7 @@ Enforce that heading elements (`h1`, `h2`, etc.) and anchors have content and th
 '%event%' event must be accompanied by '%accompanied_by%' event
 ```
 
-Enforce that `onmouseover` and `onmouseout` are accompanied by `onfocus` and `onblur`, respectively. This helps to ensure that any functionality triggered by these mouse events is also accessible to keyboard users.
+Enforce that `onmouseover` and `onmouseout` are accompanied by `onfocus` (or `onfocusin`) and `onblur` (or `onfocusout`), respectively. This helps to ensure that any functionality triggered by these mouse events is also accessible to keyboard users.
 
 ```svelte
 <!-- A11y: onmouseover must be accompanied by onfocus -->
diff --git a/documentation/docs/98-reference/.generated/shared-errors.md b/documentation/docs/98-reference/.generated/shared-errors.md
index 739bd58b35..d7596fc068 100644
--- a/documentation/docs/98-reference/.generated/shared-errors.md
+++ b/documentation/docs/98-reference/.generated/shared-errors.md
@@ -75,10 +75,10 @@ Certain lifecycle methods can only be used during component initialisation. To f
 ### missing_context
 
 ```
-Context was not set in a parent component
+Context was not set in the current component or any of its ancestors
 ```
 
-The [`createContext()`](svelte#createContext) utility returns a `[get, set]` pair of functions. `get` will throw an error if `set` was not used to set the context in a parent component.
+The [`createContext()`](svelte#createContext) utility returns a `[get, set]` pair of functions. `get` will throw an error if `set` was not used to set the context in the current component or any of its ancestors.
 
 ### snippet_without_render_tag
 
diff --git a/documentation/docs/98-reference/21-svelte-easing.md b/documentation/docs/98-reference/21-svelte-easing.md
index 3f47963cde..a2b49ff4a9 100644
--- a/documentation/docs/98-reference/21-svelte-easing.md
+++ b/documentation/docs/98-reference/21-svelte-easing.md
@@ -2,4 +2,6 @@
 title: svelte/easing
 ---
 
+This module provides a set of functions that allow you to manipulate time values in different ways. It’s particularly useful for animations when combined with the `motion` module. 
+
 > MODULE: svelte/easing
diff --git a/package.json b/package.json
index 0d2fbc7fd6..16fc26bc32 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
   "private": true,
   "type": "module",
   "license": "MIT",
-  "packageManager": "pnpm@10.4.0",
+  "packageManager": "pnpm@10.33.4+sha512.1c67b3b359b2d408119ba1ed289f34b8fc3c6873412bec6fd264fbdc82489e510fcbecb9ce9d22dae7f3b76269d8441046014bdca53b9979cd7a561ad631b800",
   "engines": {
     "pnpm": ">=9.0.0"
   },
@@ -26,10 +26,10 @@
     "bench:debug": "NODE_ENV=production node --allow-natives-syntax --inspect-brk ./benchmarking/run.js"
   },
   "devDependencies": {
+    "@changesets/changelog-github": "1.0.0-next.6",
     "@changesets/cli": "^2.29.8",
     "@eslint/js": "^10.0.0",
     "@sveltejs/eslint-config": "^9.0.0",
-    "@svitejs/changesets-changelog-github-compact": "^1.1.0",
     "@types/node": "^20.11.5",
     "@types/picomatch": "^4.0.2",
     "@vitest/coverage-v8": "^4.1.7",
diff --git a/packages/svelte/CHANGELOG.md b/packages/svelte/CHANGELOG.md
index 80b61facb0..e66b3db109 100644
--- a/packages/svelte/CHANGELOG.md
+++ b/packages/svelte/CHANGELOG.md
@@ -1,5 +1,113 @@
 # svelte
 
+## 5.56.10
+
+### Patch Changes
+
+- fix: preserve CSS escape sequences when printing selectors ([#18667](https://github.com/sveltejs/svelte/pull/18667))
+
+- fix: parse `:nth-child(2n of.foo)` where `of` is not followed by whitespace ([#18611](https://github.com/sveltejs/svelte/pull/18611))
+
+- fix: transform expressions inside labeled statements during server compilation ([#18617](https://github.com/sveltejs/svelte/pull/18617))
+
+- docs: clarify that context lookup includes the current component and all ancestors ([#18581](https://github.com/sveltejs/svelte/pull/18581))
+
+- fix: apply CSS custom properties with falsy values on components ([#18634](https://github.com/sveltejs/svelte/pull/18634))
+
+- fix: correctly print `{#await ... catch x}` et al ([#18645](https://github.com/sveltejs/svelte/pull/18645))
+
+- fix: ignore comments of Program node during migration script ([#18656](https://github.com/sveltejs/svelte/pull/18656))
+
+- fix: reliably resolve append_style to its correct root ([#18614](https://github.com/sveltejs/svelte/pull/18614))
+
+- fix: clean up removed capture event handlers from spread attributes ([#18618](https://github.com/sveltejs/svelte/pull/18618))
+
+- fix: don't corrupt renderer type during SSR's legacy `bind:` retry loop ([#18616](https://github.com/sveltejs/svelte/pull/18616))
+
+- fix: treat concise arrow function bodies as implicit returns when calculating blockers ([#18613](https://github.com/sveltejs/svelte/pull/18613))
+
+- fix: give effect teardowns the value from before the first write in a flush ([#18620](https://github.com/sveltejs/svelte/pull/18620))
+
+- fix: avoid double-calling a derived reference when destructuring `$derived` of another `$derived` during server-side rendering ([#18668](https://github.com/sveltejs/svelte/pull/18668))
+
+- fix: preserve namespaces in CSS type selectors ([#18678](https://github.com/sveltejs/svelte/pull/18678))
+
+- fix: increment private state fields through a non-`this` receiver ([#18622](https://github.com/sveltejs/svelte/pull/18622))
+
+- chore: deduplicate client and server context helpers ([#18580](https://github.com/sveltejs/svelte/pull/18580))
+
+- fix: release `last_propagated_event` after event propagation settles so it no longer retains the last event's target subtree ([#18569](https://github.com/sveltejs/svelte/pull/18569))
+
+- fix: allow custom elements to receive async values as props ([#18661](https://github.com/sveltejs/svelte/pull/18661))
+
+- fix: strip comments from inline `style` values in linear time ([#18553](https://github.com/sveltejs/svelte/pull/18553))
+
+- fix: prevent declaration comments from breaking server derived references ([#18641](https://github.com/sveltejs/svelte/pull/18641))
+
+- perf: make async blocker analysis scale linearly with the number of top-level references ([#18549](https://github.com/sveltejs/svelte/pull/18549))
+
+- fix: preserve short-circuiting for logical assignments to private state fields ([#18594](https://github.com/sveltejs/svelte/pull/18594))
+
+## 5.56.9
+
+### Patch Changes
+
+- fix: skip controlled each fast path while another batch is pending ([#18625](https://github.com/sveltejs/svelte/pull/18625))
+
+- fix: better whitespace handling inside printer ([#18638](https://github.com/sveltejs/svelte/pull/18638))
+
+- fix: don't duplicate comments in attributes ([#18636](https://github.com/sveltejs/svelte/pull/18636))
+
+- fix: preserve CSS comments in the AST printer ([#18637](https://github.com/sveltejs/svelte/pull/18637))
+
+## 5.56.8
+
+### Patch Changes
+
+- fix: call `onerror` and provide a working `reset` when hydrating a failed boundary ([#18556](https://github.com/sveltejs/svelte/pull/18556))
+
+- fix: preserve select selection when spread attributes omit value ([#18561](https://github.com/sveltejs/svelte/pull/18561))
+
+## 5.56.7
+
+### Patch Changes
+
+- chore: provide `indent` option for `print` ([#18474](https://github.com/sveltejs/svelte/pull/18474))
+
+## 5.56.6
+
+### Patch Changes
+
+- perf: skip unnecessary blocker analysis when compiling components without top-level await ([#18548](https://github.com/sveltejs/svelte/pull/18548))
+
+- fix: rerun derived that had an abort controller on reconnection ([#18551](https://github.com/sveltejs/svelte/pull/18551))
+
+## 5.56.5
+
+### Patch Changes
+
+- chore: drop dead code that make TSGO fail ([#18496](https://github.com/sveltejs/svelte/pull/18496))
+
+- fix: don't (re)connect deriveds when read inside branch/root effects ([#18527](https://github.com/sveltejs/svelte/pull/18527))
+
+- fix: skip unnecessary derived effect in earlier batch ([#18525](https://github.com/sveltejs/svelte/pull/18525))
+
+- fix: avoid declaration tag warning in event handlers ([#18500](https://github.com/sveltejs/svelte/pull/18500))
+
+- fix: abort deriveds own AbortSignal when it disconnects ([#18400](https://github.com/sveltejs/svelte/pull/18400))
+
+- fix: ensure `$state.eager()` is correctly transormed for SSR output ([#18530](https://github.com/sveltejs/svelte/pull/18530))
+
+- fix: correctly transform declaration tags during SSR ([#18492](https://github.com/sveltejs/svelte/pull/18492))
+
+- fix: transform computed keys in keyed `{#each}` destructuring patterns ([#18521](https://github.com/sveltejs/svelte/pull/18521))
+
+- fix: chain preprocessor sourcemaps with an empty `sources[0]` instead of dropping them ([#18518](https://github.com/sveltejs/svelte/pull/18518))
+
+- fix: clear previous_task reference after abort in Tween to prevent memory leak on interrupted tweens ([#18541](https://github.com/sveltejs/svelte/pull/18541))
+
+- fix: don't treat declaration tags as parts inside each blocks ([#18507](https://github.com/sveltejs/svelte/pull/18507))
+
 ## 5.56.4
 
 ### Patch Changes
diff --git a/packages/svelte/elements.d.ts b/packages/svelte/elements.d.ts
index daa40635b6..15837f831a 100644
--- a/packages/svelte/elements.d.ts
+++ b/packages/svelte/elements.d.ts
@@ -1352,6 +1352,9 @@ export interface HTMLSelectAttributes extends HTMLAttributes<HTMLSelectElement>
 	required?: boolean | undefined | null;
 	size?: number | undefined | null;
 	value?: any;
+	// needs both casing variants because language tools does lowercase names of non-shorthand attributes
+	defaultValue?: any;
+	defaultvalue?: any;
 
 	'on:change'?: ChangeEventHandler<HTMLSelectElement> | undefined | null;
 	onchange?: ChangeEventHandler<HTMLSelectElement> | undefined | null;
diff --git a/packages/svelte/messages/client-warnings/warnings.md b/packages/svelte/messages/client-warnings/warnings.md
index 58d00f3933..ac2e103ffe 100644
--- a/packages/svelte/messages/client-warnings/warnings.md
+++ b/packages/svelte/messages/client-warnings/warnings.md
@@ -295,25 +295,6 @@ To silence the warning, ensure that `value`:
 
 To resolve this, ensure you're comparing values where both values were created with `$state(...)`, or neither were. Note that `$state.raw(...)` will _not_ create a state proxy.
 
-## state_proxy_unmount
-
-> Tried to unmount a state proxy, rather than a component
-
-`unmount` was called with a state proxy:
-
-```js
-import { mount, unmount } from 'svelte';
-import Component from './Component.svelte';
-let target = document.body;
-// ---cut---
-let component = $state(mount(Component, { target }));
-
-// later...
-unmount(component);
-```
-
-Avoid using `$state` here. If `component` _does_ need to be reactive for some reason, use `$state.raw` instead.
-
 ## svelte_boundary_reset_noop
 
 > A `<svelte:boundary>` `reset` function only resets the boundary the first time it is called
diff --git a/packages/svelte/messages/compile-errors/script.md b/packages/svelte/messages/compile-errors/script.md
index 743fe31fde..9980db4c19 100644
--- a/packages/svelte/messages/compile-errors/script.md
+++ b/packages/svelte/messages/compile-errors/script.md
@@ -186,6 +186,18 @@ This turned out to be buggy and unpredictable, particularly when working with de
 
 > Cannot use rune without parentheses
 
+Runes are keywords rather than values — they can't be assigned to a variable or passed to a function, only called. Referencing one without parentheses is therefore an error...
+
+```js
+let count = $state;
+```
+
+...whether it's a rune like `$state` or one reached through a property, like `$derived.by`. Add the parentheses, along with any arguments the rune expects:
+
+```js
+let count = $state(0);
+```
+
 ## rune_removed
 
 > The `%name%` rune has been removed
diff --git a/packages/svelte/messages/compile-warnings/a11y.md b/packages/svelte/messages/compile-warnings/a11y.md
index 1f48ef0dd5..915032bb93 100644
--- a/packages/svelte/messages/compile-warnings/a11y.md
+++ b/packages/svelte/messages/compile-warnings/a11y.md
@@ -300,7 +300,7 @@ Enforce that heading elements (`h1`, `h2`, etc.) and anchors have content and th
 
 > '%event%' event must be accompanied by '%accompanied_by%' event
 
-Enforce that `onmouseover` and `onmouseout` are accompanied by `onfocus` and `onblur`, respectively. This helps to ensure that any functionality triggered by these mouse events is also accessible to keyboard users.
+Enforce that `onmouseover` and `onmouseout` are accompanied by `onfocus` (or `onfocusin`) and `onblur` (or `onfocusout`), respectively. This helps to ensure that any functionality triggered by these mouse events is also accessible to keyboard users.
 
 ```svelte
 <!-- A11y: onmouseover must be accompanied by onfocus -->
diff --git a/packages/svelte/messages/shared-errors/errors.md b/packages/svelte/messages/shared-errors/errors.md
index 3ff474768e..43dca57ac8 100644
--- a/packages/svelte/messages/shared-errors/errors.md
+++ b/packages/svelte/messages/shared-errors/errors.md
@@ -62,9 +62,9 @@ Certain lifecycle methods can only be used during component initialisation. To f
 
 ## missing_context
 
-> Context was not set in a parent component
+> Context was not set in the current component or any of its ancestors
 
-The [`createContext()`](svelte#createContext) utility returns a `[get, set]` pair of functions. `get` will throw an error if `set` was not used to set the context in a parent component.
+The [`createContext()`](svelte#createContext) utility returns a `[get, set]` pair of functions. `get` will throw an error if `set` was not used to set the context in the current component or any of its ancestors.
 
 ## snippet_without_render_tag
 
diff --git a/packages/svelte/package.json b/packages/svelte/package.json
index 34fa68c8a7..2da4ee428d 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.56.4",
+  "version": "5.56.10",
   "type": "module",
   "types": "./types/index.d.ts",
   "engines": {
diff --git a/packages/svelte/src/ambient.d.ts b/packages/svelte/src/ambient.d.ts
index ed0a004fa1..a9b2cebe1a 100644
--- a/packages/svelte/src/ambient.d.ts
+++ b/packages/svelte/src/ambient.d.ts
@@ -261,7 +261,7 @@ declare function $effect(fn: () => void | (() => void)): void;
 declare namespace $effect {
 	/**
 	 * Runs code right before a component is mounted to the DOM, and then whenever its dependencies change, i.e. `$state` or `$derived` values.
-	 * The timing of the execution is right before the DOM is updated.
+	 * The timing of the execution is right before the DOM that comes after it is updated; parent DOM may already have been updated by the time it runs.
 	 *
 	 * Example:
 	 * ```ts
diff --git a/packages/svelte/src/compiler/index.js b/packages/svelte/src/compiler/index.js
index 1d822514b9..599206ac6a 100644
--- a/packages/svelte/src/compiler/index.js
+++ b/packages/svelte/src/compiler/index.js
@@ -141,7 +141,8 @@ export function parseCss(source) {
 		type: 'StyleSheetFile',
 		start: 0,
 		end: source.length,
-		children
+		children,
+		comments: parser.css_comments
 	};
 }
 
diff --git a/packages/svelte/src/compiler/migrate/index.js b/packages/svelte/src/compiler/migrate/index.js
index 0370155c12..3baef3ecae 100644
--- a/packages/svelte/src/compiler/migrate/index.js
+++ b/packages/svelte/src/compiler/migrate/index.js
@@ -1590,7 +1590,12 @@ function migrate_slot_usage(node, path, state) {
  */
 function extract_type_and_comment(declarator, state, path) {
 	const str = state.str;
-	const parent = path.at(-1);
+	let parent = path.at(-1);
+
+	if (parent?.type === 'Program') {
+		// We don't want comments from the program node
+		parent = undefined;
+	}
 
 	// Try to find jsdoc above the declaration
 	let comment_node = /** @type {Node} */ (parent)?.leadingComments?.at(-1);
diff --git a/packages/svelte/src/compiler/phases/1-parse/acorn.js b/packages/svelte/src/compiler/phases/1-parse/acorn.js
index fb60c228c5..070183f984 100644
--- a/packages/svelte/src/compiler/phases/1-parse/acorn.js
+++ b/packages/svelte/src/compiler/phases/1-parse/acorn.js
@@ -59,7 +59,7 @@ export function parse(source, comments, typescript, is_script) {
 
 		return /** @type {Program} */ (ast);
 	} catch (err) {
-		// TODO the `return` in necessary for TS<7 due to a bug; otherwise
+		// TODO the `return` is necessary for TS<7 due to a bug; otherwise
 		// the `finally` block is regarded as unreachable
 		return handle_parse_error(err);
 	} finally {
diff --git a/packages/svelte/src/compiler/phases/1-parse/index.js b/packages/svelte/src/compiler/phases/1-parse/index.js
index 02d1629c99..fa7b292640 100644
--- a/packages/svelte/src/compiler/phases/1-parse/index.js
+++ b/packages/svelte/src/compiler/phases/1-parse/index.js
@@ -50,6 +50,9 @@ export class Parser {
 	/** */
 	index = 0;
 
+	/** @type {AST.CSS.CSSComment[]} */
+	css_comments = [];
+
 	/**
 	 * Creates a minimal parser instance for CSS-only parsing.
 	 * Skips Svelte component parsing setup.
@@ -61,6 +64,7 @@ export class Parser {
 		parser.template = source;
 		parser.index = 0;
 		parser.loose = false;
+		parser.css_comments = [];
 		return parser;
 	}
 
diff --git a/packages/svelte/src/compiler/phases/1-parse/read/style.js b/packages/svelte/src/compiler/phases/1-parse/read/style.js
index 160e5da277..df036d0d33 100644
--- a/packages/svelte/src/compiler/phases/1-parse/read/style.js
+++ b/packages/svelte/src/compiler/phases/1-parse/read/style.js
@@ -7,8 +7,11 @@ const REGEX_CLOSING_BRACKET = /[\s\]]/;
 const REGEX_ATTRIBUTE_FLAGS = /[a-zA-Z]+/y; // only `i` and `s` are valid today, but make it future-proof
 const REGEX_COMBINATOR = /(\+|~|>|\|\|)/y;
 const REGEX_PERCENTAGE = /\d+(\.\d+)?%/y;
+// `of` must be preceded by whitespace, otherwise it would be part of the `<an+b>` token
+// (`2nof` is a single dimension token). It does not need to be followed by whitespace,
+// because a `.`, `#`, `[`, `*`, `:` or `&` already ends the `of` identifier — minifiers rely on that
 const REGEX_NTH_OF =
-	/(even|odd|\+?(\d+|\d*n(\s*[+-]\s*\d+)?)|-\d*n(\s*\+\s*\d+))((?=\s*[,)])|\s+of\s+)/y;
+	/(even|odd|\+?(\d+|\d*n(\s*[+-]\s*\d+)?)|-\d*n(\s*\+\s*\d+))((?=\s*[,)])|\s+of(\s+|(?=[.#[*:&])))/y;
 const REGEX_WHITESPACE_OR_COLON = /[\s:]/;
 const REGEX_LEADING_HYPHEN_OR_DIGIT = /-?\d/y;
 const REGEX_VALID_IDENTIFIER_CHAR = /[a-zA-Z0-9_-]/;
@@ -24,6 +27,7 @@ const REGEX_HTML_COMMENT_CLOSE = /-->/;
  */
 export default function read_style(parser, start, attributes) {
 	const content_start = parser.index;
+	parser.css_comments = [];
 	const children = read_body(parser, (p) => p.match('</style') || p.index >= p.template.length);
 	const content_end = parser.index;
 
@@ -36,6 +40,7 @@ export default function read_style(parser, start, attributes) {
 		end: parser.index,
 		attributes,
 		children,
+		comments: parser.css_comments,
 		content: {
 			start: content_start,
 			end: content_end,
@@ -202,15 +207,18 @@ function read_selector(parser, inside_pseudo_class = false) {
 			});
 		} else if (parser.eat('*')) {
 			let name = '*';
+			/** @type {string | undefined} */
+			let namespace;
 
 			if (parser.eat('|')) {
-				// * is the namespace (which we ignore)
-				name = read_identifier(parser);
+				namespace = name;
+				name = parser.eat('*') ? '*' : read_identifier(parser);
 			}
 
 			relative_selector.selectors.push({
 				type: 'TypeSelector',
 				name,
+				...(namespace !== undefined && { namespace }),
 				start,
 				end: parser.index
 			});
@@ -229,18 +237,22 @@ function read_selector(parser, inside_pseudo_class = false) {
 				end: parser.index
 			});
 		} else if (parser.eat('::')) {
+			const name = read_identifier(parser);
+			/** @type {AST.CSS.SelectorList | null} */
+			let args = null;
+
+			if (parser.eat('(')) {
+				args = read_selector_list(parser, true);
+				parser.eat(')', true);
+			}
+
 			relative_selector.selectors.push({
 				type: 'PseudoElementSelector',
-				name: read_identifier(parser),
+				name,
 				start,
-				end: parser.index
+				end: parser.index,
+				...(args && { args })
 			});
-			// We read the inner selectors of a pseudo element to ensure it parses correctly,
-			// but we don't do anything with the result.
-			if (parser.eat('(')) {
-				read_selector_list(parser, true);
-				parser.eat(')', true);
-			}
 		} else if (parser.eat(':')) {
 			const name = read_identifier(parser);
 
@@ -308,22 +320,25 @@ function read_selector(parser, inside_pseudo_class = false) {
 			});
 		} else if (!parser.match_regex(REGEX_COMBINATOR)) {
 			let name = read_identifier(parser);
+			/** @type {string | undefined} */
+			let namespace;
 
 			if (parser.eat('|')) {
-				// we ignore the namespace when trying to find matching element classes
-				name = read_identifier(parser);
+				namespace = name;
+				name = parser.eat('*') ? '*' : read_identifier(parser);
 			}
 
 			relative_selector.selectors.push({
 				type: 'TypeSelector',
 				name,
+				...(namespace !== undefined && { namespace }),
 				start,
 				end: parser.index
 			});
 		}
 
 		const index = parser.index;
-		allow_comment_or_whitespace(parser);
+		allow_comment_or_whitespace(parser, false);
 
 		if (parser.match(',') || (inside_pseudo_class ? parser.match(')') : parser.match('{'))) {
 			// rewind, so we know whether to continue building the selector list
@@ -449,7 +464,7 @@ function read_block_item(parser) {
 	// read ahead to understand whether we're dealing with a declaration or a nested rule.
 	// this involves some duplicated work, but avoids a try-catch that would disguise errors
 	const start = parser.index;
-	read_value(parser);
+	read_value(parser, false);
 	const char = parser.template[parser.index];
 	parser.index = start;
 
@@ -492,10 +507,13 @@ function read_declaration(parser) {
 
 /**
  * @param {Parser} parser
+ * @param {boolean} [capture_comments]
  * @returns {string}
  */
-function read_value(parser) {
+function read_value(parser, capture_comments = true) {
 	let value = '';
+	/** @type {AST.CSS.CSSComment[]} */
+	const value_comments = [];
 	let escaped = false;
 	let in_url = false;
 
@@ -523,6 +541,13 @@ function read_value(parser) {
 		} else if (char === '(' && value.slice(-3) === 'url') {
 			in_url = true;
 		} else if ((char === ';' || char === '{' || char === '}') && !in_url && !quote_mark) {
+			const leading_whitespace = value.length - value.trimStart().length;
+			for (const comment of value_comments) {
+				comment.position = Math.max(
+					0,
+					/** @type {number} */ (comment.position) - leading_whitespace
+				);
+			}
 			return value.trim();
 		} else if (
 			char === '/' &&
@@ -530,13 +555,11 @@ function read_value(parser) {
 			!quote_mark &&
 			parser.template[parser.index + 1] === '*'
 		) {
-			parser.index += 2;
-			while (parser.index < parser.template.length) {
-				if (parser.template[parser.index] === '*' && parser.template[parser.index + 1] === '/') {
-					parser.index += 2;
-					break;
-				}
-				parser.index++;
+			const comment = read_comment(parser);
+			if (capture_comments) {
+				comment.position = value.length;
+				parser.css_comments.push(comment);
+				value_comments.push(comment);
 			}
 			continue;
 		}
@@ -600,7 +623,8 @@ function read_identifier(parser) {
 		if (char === '\\') {
 			const sequence = parser.match_regex(REGEX_UNICODE_SEQUENCE);
 			if (sequence) {
-				identifier += String.fromCodePoint(parseInt(sequence.slice(1), 16));
+				const character = String.fromCodePoint(parseInt(sequence.slice(1), 16));
+				identifier += character === '\\' ? '\\\\' : character;
 				parser.index += sequence.length;
 			} else {
 				identifier += '\\' + parser.template[parser.index + 1];
@@ -624,13 +648,16 @@ function read_identifier(parser) {
 	return identifier;
 }
 
-/** @param {Parser} parser */
-function allow_comment_or_whitespace(parser) {
+/**
+ * @param {Parser} parser
+ * @param {boolean} [capture_comments]
+ */
+function allow_comment_or_whitespace(parser, capture_comments = true) {
 	parser.allow_whitespace();
 	while (parser.match('/*') || parser.match('<!--')) {
-		if (parser.eat('/*')) {
-			parser.read_until(REGEX_COMMENT_CLOSE);
-			parser.eat('*/', true);
+		if (parser.match('/*')) {
+			const comment = read_comment(parser);
+			if (capture_comments) parser.css_comments.push(comment);
 		}
 
 		if (parser.eat('<!--')) {
@@ -642,6 +669,25 @@ function allow_comment_or_whitespace(parser) {
 	}
 }
 
+/**
+ * @param {Parser} parser
+ * @returns {AST.CSS.CSSComment}
+ */
+function read_comment(parser) {
+	const start = parser.index;
+	parser.eat('/*', true);
+	const value = parser.read_until(REGEX_COMMENT_CLOSE);
+	parser.eat('*/', true);
+	const end = parser.index;
+
+	return {
+		type: 'CSSComment',
+		value,
+		start,
+		end
+	};
+}
+
 /**
  * Parse standalone CSS content (not wrapped in `<style>`).
  * @param {Parser} parser
diff --git a/packages/svelte/src/compiler/phases/1-parse/utils/html.js b/packages/svelte/src/compiler/phases/1-parse/utils/html.js
index a0c2a5b06f..ccb2005054 100644
--- a/packages/svelte/src/compiler/phases/1-parse/utils/html.js
+++ b/packages/svelte/src/compiler/phases/1-parse/utils/html.js
@@ -20,7 +20,7 @@ function reg_exp_entity(entity_name, is_attribute_value) {
 
 /** @param {boolean} is_attribute_value */
 function get_entity_pattern(is_attribute_value) {
-	const reg_exp_num = '#(?:x[a-fA-F\\d]+|\\d+)(?:;)?';
+	const reg_exp_num = '#(?:[xX][a-fA-F\\d]+|\\d+)(?:;)?';
 	const reg_exp_entities = Object.keys(entities).map(
 		/** @param {any} entity_name */ (entity_name) => reg_exp_entity(entity_name, is_attribute_value)
 	);
@@ -50,7 +50,7 @@ export function decode_character_references(html, is_attribute_value) {
 			// Handle named entities
 			if (entity[0] !== '#') {
 				code = entities[entity];
-			} else if (entity[1] === 'x') {
+			} else if (entity[1] === 'x' || entity[1] === 'X') {
 				code = parseInt(entity.substring(2), 16);
 			} else {
 				code = parseInt(entity.substring(1), 10);
@@ -60,7 +60,7 @@ export function decode_character_references(html, is_attribute_value) {
 				return match;
 			}
 
-			return String.fromCodePoint(validate_code(code));
+			return String.fromCodePoint(validate_code(code, is_attribute_value));
 		}
 	);
 }
@@ -75,10 +75,15 @@ const NUL = 0;
 // Also see: https://en.wikipedia.org/wiki/Plane_(Unicode)
 // Also see: https://html.spec.whatwg.org/multipage/parsing.html#preprocessing-the-input-stream
 
-/** @param {number} code */
-function validate_code(code) {
-	// line feed becomes generic whitespace
-	if (code === 10) {
+/**
+ * @param {number} code
+ * @param {boolean} is_attribute_value
+ */
+function validate_code(code, is_attribute_value) {
+	// line feed becomes generic whitespace, since it is collapsed along with the
+	// surrounding whitespace anyway. In an attribute value it is significant, so it
+	// is left alone there
+	if (code === 10 && !is_attribute_value) {
 		return 32;
 	}
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js b/packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
index d6052c9c3e..023d4e768e 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
@@ -312,6 +312,9 @@ const css_visitors = {
 		}
 
 		context.next();
+	},
+	PseudoElementSelector() {
+		// Don't analyse these
 	}
 };
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/css/css-prune.js b/packages/svelte/src/compiler/phases/2-analyze/css/css-prune.js
index f5909dacaf..10ee7c69b2 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/css/css-prune.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/css/css-prune.js
@@ -122,6 +122,13 @@ const any_selector = {
  */
 const seen = new Set();
 
+/**
+ * @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement | Compiler.AST.RenderTag | Compiler.AST.Component | Compiler.AST.SvelteComponent | Compiler.AST.SvelteSelf} node
+ */
+function is_inside_svelte_head(node) {
+	return node.metadata.path.some((ancestor) => ancestor.type === 'SvelteHead');
+}
+
 /**
  *
  * @param {Compiler.AST.CSS.StyleSheet} stylesheet
@@ -143,6 +150,9 @@ export function prune(stylesheet, elements) {
 				seen.clear();
 
 				if (
+					// Elements rendered through <svelte:head> are not style-scopable.
+					// Prevent css hash injection (class="s-...") on tags like <meta>, <link>, <script>.
+					!is_inside_svelte_head(element) &&
 					apply_selector(
 						selectors,
 						/** @type {Compiler.AST.CSS.Rule} */ (node.metadata.rule),
diff --git a/packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js b/packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js
index 238c83f00e..0964be1615 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js
@@ -23,6 +23,9 @@ const visitors = {
 			context.next();
 		}
 	},
+	PseudoElementSelector() {
+		// Don't analyse these
+	},
 	ComplexSelector(node, context) {
 		if (
 			!node.metadata.used &&
diff --git a/packages/svelte/src/compiler/phases/2-analyze/index.js b/packages/svelte/src/compiler/phases/2-analyze/index.js
index 5802bb8807..36f55753a2 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/index.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/index.js
@@ -289,7 +289,7 @@ export function analyze_module(source, options) {
 		runes: true,
 		immutable: true,
 		tracing: false,
-		async_deriveds: new Set(),
+		async_deriveds: new Map(),
 		comments,
 		classes: new Map(),
 		pickled_awaits: new Set()
@@ -561,7 +561,7 @@ export function analyze_component(root, source, options) {
 		source,
 		snippet_renderers: new Map(),
 		snippets: new Set(),
-		async_deriveds: new Set(),
+		async_deriveds: new Map(),
 		pickled_awaits: new Set(),
 		instance_body: {
 			sync: [],
@@ -836,6 +836,11 @@ export function analyze_component(root, source, options) {
 					} else {
 						e.export_undefined(specifier, name);
 					}
+				} else if (binding.initial?.type === 'SnippetBlock') {
+					// If a snippet is exported, a consumer could only import this named export and not the default export (the component).
+					// In this case we need to set hasGlobal of our output to true so that e.g. vite-plugin-svelte does not tell Vite to
+					// tree-shake the CSS if the default export is not used.
+					analysis.css.has_global = true;
 				}
 			}
 		}
@@ -962,7 +967,7 @@ function calculate_blockers(instance, analysis) {
 	 * @param {Set<Binding>} touched
 	 * @param {Set<ESTree.Node>} seen
 	 */
-	const touch = (expression, scope, touched, seen = new Set()) => {
+	const touch = (expression, scope, touched, seen) => {
 		if (seen.has(expression)) return;
 		seen.add(expression);
 
@@ -1019,6 +1024,13 @@ function calculate_blockers(instance, analysis) {
 			}
 		}
 
+		// Share seen nodes across calls so transitive assignments are only visited once.
+		// Keep separate read/write state because the target sets can differ.
+		/** @type {Set<ESTree.Node>} */
+		const writes_seen = new Set();
+		/** @type {Set<ESTree.Node>} */
+		const reads_seen = new Set();
+
 		walk(
 			node,
 			{ scope },
@@ -1048,13 +1060,7 @@ function calculate_blockers(instance, analysis) {
 					const rune = get_rune(node, context.state.scope);
 					if (rune === '$effect') return;
 
-					/** @type {Set<Binding>} */
-					const touched = new Set();
-					touch(node, context.state.scope, touched);
-
-					for (const b of touched) {
-						writes.add(b);
-					}
+					touch(node, context.state.scope, writes, writes_seen);
 				},
 				Identifier(node, context) {
 					const parent = /** @type {ESTree.Node} */ (context.path.at(-1));
@@ -1070,7 +1076,7 @@ function calculate_blockers(instance, analysis) {
 					// might be called immediately, so we have to touch all references within it. Example:
 					// function foo() { return () => blocker; } foo(); // blocker is touched
 					if (node.argument) {
-						touch(node.argument, context.state.scope, reads);
+						touch(node.argument, context.state.scope, reads, reads_seen);
 					}
 				},
 				// don't look inside functions until they are called
@@ -1225,8 +1231,29 @@ function calculate_blockers(instance, analysis) {
 		}
 	}
 
+	// With no top-level await, no binding can have a blocker and function tracing
+	// cannot affect the output.
+	if (!awaited) return;
+
 	flush_sync_group();
 
+	// a store subscription must wait on whatever blocks the store itself; this must happen
+	// before function tracing so that functions reading `$store` inherit the blocker
+	for (const [name, binding] of instance.scope.declarations) {
+		if (binding.kind !== 'store_sub') continue;
+
+		const store_blocker = instance.scope.get(name.slice(1))?.blocker;
+		if (!store_blocker) continue;
+
+		if (
+			!binding.blocker ||
+			/** @type {ESTree.SimpleLiteral & { value: number }} */ (binding.blocker.property).value <
+				/** @type {ESTree.SimpleLiteral & { value: number }} */ (store_blocker.property).value
+		) {
+			binding.blocker = store_blocker;
+		}
+	}
+
 	for (const fn of functions) {
 		/** @type {Set<Binding>} */
 		const reads_writes = new Set();
@@ -1235,12 +1262,15 @@ function calculate_blockers(instance, analysis) {
 				? /** @type {ESTree.FunctionExpression | ESTree.ArrowFunctionExpression} */ (fn.init)
 				: fn;
 
-		trace_references(
-			init.body,
-			reads_writes,
-			reads_writes,
-			/** @type {Scope} */ (instance.scopes.get(init))
-		);
+		const fn_scope = /** @type {Scope} */ (instance.scopes.get(init));
+
+		if (init.body.type === 'BlockStatement') {
+			trace_references(init.body, reads_writes, reads_writes, fn_scope);
+		} else {
+			// A concise arrow body is an implicit return, so treat it like the
+			// `ReturnStatement` visitor in `trace_references` would.
+			touch(init.body, fn_scope, reads_writes, new Set());
+		}
 
 		const max = [...reads_writes].reduce((max, binding) => {
 			if (binding.blocker) {
@@ -1314,7 +1344,8 @@ function order_reactive_statements(unsorted_reactive_declarations) {
 	 * @returns
 	 */
 	const add_declaration = (node, declaration) => {
-		if ([...reactive_declarations.values()].includes(declaration)) return;
+		// Visited set: each ReactiveStatement is stored under exactly one LabeledStatement node
+		if (reactive_declarations.has(node)) return;
 
 		for (const binding of declaration.dependencies) {
 			if (declaration.assignments.has(binding)) continue;
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitExpression.js
index 5a54d62471..c29f469ad0 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitExpression.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitExpression.js
@@ -1,6 +1,7 @@
 /** @import { AwaitExpression, Expression, SpreadElement, Property } from 'estree' */
 /** @import { Context } from '../types' */
 /** @import { AST } from '#compiler' */
+/** @import { ExpressionMetadata } from '../../nodes.js' */
 import * as e from '../../../errors.js';
 
 /**
@@ -10,15 +11,20 @@ import * as e from '../../../errors.js';
 export function AwaitExpression(node, context) {
 	const tla = context.state.ast_type === 'instance' && context.state.function_depth === 1;
 
-	// preserve context for awaits that precede other expressions in template or `$derived(...)`
 	if (
 		is_reactive_expression(
 			context.path,
 			context.state.derived_function_depth === context.state.function_depth
-		) &&
-		!is_last_evaluated_expression(context.path, node)
+		)
 	) {
-		context.state.analysis.pickled_awaits.add(node);
+		const expression = /** @type {ExpressionMetadata} */ (context.state.expression);
+
+		// preserve context for awaits that precede other expressions in template or `$derived(...)`,
+		// and for any await that follows one, so the restored context ends at the next suspension
+		if (expression.has_pickled_await || !is_last_evaluated_expression(context.path, node)) {
+			context.state.analysis.pickled_awaits.add(node);
+			expression.has_pickled_await = true;
+		}
 	}
 
 	let suspend = tla;
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
index d3524af4db..312a93e5fd 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
@@ -253,7 +253,7 @@ export function CallExpression(node, context) {
 		});
 
 		if (expression.has_await) {
-			context.state.analysis.async_deriveds.add(node);
+			context.state.analysis.async_deriveds.set(node, expression);
 		}
 
 		// Tell surrounding declaration tag about metadata for correct calculation of blockers etc
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/DeclarationTag.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/DeclarationTag.js
index 52e9480838..2f72b16c72 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/DeclarationTag.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/DeclarationTag.js
@@ -43,7 +43,8 @@ export function DeclarationTag(node, context) {
  */
 export function mark_async_declaration(context, metadata, declarations) {
 	const has_await = metadata.expression.has_await;
-	const blockers = [...metadata.expression.dependencies]
+	// reads inside closures must block too, like they do in template expressions
+	const blockers = [...metadata.expression.references]
 		.map((dep) => dep.blocker)
 		.filter((b) => b !== null && b.object !== context.state.async_consts?.id);
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportNamedDeclaration.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportNamedDeclaration.js
index 5b8d9ba053..dec6ebe2b4 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportNamedDeclaration.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExportNamedDeclaration.js
@@ -1,4 +1,4 @@
-/** @import { ExportNamedDeclaration, Identifier } from 'estree' */
+/** @import { ExportNamedDeclaration, Identifier, VariableDeclaration } from 'estree' */
 /** @import { Context } from '../types' */
 import * as e from '../../../errors.js';
 import { extract_identifiers } from '../../../utils/ast.js';
@@ -23,15 +23,6 @@ export function ExportNamedDeclaration(node, context) {
 	}
 
 	if (node.declaration?.type === 'VariableDeclaration') {
-		// in runes mode, forbid `export let`
-		if (
-			context.state.analysis.runes &&
-			context.state.ast_type === 'instance' &&
-			node.declaration.kind === 'let'
-		) {
-			e.legacy_export_invalid(node);
-		}
-
 		for (const declarator of node.declaration.declarations) {
 			for (const id of extract_identifiers(declarator.id)) {
 				const binding = context.state.scope.get(id.name);
@@ -46,6 +37,15 @@ export function ExportNamedDeclaration(node, context) {
 				}
 			}
 		}
+
+		// in runes mode, forbid `export let`
+		if (
+			context.state.analysis.runes &&
+			context.state.ast_type === 'instance' &&
+			node.declaration.kind === 'let'
+		) {
+			e.legacy_export_invalid(node);
+		}
 	}
 
 	if (context.state.analysis.runes) {
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteBody.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteBody.js
index 82bc592c14..39b559b32f 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteBody.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteBody.js
@@ -3,6 +3,7 @@
 import * as e from '../../../errors.js';
 import { is_event_attribute } from '../../../utils/ast.js';
 import { disallow_children } from './shared/special-element.js';
+import { check_global_event_reference } from './shared/utils.js';
 
 /**
  * @param {AST.SvelteBody} node
@@ -11,10 +12,9 @@ import { disallow_children } from './shared/special-element.js';
 export function SvelteBody(node, context) {
 	disallow_children(node);
 	for (const attribute of node.attributes) {
-		if (
-			attribute.type === 'SpreadAttribute' ||
-			(attribute.type === 'Attribute' && !is_event_attribute(attribute))
-		) {
+		if (attribute.type === 'Attribute' && is_event_attribute(attribute)) {
+			check_global_event_reference(attribute, context);
+		} else if (attribute.type === 'SpreadAttribute' || attribute.type === 'Attribute') {
 			e.svelte_body_illegal_attribute(attribute);
 		}
 	}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteDocument.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteDocument.js
index fe54ebf30d..23e984f607 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteDocument.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteDocument.js
@@ -3,6 +3,7 @@
 import { disallow_children } from './shared/special-element.js';
 import * as e from '../../../errors.js';
 import { is_event_attribute } from '../../../utils/ast.js';
+import { check_global_event_reference } from './shared/utils.js';
 
 /**
  * @param {AST.SvelteDocument} node
@@ -12,10 +13,9 @@ export function SvelteDocument(node, context) {
 	disallow_children(node);
 
 	for (const attribute of node.attributes) {
-		if (
-			attribute.type === 'SpreadAttribute' ||
-			(attribute.type === 'Attribute' && !is_event_attribute(attribute))
-		) {
+		if (attribute.type === 'Attribute' && is_event_attribute(attribute)) {
+			check_global_event_reference(attribute, context);
+		} else if (attribute.type === 'SpreadAttribute' || attribute.type === 'Attribute') {
 			e.illegal_element_attribute(attribute, 'svelte:document');
 		}
 	}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteWindow.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteWindow.js
index 20f5abc5d6..5281c7a635 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteWindow.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteWindow.js
@@ -3,6 +3,7 @@
 import { disallow_children } from './shared/special-element.js';
 import * as e from '../../../errors.js';
 import { is_event_attribute } from '../../../utils/ast.js';
+import { check_global_event_reference } from './shared/utils.js';
 
 /**
  * @param {AST.SvelteWindow} node
@@ -12,10 +13,9 @@ export function SvelteWindow(node, context) {
 	disallow_children(node);
 
 	for (const attribute of node.attributes) {
-		if (
-			attribute.type === 'SpreadAttribute' ||
-			(attribute.type === 'Attribute' && !is_event_attribute(attribute))
-		) {
+		if (attribute.type === 'Attribute' && is_event_attribute(attribute)) {
+			check_global_event_reference(attribute, context);
+		} else if (attribute.type === 'SpreadAttribute' || attribute.type === 'Attribute') {
 			e.illegal_element_attribute(attribute, 'svelte:window');
 		}
 	}
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 a6e801cf5a..e09ab018a8 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
@@ -373,11 +373,23 @@ export function check_element(node, context) {
 		}
 	}
 
-	if (!has_spread && handlers.has('mouseover') && !handlers.has('focus')) {
+	// `focus`/`blur` don't bubble, so an element that isn't focusable itself can only be notified
+	// about focus changes inside it through `focusin`/`focusout` — accept those as well
+	if (
+		!has_spread &&
+		handlers.has('mouseover') &&
+		!handlers.has('focus') &&
+		!handlers.has('focusin')
+	) {
 		w.a11y_mouse_events_have_key_events(node, 'mouseover', 'focus');
 	}
 
-	if (!has_spread && handlers.has('mouseout') && !handlers.has('blur')) {
+	if (
+		!has_spread &&
+		handlers.has('mouseout') &&
+		!handlers.has('blur') &&
+		!handlers.has('focusout')
+	) {
 		w.a11y_mouse_events_have_key_events(node, 'mouseout', 'blur');
 	}
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js
index ff02dee02a..6a0c58ca30 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js
@@ -9,6 +9,7 @@ import {
 	validate_attribute_name,
 	validate_slot_attribute
 } from './attribute.js';
+import { check_global_event_reference } from './utils.js';
 
 const EVENT_MODIFIERS = [
 	'preventDefault',
@@ -64,14 +65,7 @@ export function validate_element(node, context) {
 					e.attribute_invalid_event_handler(attribute);
 				}
 
-				const value = get_attribute_expression(attribute);
-				if (
-					value.type === 'Identifier' &&
-					value.name === attribute.name &&
-					!context.state.scope.get(value.name)
-				) {
-					w.attribute_global_event_reference(attribute, attribute.name);
-				}
+				check_global_event_reference(attribute, context);
 			}
 
 			if (attribute.name === 'slot') {
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/function.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/function.js
index 7bdb2243f2..6b3d227eca 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/function.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/function.js
@@ -18,7 +18,9 @@ export function visit_function(node, context) {
 
 	context.next({
 		...context.state,
-		function_depth: context.state.function_depth + 1,
+		// we generally want to use scope.function_depth unless we specifically increased
+		// that in state.function_depth (e.g. a derived)
+		function_depth: Math.max(context.state.scope.function_depth, context.state.function_depth) + 1,
 		expression: null
 	});
 }
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js
index 35116d715a..a32355abf5 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js
@@ -4,7 +4,11 @@
 /** @import { Scope } from '../../../scope' */
 /** @import { NodeLike } from '../../../../errors.js' */
 import * as e from '../../../../errors.js';
-import { extract_identifiers, get_parent } from '../../../../utils/ast.js';
+import {
+	extract_identifiers,
+	get_attribute_expression,
+	get_parent
+} from '../../../../utils/ast.js';
 import * as w from '../../../../warnings.js';
 import * as b from '#compiler/builders';
 import { get_rune } from '../../../scope.js';
@@ -298,3 +302,21 @@ export function validate_export(node, scope, name) {
 		e.state_invalid_export(node);
 	}
 }
+
+/**
+ * Warns when an event attribute uses the shorthand form (`{onclick}`) but the
+ * referenced name isn't declared, so it silently resolves to the global handler.
+ * @param {AST.Attribute & { value: [AST.ExpressionTag] | AST.ExpressionTag }} attribute
+ * @param {Context} context
+ */
+export function check_global_event_reference(attribute, context) {
+	const value = get_attribute_expression(attribute);
+
+	if (
+		value.type === 'Identifier' &&
+		value.name === attribute.name &&
+		!context.state.scope.get(value.name)
+	) {
+		w.attribute_global_event_reference(attribute, attribute.name);
+	}
+}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js b/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
index 622abea0c4..c1614f97b7 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
@@ -251,11 +251,11 @@ export function client_component(analysis, options) {
 	}
 
 	for (const [node] of analysis.reactive_statements) {
-		const statement = [...state.legacy_reactive_statements].find(([n]) => n === node);
+		const statement = state.legacy_reactive_statements.get(node);
 		if (statement === undefined) {
 			throw new Error('Could not find reactive statement');
 		}
-		instance.body.push(statement[1]);
+		instance.body.push(statement);
 	}
 
 	if (analysis.reactive_statements.size > 0) {
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/transform-template/index.js b/packages/svelte/src/compiler/phases/3-transform/client/transform-template/index.js
index 5fdc88844b..4c6d5f4ece 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/transform-template/index.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/transform-template/index.js
@@ -39,6 +39,12 @@ export function transform_template(state, name, flags = 0) {
 	const namespace = state.metadata.namespace;
 	const tree = state.options.fragments === 'tree';
 
+	const { nodes } = state.template;
+	const is_lone_anchor = nodes.length === 1 && nodes[0].type === 'comment';
+
+	// special case - `$.comment` creates the anchor more cheaply than cloning a template
+	if (is_lone_anchor) return b.id('$.comment');
+
 	const expression = tree ? state.template.as_tree() : state.template.as_html();
 
 	const key =
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/utils.js b/packages/svelte/src/compiler/phases/3-transform/client/utils.js
index d52b438d92..9cdfa5cae1 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/utils.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/utils.js
@@ -2,6 +2,7 @@
 /** @import { Binding } from '#compiler' */
 /** @import { ClientTransformState, ComponentClientTransformState } from './types.js' */
 /** @import { Analysis } from '../../types.js' */
+/** @import { ExpressionMetadata } from '../../nodes.js' */
 /** @import { Scope } from '../../scope.js' */
 import * as b from '#compiler/builders';
 import { is_simple_expression, save } from '../../../utils/ast.js';
@@ -164,20 +165,46 @@ export function should_proxy(node, scope) {
 	return true;
 }
 
+/**
+ * An async thunk. If an `await` inside restores the reaction context via `$.save`,
+ * the body exits through `$.unsave` so the context cannot leak into foreign microtasks
+ * that run before the returned promise settles
+ * @param {Expression | BlockStatement} body
+ * @param {ExpressionMetadata} metadata
+ */
+export function async_thunk(body, metadata) {
+	if (!metadata.has_pickled_await) {
+		return b.arrow([], body, true);
+	}
+
+	const block = body.type === 'BlockStatement' ? body : b.block([b.return(body)]);
+
+	return b.arrow(
+		[],
+		b.block([
+			{
+				type: 'TryStatement',
+				block,
+				handler: null,
+				finalizer: b.block([b.stmt(b.call('$.unsave'))])
+			}
+		]),
+		true
+	);
+}
+
 /**
  * Svelte legacy mode should use safe equals in most places, runes mode shouldn't
  * @param {ComponentClientTransformState} state
  * @param {Expression | BlockStatement} expression
- * @param {boolean} [async]
+ * @param {ExpressionMetadata} [metadata]
  */
-export function create_derived(state, expression, async = false) {
-	const thunk = b.thunk(expression, async);
-
-	if (async) {
-		return save(b.call('$.async_derived', thunk));
-	} else {
-		return b.call(state.analysis.runes ? '$.derived' : '$.derived_safe_equal', thunk);
+export function create_derived(state, expression, metadata) {
+	if (metadata?.has_await) {
+		return save(b.call('$.async_derived', async_thunk(expression, metadata)));
 	}
+
+	return b.call(state.analysis.runes ? '$.derived' : '$.derived_safe_equal', b.thunk(expression));
 }
 
 /**
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js
index e66e3408e2..7ab148f0a3 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js
@@ -1,4 +1,4 @@
-/** @import { AssignmentExpression, AssignmentOperator, Expression, Identifier, Pattern } from 'estree' */
+/** @import { AssignmentExpression, AssignmentOperator, Expression, Identifier, LogicalOperator, Pattern } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { Context } from '../types.js' */
 import * as b from '#compiler/builders';
@@ -79,8 +79,13 @@ function build_assignment(operator, left, right, context) {
 
 			// special case — assignment to private state field
 			if (left.property.type === 'PrivateIdentifier') {
+				const logical_operator = ['||=', '&&=', '??='].includes(operator)
+					? /** @type {LogicalOperator} */ (operator.slice(0, -1))
+					: null;
 				let value = /** @type {Expression} */ (
-					context.visit(build_assignment_value(operator, left, right))
+					context.visit(
+						logical_operator === null ? build_assignment_value(operator, left, right) : right
+					)
 				);
 
 				const needs_proxy =
@@ -88,7 +93,15 @@ function build_assignment(operator, left, right, context) {
 					is_non_coercive_operator(operator) &&
 					should_proxy(value, context.state.scope);
 
-				return b.call('$.set', left, value, needs_proxy && b.true);
+				const assignment = b.call('$.set', left, value, needs_proxy && b.true);
+
+				return logical_operator === null
+					? assignment
+					: b.logical(
+							logical_operator,
+							/** @type {Expression} */ (context.visit(left)),
+							assignment
+						);
 			}
 		}
 	}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/AwaitBlock.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/AwaitBlock.js
index b8def178f2..986cd789d9 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/AwaitBlock.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/AwaitBlock.js
@@ -1,9 +1,9 @@
 /** @import { BlockStatement, Pattern, Statement } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { ComponentClientTransformState, ComponentContext } from '../types' */
-import { extract_identifiers, is_expression_async } from '../../../../utils/ast.js';
+import { extract_identifiers } from '../../../../utils/ast.js';
 import * as b from '#compiler/builders';
-import { create_derived } from '../utils.js';
+import { async_thunk, create_derived } from '../utils.js';
 import { get_value } from './shared/declarations.js';
 import { build_expression, add_svelte_meta } from './shared/utils.js';
 
@@ -15,10 +15,10 @@ export function AwaitBlock(node, context) {
 	context.state.template.push_comment();
 
 	// Visit {#await <expression>} first to ensure that scopes are in the correct order
-	const expression = b.thunk(
-		build_expression(context, node.expression, node.metadata.expression),
-		node.metadata.expression.has_await
-	);
+	const input = build_expression(context, node.expression, node.metadata.expression);
+	const expression = node.metadata.expression.has_await
+		? async_thunk(input, node.metadata.expression)
+		: b.thunk(input);
 
 	let then_block;
 	let catch_block;
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/BindDirective.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/BindDirective.js
index 6838e5006d..c7bf24b3f9 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/BindDirective.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/BindDirective.js
@@ -1,7 +1,7 @@
 /** @import { CallExpression, Expression, Pattern } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types' */
-import { dev, is_ignored } from '../../../../state.js';
+import { dev, ignore_map, is_ignored } from '../../../../state.js';
 import { is_text_attribute } from '../../../../utils/ast.js';
 import * as b from '#compiler/builders';
 import { binding_properties } from '../../../bindings.js';
@@ -40,9 +40,15 @@ export function BindDirective(node, context) {
 			validate_binding(context.state, node, expression);
 		}
 
-		const assignment = /** @type {Expression} */ (
-			context.visit(b.assignment('=', /** @type {Pattern} */ (node.expression), b.id('$$value')))
+		const raw_assignment = b.assignment(
+			'=',
+			/** @type {Pattern} */ (node.expression),
+			b.id('$$value')
 		);
+		// The assignment is generated, so inherit any ignores attached to the binding
+		ignore_map.set(raw_assignment, ignore_map.get(node) ?? []);
+
+		const assignment = /** @type {Expression} */ (context.visit(raw_assignment));
 
 		if (dev) {
 			// in dev, create named functions, so that `$inspect(...)` delivers
@@ -58,16 +64,7 @@ export function BindDirective(node, context) {
 			get = b.thunk(expression);
 
 			/** @type {Expression | undefined} */
-			set = b.unthunk(
-				b.arrow(
-					[b.id('$$value')],
-					/** @type {Expression} */ (
-						context.visit(
-							b.assignment('=', /** @type {Pattern} */ (node.expression), b.id('$$value'))
-						)
-					)
-				)
-			);
+			set = b.unthunk(b.arrow([b.id('$$value')], assignment));
 
 			if (get === set) {
 				set = undefined;
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/ConstTag.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/ConstTag.js
index d05d7a8ed9..b3b2358e4c 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/ConstTag.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/ConstTag.js
@@ -19,7 +19,7 @@ export function ConstTag(node, context) {
 	if (declaration.id.type === 'Identifier') {
 		const init = build_expression(context, declaration.init, node.metadata.expression);
 
-		let expression = create_derived(context.state, init, node.metadata.expression.has_await);
+		let expression = create_derived(context.state, init, node.metadata.expression);
 
 		if (dev) {
 			expression = b.call('$.tag', expression, b.literal(declaration.id.name));
@@ -45,20 +45,31 @@ export function ConstTag(node, context) {
 			transform
 		});
 
-		// TODO optimise the simple `{ x } = y` case — we can just return `y`
-		// instead of destructuring it only to return a new object
+		const is_simple_object_pattern =
+			declaration.id.type === 'ObjectPattern' &&
+			declaration.id.properties.every(
+				(p) =>
+					p.type === 'Property' &&
+					!p.computed &&
+					p.key.type === 'Identifier' &&
+					p.value.type === 'Identifier' &&
+					p.key.name === p.value.name
+			);
+
 		const init = build_expression(
 			{ ...context, state: child_state },
 			declaration.init,
 			node.metadata.expression
 		);
 
-		const block = b.block([
-			b.const(/** @type {Pattern} */ (context.visit(declaration.id, child_state)), init),
-			b.return(b.object(identifiers.map((node) => b.prop('init', node, node))))
-		]);
+		const block = is_simple_object_pattern
+			? b.block([b.return(init)])
+			: b.block([
+					b.const(/** @type {Pattern} */ (context.visit(declaration.id, child_state)), init),
+					b.return(b.object(identifiers.map((node) => b.prop('init', node, node))))
+				]);
 
-		let expression = create_derived(context.state, block, node.metadata.expression.has_await);
+		let expression = create_derived(context.state, block, node.metadata.expression);
 
 		if (dev) {
 			expression = b.call('$.tag', expression, b.literal('[@const]'));
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/DeclarationTag.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/DeclarationTag.js
index abec5e828f..ceb81a468d 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/DeclarationTag.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/DeclarationTag.js
@@ -3,6 +3,7 @@
 /** @import { ComponentContext } from '../types' */
 import { extract_identifiers, has_await_expression } from '../../../../utils/ast.js';
 import * as b from '#compiler/builders';
+import { async_thunk } from '../utils.js';
 import { add_state_transformers } from './shared/declarations.js';
 
 /**
@@ -70,7 +71,7 @@ export function add_async_declaration(context, metadata, ids, assignments, kind
 		context.state.consts.push(kind === 'var' ? b.var(id.name) : b.let(id.name));
 	}
 
-	const blockers = [...metadata.expression.dependencies]
+	const blockers = [...metadata.expression.references]
 		.map((dep) => dep.blocker)
 		.filter((b) => b !== null && b.object !== context.state.async_consts?.id);
 
@@ -85,5 +86,5 @@ export function add_async_declaration(context, metadata, ids, assignments, kind
 		metadata.expression.has_await ||
 		assignments.some((assignment) => has_await_expression(assignment));
 	const body = assignments.length === 1 ? assignments[0].expression : b.block(assignments);
-	run.thunks.push(b.thunk(body, has_await));
+	run.thunks.push(has_await ? async_thunk(body, metadata.expression) : b.thunk(body));
 }
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/EachBlock.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/EachBlock.js
index a1371b516a..e0bd8d797a 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/EachBlock.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/EachBlock.js
@@ -12,6 +12,7 @@ import {
 import { dev } from '../../../../state.js';
 import { extract_paths, object } from '../../../../utils/ast.js';
 import * as b from '#compiler/builders';
+import { async_thunk } from '../utils.js';
 import { get_value } from './shared/declarations.js';
 import { build_expression, add_svelte_meta } from './shared/utils.js';
 
@@ -294,7 +295,10 @@ export function EachBlock(node, context) {
 	let key_function = b.id('$.index');
 
 	if (node.metadata.keyed) {
-		const pattern = /** @type {Pattern} */ (node.context); // can only be keyed when a context is provided
+		// can only be keyed when a context is provided
+		const pattern = /** @type {Pattern} */ (
+			context.visit(/** @type {Pattern} */ (node.context), key_state)
+		);
 		const expression = /** @type {Expression} */ (
 			context.visit(/** @type {Expression} */ (node.key), key_state)
 		);
@@ -310,7 +314,9 @@ export function EachBlock(node, context) {
 
 	const has_await = node.metadata.expression.has_await;
 
-	const get_collection = b.thunk(collection, has_await);
+	const get_collection = has_await
+		? async_thunk(collection, node.metadata.expression)
+		: b.thunk(collection);
 	const thunk = has_await ? b.thunk(b.call('$.get', b.id('$$collection'))) : get_collection;
 
 	const render_args = [b.id('$$anchor'), item];
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/Fragment.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/Fragment.js
index 893b1db568..1272290c4a 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/Fragment.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/Fragment.js
@@ -141,14 +141,9 @@ export function Fragment(node, context) {
 				flags |= TEMPLATE_USE_IMPORT_NODE;
 			}
 
-			if (state.template.nodes.length === 1 && state.template.nodes[0].type === 'comment') {
-				// special case — we can use `$.comment` instead of creating a unique template
-				state.init.unshift(b.var(id, b.call('$.comment')));
-			} else {
-				const template_name = transform_template(state, 'root', flags);
+			const template_name = transform_template(state, 'root', flags);
 
-				state.init.unshift(b.var(id, b.call(template_name)));
-			}
+			state.init.unshift(b.var(id, b.call(template_name)));
 
 			close = b.stmt(b.call('$.append', b.id('$$anchor'), id));
 		}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/HtmlTag.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/HtmlTag.js
index 6c8b7c0354..910f0a1239 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/HtmlTag.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/HtmlTag.js
@@ -2,6 +2,7 @@
 /** @import { ComponentContext } from '../types' */
 import { is_ignored } from '../../../../state.js';
 import * as b from '#compiler/builders';
+import { async_thunk } from '../utils.js';
 import { build_expression } from './shared/utils.js';
 
 /**
@@ -46,7 +47,7 @@ export function HtmlTag(node, context) {
 					'$.async',
 					context.state.node,
 					node.metadata.expression.blockers(),
-					has_await ? b.array([b.thunk(expression, true)]) : b.void0,
+					has_await ? b.array([async_thunk(expression, node.metadata.expression)]) : b.void0,
 					b.arrow(
 						has_await ? [context.state.node, b.id('$$html')] : [context.state.node],
 						b.block([statement])
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/IfBlock.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/IfBlock.js
index b0cd51ce3f..5dcb3991c2 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/IfBlock.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/IfBlock.js
@@ -2,6 +2,7 @@
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types' */
 import * as b from '#compiler/builders';
+import { async_thunk } from '../utils.js';
 import { build_expression, add_svelte_meta } from './shared/utils.js';
 
 /**
@@ -117,7 +118,7 @@ export function IfBlock(node, context) {
 					'$.async',
 					context.state.node,
 					node.metadata.expression.blockers(),
-					has_await ? b.array([b.thunk(expression, true)]) : b.void0,
+					has_await ? b.array([async_thunk(expression, node.metadata.expression)]) : b.void0,
 					b.arrow(
 						has_await ? [context.state.node, b.id('$$condition')] : [context.state.node],
 						b.block(statements)
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/KeyBlock.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/KeyBlock.js
index 143a4e8edd..1831e7abab 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/KeyBlock.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/KeyBlock.js
@@ -2,6 +2,7 @@
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types' */
 import * as b from '#compiler/builders';
+import { async_thunk } from '../utils.js';
 import { build_expression, add_svelte_meta } from './shared/utils.js';
 
 /**
@@ -31,7 +32,7 @@ export function KeyBlock(node, context) {
 					'$.async',
 					context.state.node,
 					node.metadata.expression.blockers(),
-					has_await ? b.array([b.thunk(expression, true)]) : b.void0,
+					has_await ? b.array([async_thunk(expression, node.metadata.expression)]) : b.void0,
 					b.arrow(
 						has_await ? [context.state.node, b.id('$$key')] : [context.state.node],
 						b.block([statement])
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js
index 8dcd3c7d6f..401891b41b 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js
@@ -1,10 +1,9 @@
-/** @import { ArrayExpression, Expression, ExpressionStatement, Identifier, MemberExpression, ObjectExpression } from 'estree' */
+/** @import { ArrayExpression, Expression, ExpressionStatement, Identifier, MemberExpression, ObjectExpression, Statement } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { ComponentClientTransformState, ComponentContext } from '../types' */
 /** @import { Scope } from '../../../scope' */
 import {
 	cannot_be_set_statically,
-	is_boolean_attribute,
 	is_dom_property,
 	is_load_error_element
 } from '../../../../../utils.js';
@@ -13,7 +12,6 @@ import { is_event_attribute, is_text_attribute } from '../../../../utils/ast.js'
 import * as b from '#compiler/builders';
 import {
 	create_attribute,
-	ExpressionMetadata,
 	is_custom_element_node,
 	is_customizable_select_element
 } from '../../../nodes.js';
@@ -231,6 +229,12 @@ export function RegularElement(node, context) {
 				continue;
 			}
 
+			// `<select defaultValue>` needs the options to exist before it can mark one
+			// as selected, so it is handled after the children, alongside `value`
+			if (node.name === 'select' && get_attribute_name(node, attribute) === 'defaultValue') {
+				continue;
+			}
+
 			const name = get_attribute_name(node, attribute);
 
 			if (
@@ -434,7 +438,7 @@ export function RegularElement(node, context) {
 			state: child_state
 		});
 
-		if (needs_reset) {
+		if (needs_reset && !fold_reset_into_child(child_state.init, context.state.node)) {
 			child_state.init.push(b.stmt(b.call('$.reset', context.state.node)));
 		}
 	}
@@ -513,6 +517,26 @@ export function RegularElement(node, context) {
 		}
 	}
 
+	// deferred from the attribute loop above, so that the options it selects from
+	// have been created and had their values assigned
+	if (!has_spread && name === 'select') {
+		for (const attribute of /** @type {AST.Attribute[]} */ (attributes)) {
+			if (get_attribute_name(node, attribute) === 'defaultValue') {
+				const { value, has_state } = build_attribute_value(attribute.value, context, (v, m) =>
+					context.state.memoizer.add(v, m)
+				);
+
+				const update = b.stmt(b.call('$.set_default_select_value', node_id, value));
+
+				(has_state ? context.state.update : context.state.init).push(update);
+				if (!bindings.has('value')) {
+					context.state.init.push(b.stmt(b.call('$.init_select', node_id)));
+				}
+				break;
+			}
+		}
+	}
+
 	context.state.template.pop_element();
 }
 
@@ -528,18 +552,12 @@ export function build_class_directives_object(
 ) {
 	let properties = [];
 
-	const metadata = new ExpressionMetadata();
-
 	for (const d of class_directives) {
-		metadata.merge(d.metadata.expression);
-
 		const expression = /** @type Expression */ (context.visit(d.expression));
-		properties.push(b.init(d.name, expression));
+		properties.push(b.init(d.name, memoizer.add(expression, d.metadata.expression)));
 	}
 
-	const directives = b.object(properties);
-
-	return memoizer.add(directives, metadata);
+	return b.object(properties);
 }
 
 /**
@@ -555,23 +573,17 @@ export function build_style_directives_object(
 	const normal = b.object([]);
 	const important = b.object([]);
 
-	const metadata = new ExpressionMetadata();
-
 	for (const d of style_directives) {
-		metadata.merge(d.metadata.expression);
-
 		const expression =
 			d.value === true
 				? build_getter(b.id(d.name), context.state)
 				: build_attribute_value(d.value, context).value;
 
 		const object = d.modifiers.includes('important') ? important : normal;
-		object.properties.push(b.init(d.name, expression));
+		object.properties.push(b.init(d.name, memoizer.add(expression, d.metadata.expression)));
 	}
 
-	const directives = important.properties.length ? b.array([normal, important]) : normal;
-
-	return memoizer.add(directives, metadata);
+	return important.properties.length ? b.array([normal, important]) : normal;
 }
 
 /**
@@ -664,14 +676,25 @@ function build_element_attribute_update(element, node_id, name, value, attribute
  * @param {ComponentContext} context
  */
 function build_custom_element_attribute_update_assignment(node_id, attribute, context) {
-	const { value, has_state } = build_attribute_value(attribute.value, context);
+	const memoizer = new Memoizer();
+	const { value, has_state } = build_attribute_value(attribute.value, context, (value, metadata) =>
+		memoizer.add(value, metadata)
+	);
 
 	// don't lowercase name, as we set the element's property, which might be case sensitive
 	const call = b.call('$.set_custom_element_data', node_id, b.literal(attribute.name), value);
 
 	// this is different from other updates — it doesn't get grouped,
 	// because set_custom_element_data may not be idempotent
-	const update = has_state ? b.call('$.template_effect', b.thunk(call)) : call;
+	const update = has_state
+		? b.call(
+				'$.template_effect',
+				b.arrow(memoizer.apply(), call),
+				memoizer.sync_values(),
+				memoizer.async_values(),
+				memoizer.blockers()
+			)
+		: call;
 
 	context.state.init.push(b.stmt(update));
 }
@@ -704,28 +727,32 @@ function build_element_special_value_attribute(
 	);
 
 	const evaluated = context.state.scope.evaluate(value);
-	const assignment = b.assignment('=', b.member(node_id, '__value'), value);
 
-	const set_value_assignment = b.assignment(
-		'=',
-		b.member(node_id, 'value'),
-		evaluated.is_defined ? assignment : b.logical('??', assignment, b.literal(''))
-	);
+	/** @param {Expression} value */
+	const build_update = (value) => {
+		const assignment = b.assignment('=', b.member(node_id, '__value'), value);
 
-	const update = b.stmt(
-		is_select_with_value
-			? b.sequence([
-					set_value_assignment,
-					// This ensures a one-way street to the DOM in case it's <select {value}>
-					// and not <select bind:value>. We need it in addition to $.init_select
-					// because the select value is not reflected as an attribute, so the
-					// mutation observer wouldn't notice.
-					b.call('$.select_option', node_id, value)
-				])
-			: synthetic
-				? assignment
-				: set_value_assignment
-	);
+		const set_value_assignment = b.assignment(
+			'=',
+			b.member(node_id, 'value'),
+			evaluated.is_defined ? assignment : b.logical('??', assignment, b.literal(''))
+		);
+
+		return b.stmt(
+			is_select_with_value
+				? b.sequence([
+						set_value_assignment,
+						// This ensures a one-way street to the DOM in case it's <select {value}>
+						// and not <select bind:value>. We need it in addition to $.init_select
+						// because the select value is not reflected as an attribute, so the
+						// mutation observer wouldn't notice.
+						b.call('$.select_option', node_id, value)
+					])
+				: synthetic
+					? assignment
+					: set_value_assignment
+		);
+	};
 
 	if (has_state) {
 		const id = b.id(state.scope.generate(`${node_id.name}_value`));
@@ -736,12 +763,53 @@ function build_element_special_value_attribute(
 		const init = element === 'option' ? b.object([]) : undefined;
 
 		state.init.push(b.var(id, init));
-		state.update.push(b.if(b.binary('!==', id, b.assignment('=', id, value)), b.block([update])));
+
+		// the guard already evaluated `value` into `id`, so read that back rather than
+		// evaluating the same expression (and its signal reads) a second time
+		state.update.push(
+			b.if(b.binary('!==', id, b.assignment('=', id, value)), b.block([build_update(id)]))
+		);
 	} else {
-		state.init.push(update);
+		state.init.push(build_update(value));
 	}
 
 	if (is_select_with_value) {
 		state.init.push(b.stmt(b.call('$.init_select', node_id)));
 	}
 }
+
+/**
+ * `<p>{text}</p>` and friends produce `var x = $.child(p, true); $.reset(p);`. That pair is
+ * by far the most common shape in compiled output, and `$.only_child` does both, so fold the
+ * two together when the `$.child(...)` is the last thing we emitted for this element.
+ * @param {Statement[]} init
+ * @param {Expression} node_id
+ * @returns {boolean} whether the reset was folded in
+ */
+function fold_reset_into_child(init, node_id) {
+	const last = init.at(-1);
+
+	if (
+		node_id?.type !== 'Identifier' ||
+		last?.type !== 'VariableDeclaration' ||
+		last.declarations.length !== 1
+	) {
+		return false;
+	}
+
+	const call = last.declarations[0].init;
+
+	if (
+		call?.type !== 'CallExpression' ||
+		call.callee.type !== 'Identifier' ||
+		call.callee.name !== '$.child' ||
+		call.arguments[0]?.type !== 'Identifier' ||
+		call.arguments[0].name !== node_id.name
+	) {
+		return false;
+	}
+
+	call.callee = b.id('$.only_child');
+
+	return true;
+}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/SvelteElement.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/SvelteElement.js
index 10024298fa..909b4e0b71 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/SvelteElement.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/SvelteElement.js
@@ -4,6 +4,7 @@
 import { dev, locator } from '../../../../state.js';
 import { is_text_attribute } from '../../../../utils/ast.js';
 import * as b from '#compiler/builders';
+import { async_thunk } from '../utils.js';
 import { determine_namespace_for_children } from '../../utils.js';
 import {
 	build_attribute_value,
@@ -147,7 +148,7 @@ export function SvelteElement(node, context) {
 					'$.async',
 					context.state.node,
 					node.metadata.expression.blockers(),
-					has_await ? b.array([b.thunk(expression, true)]) : b.void0,
+					has_await ? b.array([async_thunk(expression, node.metadata.expression)]) : b.void0,
 					b.arrow(
 						has_await ? [context.state.node, b.id('$$tag')] : [context.state.node],
 						b.block(statements)
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/UpdateExpression.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/UpdateExpression.js
index 66952eb298..bc483daaed 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/UpdateExpression.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/UpdateExpression.js
@@ -13,7 +13,6 @@ export function UpdateExpression(node, context) {
 
 	if (
 		argument.type === 'MemberExpression' &&
-		argument.object.type === 'ThisExpression' &&
 		argument.property.type === 'PrivateIdentifier' &&
 		context.state.state_fields.has('#' + argument.property.name)
 	) {
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/VariableDeclaration.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/VariableDeclaration.js
index b9f4690179..246feaccf6 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/VariableDeclaration.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/VariableDeclaration.js
@@ -6,7 +6,13 @@ import { extract_paths, save } from '../../../../utils/ast.js';
 import * as b from '#compiler/builders';
 import * as assert from '../../../../utils/assert.js';
 import { get_rune } from '../../../scope.js';
-import { get_prop_source, is_prop_source, is_state_source, should_proxy } from '../utils.js';
+import {
+	async_thunk,
+	get_prop_source,
+	is_prop_source,
+	is_state_source,
+	should_proxy
+} from '../utils.js';
 import { get_value } from './shared/declarations.js';
 
 /**
@@ -200,9 +206,10 @@ export function VariableDeclaration(node, context) {
 			}
 
 			if (rune === '$derived' || rune === '$derived.by') {
-				const is_async = context.state.analysis.async_deriveds.has(
+				const metadata = context.state.analysis.async_deriveds.get(
 					/** @type {CallExpression} */ (init)
 				);
+				const is_async = metadata !== undefined;
 
 				if (declarator.id.type === 'Identifier') {
 					let expression = /** @type {Expression} */ (context.visit(value));
@@ -213,7 +220,7 @@ export function VariableDeclaration(node, context) {
 						/** @type {Expression} */
 						let call = b.call(
 							'$.async_derived',
-							b.thunk(expression, true),
+							async_thunk(expression, metadata),
 							dev && b.literal(declarator.id.name),
 							location ? b.literal(location) : undefined
 						);
@@ -246,7 +253,7 @@ export function VariableDeclaration(node, context) {
 
 							call = b.call(
 								'$.async_derived',
-								b.thunk(expression, true),
+								async_thunk(expression, metadata),
 								dev &&
 									b.literal(
 										`[$derived ${declarator.id.type === 'ArrayPattern' ? 'iterable' : 'object'}]`
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/element.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/element.js
index 58ed88855f..ec0ca83cb4 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/element.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/element.js
@@ -30,6 +30,7 @@ export function build_attribute_effect(
 ) {
 	/** @type {ObjectExpression['properties']} */
 	const values = [];
+	const is_select = element.type === 'RegularElement' && element.name === 'select';
 
 	const memoizer = new Memoizer();
 
@@ -48,7 +49,11 @@ export function build_attribute_effect(
 				context.state.init.push(b.var(id, value));
 				values.push(b.init(attribute.name, b.id(id)));
 			} else {
-				values.push(b.init(attribute.name, value));
+				const name =
+					is_select && normalize_attribute(attribute.name) === 'defaultValue'
+						? 'defaultValue'
+						: attribute.name;
+				values.push(b.init(name, value));
 			}
 		} else {
 			let value = /** @type {Expression} */ (context.visit(attribute));
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/fragment.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/fragment.js
index f77af74f7e..72104481ec 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/fragment.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/fragment.js
@@ -161,7 +161,7 @@ export function is_static_element(node) {
 		}
 
 		if (
-			['input', 'textarea'].includes(node.name) &&
+			['input', 'textarea', 'select'].includes(node.name) &&
 			['value', 'checked'].includes(attribute.name)
 		) {
 			return false;
@@ -171,11 +171,6 @@ export function is_static_element(node) {
 			return false;
 		}
 
-		// We need to apply src and loading after appending the img to the DOM for lazy loading to work
-		if (node.name === 'img' && attribute.name === 'loading') {
-			return false;
-		}
-
 		if (attribute.value !== true && !is_text_attribute(attribute)) {
 			return false;
 		}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/utils.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/utils.js
index 51c84dd01c..64ae573984 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/utils.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/utils.js
@@ -8,7 +8,7 @@ import { sanitize_template_string } from '../../../../../utils/sanitize_template
 import { regex_is_valid_identifier } from '../../../../patterns.js';
 import is_reference from 'is-reference';
 import { dev, is_ignored, locator, component_name } from '../../../../../state.js';
-import { build_getter } from '../../utils.js';
+import { async_thunk, build_getter, is_state_source } from '../../utils.js';
 import { ExpressionMetadata } from '../../../../nodes.js';
 
 /**
@@ -16,10 +16,10 @@ import { ExpressionMetadata } from '../../../../nodes.js';
  * from templates and replacing them with `$0`, `$1` etc
  */
 export class Memoizer {
-	/** @type {Array<{ id: Identifier, expression: Expression }>} */
+	/** @type {Array<{ id: Identifier, expression: Expression, metadata: ExpressionMetadata }>} */
 	#sync = [];
 
-	/** @type {Array<{ id: Identifier, expression: Expression }>} */
+	/** @type {Array<{ id: Identifier, expression: Expression, metadata: ExpressionMetadata }>} */
 	#async = [];
 
 	/** @type {Set<Expression>} */
@@ -43,7 +43,7 @@ export class Memoizer {
 
 		const id = b.id('#'); // filled in later
 
-		(metadata.has_await ? this.#async : this.#sync).push({ id, expression });
+		(metadata.has_await ? this.#async : this.#sync).push({ id, expression, metadata });
 
 		return id;
 	}
@@ -84,7 +84,7 @@ export class Memoizer {
 		if (this.#async.length === 0) return;
 		// use `b.arrow` rather than `b.thunk` so that deferred async/template effects
 		// always read live bindings rather than a possibly stale snapshot.
-		return b.array(this.#async.map((memo) => b.arrow([], memo.expression, true)));
+		return b.array(this.#async.map((memo) => async_thunk(memo.expression, memo.metadata)));
 	}
 
 	sync_values() {
@@ -272,6 +272,10 @@ export function build_bind_this(expression, value, { state, visit }) {
 			const binding = state.scope.get(node.name);
 			if (!binding) return;
 
+			// if it is a state or a derived it means is a declaration tag...in that case we don't want to pass the
+			// value but the signal itself or assignment will break
+			if (is_state_source(binding, state.analysis) || binding.kind === 'derived') return;
+
 			for (const [owner, scope] of state.scopes) {
 				if (owner.type === 'EachBlock' && scope === binding.scope) {
 					ids.push(node);
diff --git a/packages/svelte/src/compiler/phases/3-transform/css/index.js b/packages/svelte/src/compiler/phases/3-transform/css/index.js
index 92b2706f22..bfeb426493 100644
--- a/packages/svelte/src/compiler/phases/3-transform/css/index.js
+++ b/packages/svelte/src/compiler/phases/3-transform/css/index.js
@@ -355,7 +355,11 @@ const visitors = {
 						continue;
 					}
 
-					if (selector.type === 'TypeSelector' && selector.name === '*') {
+					if (
+						selector.type === 'TypeSelector' &&
+						selector.name === '*' &&
+						selector.namespace === undefined
+					) {
 						context.state.code.update(selector.start, selector.end, modifier);
 					} else {
 						context.state.code.appendLeft(selector.end, modifier);
@@ -374,6 +378,9 @@ const visitors = {
 		if (node.name === 'is' || node.name === 'where' || node.name === 'has' || node.name === 'not') {
 			context.next();
 		}
+	},
+	PseudoElementSelector() {
+		// Functional pseudo-element arguments are not scoped as selectors.
 	}
 };
 
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/transform-server.js b/packages/svelte/src/compiler/phases/3-transform/server/transform-server.js
index 77b67735f7..5da1940de0 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/transform-server.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/transform-server.js
@@ -152,7 +152,7 @@ export function server_component(analysis, options) {
 	const legacy_reactive_declarations = [];
 
 	for (const [node] of analysis.reactive_statements) {
-		const statement = [...state.legacy_reactive_statements].find(([n]) => n === node);
+		const statement = state.legacy_reactive_statements.get(node);
 		if (statement === undefined) {
 			throw new Error('Could not find reactive statement');
 		}
@@ -169,7 +169,7 @@ export function server_component(analysis, options) {
 			}
 		}
 
-		instance.body.push(statement[1]);
+		instance.body.push(statement);
 	}
 
 	if (legacy_reactive_declarations.length > 0) {
@@ -214,14 +214,25 @@ export function server_component(analysis, options) {
 		];
 	}
 
-	if (
-		[...analysis.instance.scope.declarations.values()].some(
-			(binding) => binding.kind === 'store_sub'
-		)
-	) {
+	const store_subs = [...analysis.instance.scope.declarations.values()].filter(
+		(binding) => binding.kind === 'store_sub'
+	);
+
+	// a blocked subscription is only created once its promise resolves, so its teardown must wait until the render is done
+	const defer_store_teardown = store_subs.some((binding) => binding.blocker);
+
+	if (store_subs.length > 0) {
 		instance.body.unshift(b.var('$$store_subs'));
+
+		const unsubscribe = b.if(
+			b.id('$$store_subs'),
+			b.stmt(b.call('$.unsubscribe_stores', b.id('$$store_subs')))
+		);
+
 		template.body.push(
-			b.if(b.id('$$store_subs'), b.stmt(b.call('$.unsubscribe_stores', b.id('$$store_subs'))))
+			defer_store_teardown
+				? b.stmt(b.call('$$renderer.on_destroy', b.arrow([], b.block([unsubscribe]))))
+				: unsubscribe
 		);
 	}
 
@@ -261,7 +272,7 @@ export function server_component(analysis, options) {
 		);
 	}
 
-	let should_inject_context = dev || analysis.needs_context;
+	let should_inject_context = dev || analysis.needs_context || defer_store_teardown;
 
 	if (should_inject_context) {
 		component_block = b.block([
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/AssignmentExpression.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/AssignmentExpression.js
index e6a1a86aa8..d555b6bb1d 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/AssignmentExpression.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/AssignmentExpression.js
@@ -110,7 +110,7 @@ function build_assignment(operator, left, right, context) {
 			context.visit(build_assignment_value(operator, left, right))
 		);
 
-		return b.call(binding.node, value);
+		return b.call(object, value);
 	}
 
 	return null;
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/CallExpression.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/CallExpression.js
index 8525fb6366..ac78f55da9 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/CallExpression.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/CallExpression.js
@@ -46,7 +46,7 @@ export function CallExpression(node, context) {
 	}
 
 	if (rune === '$state.eager') {
-		return node.arguments[0];
+		return context.visit(node.arguments[0]);
 	}
 
 	if (rune === '$state.snapshot') {
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/DeclarationTag.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/DeclarationTag.js
index 8338700c0b..3fbff7167b 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/DeclarationTag.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/DeclarationTag.js
@@ -66,7 +66,7 @@ export function add_async_declaration(context, metadata, ids, assignments, kind
 		context.state.init.push(kind === 'var' ? b.var(id.name) : b.let(id.name));
 	}
 
-	const blockers = [...metadata.expression.dependencies]
+	const blockers = [...metadata.expression.references]
 		.map((dep) => dep.blocker)
 		.filter((b) => b !== null && b.object !== context.state.async_consts?.id);
 
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/EachBlock.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/EachBlock.js
index cb5a61d52f..923c4dd394 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/EachBlock.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/EachBlock.js
@@ -2,7 +2,13 @@
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types.js' */
 import * as b from '#compiler/builders';
-import { block_close, block_open, block_open_else, create_child_block } from './shared/utils.js';
+import {
+	block_close,
+	block_open,
+	block_open_else,
+	create_child_block,
+	prepend_block_marker
+} from './shared/utils.js';
 
 /**
  * @param {AST.EachBlock} node
@@ -51,7 +57,7 @@ export function EachBlock(node, context) {
 
 		const fallback = /** @type {BlockStatement} */ (context.visit(node.fallback));
 
-		fallback.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), block_open_else)));
+		prepend_block_marker(fallback, /** @type {string} */ (block_open_else.value));
 
 		statements.push(
 			b.if(
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/IfBlock.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/IfBlock.js
index 2d1a22605c..ea636e2064 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/IfBlock.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/IfBlock.js
@@ -2,7 +2,7 @@
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types.js' */
 import * as b from '#compiler/builders';
-import { block_close, create_child_block } from './shared/utils.js';
+import { block_close, create_child_block, prepend_block_marker } from './shared/utils.js';
 
 /**
  * @param {AST.IfBlock} node
@@ -10,7 +10,7 @@ import { block_close, create_child_block } from './shared/utils.js';
  */
 export function IfBlock(node, context) {
 	const consequent = /** @type {BlockStatement} */ (context.visit(node.consequent));
-	consequent.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), b.literal(`<!--[0-->`))));
+	prepend_block_marker(consequent, `<!--[0-->`);
 
 	/** @type {IfStatement} */
 	let if_statement = b.if(/** @type {Expression} */ (context.visit(node.test)), consequent);
@@ -22,7 +22,7 @@ export function IfBlock(node, context) {
 	// Walk the else-if chain, flattening branches
 	for (const elseif of node.metadata.flattened ?? []) {
 		const branch = /** @type {BlockStatement} */ (context.visit(elseif.consequent));
-		branch.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), b.literal(`<!--[${index++}-->`))));
+		prepend_block_marker(branch, `<!--[${index++}-->`);
 
 		current_if = current_if.alternate = b.if(
 			/** @type {Expression} */ (context.visit(elseif.test)),
@@ -34,7 +34,7 @@ export function IfBlock(node, context) {
 	// Handle final else (or remaining async chain)
 	const final_alternate = alt ? /** @type {BlockStatement} */ (context.visit(alt)) : b.block([]);
 
-	final_alternate.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), b.literal(`<!--[-1-->`))));
+	prepend_block_marker(final_alternate, `<!--[-1-->`);
 	current_if.alternate = final_alternate;
 
 	context.state.template.push(
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/LabeledStatement.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/LabeledStatement.js
index 83c828b839..e71e7473cd 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/LabeledStatement.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/LabeledStatement.js
@@ -8,6 +8,7 @@ import * as b from '#compiler/builders';
  */
 export function LabeledStatement(node, context) {
 	if (context.state.analysis.runes || context.path.length > 1 || node.label.name !== '$') {
+		context.next();
 		return;
 	}
 
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js
index 90c34d7035..f31de46378 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js
@@ -46,7 +46,7 @@ export function RegularElement(node, context) {
 		node.attributes.some(
 			(attribute) =>
 				((attribute.type === 'Attribute' || attribute.type === 'BindDirective') &&
-					attribute.name === 'value') ||
+					(attribute.name === 'value' || attribute.name.toLowerCase() === 'defaultvalue')) ||
 				attribute.type === 'SpreadAttribute'
 		);
 	const is_option_special = name === 'option';
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/SvelteBoundary.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/SvelteBoundary.js
index 47a07a1312..feef4bd1a9 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/SvelteBoundary.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/SvelteBoundary.js
@@ -1,4 +1,4 @@
-/** @import { BlockStatement } from 'estree' */
+/** @import { BlockStatement, Statement } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types' */
 import * as b from '#compiler/builders';
@@ -84,6 +84,9 @@ export function SvelteBoundary(node, context) {
 	}
 
 	const props = b.object([]);
+	/** @type {Statement[]} */
+	const init = [];
+
 	if (failed_attribute && !failed_snippet) {
 		const failed_callee = build_attribute_value(
 			failed_attribute.value,
@@ -95,13 +98,15 @@ export function SvelteBoundary(node, context) {
 
 		props.properties.push(b.init('failed', failed_callee));
 	} else if (failed_snippet) {
-		context.visit(failed_snippet, context.state);
+		context.visit(failed_snippet, { ...context.state, init });
 		props.properties.push(b.init('failed', failed_snippet.expression));
 	}
 
-	context.state.template.push(
-		b.stmt(b.call('$$renderer.boundary', props, b.arrow([b.id('$$renderer')], children_body)))
+	const boundary = b.stmt(
+		b.call('$$renderer.boundary', props, b.arrow([b.id('$$renderer')], children_body))
 	);
+
+	context.state.template.push(init.length > 0 ? b.block([...init, boundary]) : boundary);
 }
 
 /**
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/VariableDeclaration.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/VariableDeclaration.js
index 2c7b14afa5..108f65a884 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/VariableDeclaration.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/VariableDeclaration.js
@@ -102,9 +102,11 @@ export function VariableDeclaration(node, context) {
 				} else {
 					const call = /** @type {CallExpression} */ (declarator.init);
 
-					let rhs = value;
+					// - cannot be a SpreadElement because refused during analysis
+					// - use args[0] rather than value to avoid visiting twice (above in const value = ... and below in for-ofs)
+					let rhs = /** @type {Expression} */ (call.arguments[0]);
 
-					if (rune !== '$derived' || call.arguments[0].type !== 'Identifier') {
+					if (rune === '$derived.by' || call.arguments[0].type !== 'Identifier') {
 						const id = b.id(context.state.scope.generate('$$d'));
 
 						rhs = b.call(id);
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/element.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/element.js
index 9c37b2fffe..b4f4facb5d 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/element.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/element.js
@@ -3,7 +3,7 @@
 /** @import { ComponentContext, ComponentServerTransformState } from '../../types.js' */
 import { is_event_attribute, is_text_attribute } from '../../../../../utils/ast.js';
 import { binding_properties } from '../../../../bindings.js';
-import { create_attribute, ExpressionMetadata, is_custom_element_node } from '../../../../nodes.js';
+import { ExpressionMetadata, is_custom_element_node } from '../../../../nodes.js';
 import { regex_starts_with_newline } from '../../../../patterns.js';
 import * as b from '#compiler/builders';
 import {
@@ -21,6 +21,11 @@ import { escape_html } from '../../../../../../escaping.js';
 
 const WHITESPACE_INSENSITIVE_ATTRIBUTES = ['class', 'style'];
 
+/**
+ * @typedef {{ type: 'transformed', name: string, expression: Expression }} TransformedAttribute
+ * An attribute whose expression has already been transformed and must not be visited again.
+ */
+
 /**
  * Writes the output to the template output. Some elements may have attributes on them that require the
  * their output to be the child content instead. In this case, an object is returned.
@@ -29,7 +34,7 @@ const WHITESPACE_INSENSITIVE_ATTRIBUTES = ['class', 'style'];
  * @param {(expression: Expression, metadata: ExpressionMetadata) => Expression} transform
  */
 export function build_element_attributes(node, context, transform) {
-	/** @type {Array<AST.Attribute | AST.SpreadAttribute>} */
+	/** @type {Array<AST.Attribute | AST.SpreadAttribute | TransformedAttribute>} */
 	const attributes = [];
 
 	/** @type {AST.ClassDirective[]} */
@@ -145,42 +150,26 @@ export function build_element_attributes(node, context, transform) {
 						attr.value[0].data === 'checkbox'
 				);
 
-				attributes.push(
-					create_attribute('checked', null, -1, -1, [
-						{
-							type: 'ExpressionTag',
-							start: -1,
-							end: -1,
-							expression: is_checkbox
-								? b.call(
-										b.member(attribute.expression, 'includes'),
-										build_attribute_value(value_attribute.value, context, transform)
-									)
-								: b.binary(
-										'===',
-										attribute.expression,
-										build_attribute_value(value_attribute.value, context, transform)
-									),
-							metadata: {
-								expression: new ExpressionMetadata()
-							}
-						}
-					])
-				);
+				attributes.push({
+					type: 'transformed',
+					name: 'checked',
+					expression: is_checkbox
+						? b.call(
+								b.member(expression, 'includes'),
+								build_attribute_value(value_attribute.value, context, transform)
+							)
+						: b.binary(
+								'===',
+								expression,
+								build_attribute_value(value_attribute.value, context, transform)
+							)
+				});
 			} else {
-				attributes.push(
-					create_attribute(attribute.name, null, -1, -1, [
-						{
-							type: 'ExpressionTag',
-							start: -1,
-							end: -1,
-							expression,
-							metadata: {
-								expression: new ExpressionMetadata()
-							}
-						}
-					])
-				);
+				attributes.push({
+					type: 'transformed',
+					name: get_attribute_name(node, attribute),
+					expression
+				});
 			}
 		} else if (attribute.type === 'SpreadAttribute') {
 			attributes.push(attribute);
@@ -217,7 +206,21 @@ export function build_element_attributes(node, context, transform) {
 	} else {
 		const css_hash = node.metadata.scoped ? context.state.analysis.css.hash : null;
 
-		for (const attribute of /** @type {AST.Attribute[]} */ (attributes)) {
+		for (const attribute of /** @type {Array<AST.Attribute | TransformedAttribute>} */ (
+			attributes
+		)) {
+			if (attribute.type === 'transformed') {
+				context.state.template.push(
+					b.call(
+						'$.attr',
+						b.literal(attribute.name),
+						attribute.expression,
+						is_boolean_attribute(attribute.name) && b.true
+					)
+				);
+				continue;
+			}
+
 			const name = get_attribute_name(node, attribute);
 			const can_use_literal =
 				(name !== 'class' || class_directives.length === 0) &&
@@ -298,15 +301,19 @@ function get_attribute_name(element, attribute) {
 
 /**
  * @param {AST.RegularElement | AST.SvelteElement} element
- * @param {Array<AST.Attribute | AST.SpreadAttribute | AST.BindDirective>} attributes
+ * @param {Array<AST.Attribute | AST.SpreadAttribute | AST.BindDirective | TransformedAttribute>} attributes
  * @param {ComponentContext} context
  * @param {(expression: Expression, metadata: ExpressionMetadata) => Expression} transform
  */
 export function build_spread_object(element, attributes, context, transform) {
+	const is_select = element.type === 'RegularElement' && element.name === 'select';
 	const object = b.object(
 		attributes.map((attribute) => {
-			if (attribute.type === 'Attribute') {
-				const name = get_attribute_name(element, attribute);
+			if (attribute.type === 'transformed') {
+				return b.prop('init', b.key(attribute.name), attribute.expression);
+			} else if (attribute.type === 'Attribute') {
+				let name = get_attribute_name(element, attribute);
+				if (is_select && name === 'defaultvalue') name = 'defaultValue';
 				const value = build_attribute_value(
 					attribute.value,
 					context,
@@ -317,10 +324,9 @@ export function build_spread_object(element, attributes, context, transform) {
 				return b.prop('init', b.key(name), value);
 			} else if (attribute.type === 'BindDirective') {
 				const name = get_attribute_name(element, attribute);
+				const expression = /** @type {Expression} */ (context.visit(attribute.expression));
 				const value =
-					attribute.expression.type === 'SequenceExpression'
-						? b.call(attribute.expression.expressions[0])
-						: /** @type {Expression} */ (context.visit(attribute.expression));
+					expression.type === 'SequenceExpression' ? b.call(expression.expressions[0]) : expression;
 
 				return b.prop('init', b.key(name), value);
 			}
@@ -340,7 +346,7 @@ export function build_spread_object(element, attributes, context, transform) {
 /**
  *
  * @param {AST.RegularElement | AST.SvelteElement} element
- * @param {Array<AST.Attribute | AST.SpreadAttribute>} attributes
+ * @param {Array<AST.Attribute | AST.SpreadAttribute | TransformedAttribute>} attributes
  * @param {AST.StyleDirective[]} style_directives
  * @param {AST.ClassDirective[]} class_directives
  * @param {ComponentContext} context
@@ -356,7 +362,7 @@ function build_element_spread_attributes(
 ) {
 	const args = prepare_element_spread(
 		element,
-		/** @type {Array<AST.Attribute | AST.SpreadAttribute | AST.BindDirective>} */ (attributes),
+		attributes,
 		style_directives,
 		class_directives,
 		context,
@@ -410,7 +416,7 @@ export function prepare_element_spread_object(element, context, transform) {
 /**
  * Prepare args for $.attributes(...): compute object, css_hash, classes, styles and flags.
  * @param {AST.RegularElement | AST.SvelteElement} element
- * @param {Array<AST.Attribute | AST.SpreadAttribute | AST.BindDirective>} attributes
+ * @param {Array<AST.Attribute | AST.SpreadAttribute | AST.BindDirective | TransformedAttribute>} attributes
  * @param {AST.StyleDirective[]} style_directives
  * @param {AST.ClassDirective[]} class_directives
  * @param {ComponentContext} context
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/utils.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/utils.js
index 3da6fcf321..f38ae6164c 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/utils.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/utils.js
@@ -60,7 +60,9 @@ export function process_children(nodes, { visit, state }) {
 				if (evaluated.is_known) {
 					quasi.value.cooked += escape_html((evaluated.value ?? '') + '');
 				} else {
-					expressions.push(b.call('$.escape', /** @type {Expression} */ (visit(node.expression))));
+					expressions.push(
+						b.call('$.escape', /** @type {Expression} */ (visit(node.expression, state)))
+					);
 
 					quasi = b.quasi('', i + 1 === sequence.length);
 					quasis.push(quasi);
@@ -80,7 +82,7 @@ export function process_children(nodes, { visit, state }) {
 		if (node.type === 'ExpressionTag' && node.metadata.expression.is_async()) {
 			flush();
 
-			const expression = /** @type {Expression} */ (visit(node.expression));
+			const expression = /** @type {Expression} */ (visit(node.expression, state));
 
 			let call = b.call(
 				'$$renderer.push',
@@ -178,6 +180,36 @@ export function build_template(template) {
 	return statements;
 }
 
+/**
+ * Prepends a hydration marker (e.g. `<!--[0-->`) to a branch. The branch has already been
+ * turned into statements by `build_template`, so if it happens to start with a static
+ * `$$renderer.push(...)` we fold the marker into that call rather than emitting a second one.
+ * @param {BlockStatement} block
+ * @param {string} marker
+ */
+export function prepend_block_marker(block, marker) {
+	const first = block.body[0];
+
+	if (
+		first?.type === 'ExpressionStatement' &&
+		first.expression.type === 'CallExpression' &&
+		first.expression.callee.type === 'Identifier' &&
+		first.expression.callee.name === '$$renderer.push' &&
+		first.expression.arguments.length === 1 &&
+		first.expression.arguments[0].type === 'TemplateLiteral'
+	) {
+		const quasi = first.expression.arguments[0].quasis[0];
+
+		// markers never contain characters that need escaping in a template literal
+		quasi.value.cooked = marker + quasi.value.cooked;
+		quasi.value.raw = marker + quasi.value.raw;
+
+		return;
+	}
+
+	block.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), b.literal(marker))));
+}
+
 /**
  *
  * @param {AST.Attribute['value']} value
@@ -284,7 +316,7 @@ export function build_getter(node, state) {
 	}
 
 	if (binding.kind === 'derived') {
-		return (binding.declaration_kind === 'var' ? b.maybe_call : b.call)(binding.node);
+		return (binding.declaration_kind === 'var' ? b.maybe_call : b.call)(node);
 	}
 
 	return node;
diff --git a/packages/svelte/src/compiler/phases/nodes.js b/packages/svelte/src/compiler/phases/nodes.js
index 9f6f1a02f9..3624bf4ad0 100644
--- a/packages/svelte/src/compiler/phases/nodes.js
+++ b/packages/svelte/src/compiler/phases/nodes.js
@@ -77,6 +77,9 @@ export class ExpressionMetadata {
 	/** True if the expression contains `await` */
 	has_await = false;
 
+	/** True if an `await` restores the reaction context afterwards, so the thunk must end it */
+	has_pickled_await = false;
+
 	/** True if the expression includes a member expression */
 	has_member_expression = false;
 
@@ -142,6 +145,7 @@ export class ExpressionMetadata {
 		this.has_state ||= source.has_state;
 		this.has_call ||= source.has_call;
 		this.has_await ||= source.has_await;
+		this.has_pickled_await ||= source.has_pickled_await;
 		this.has_member_expression ||= source.has_member_expression;
 		this.has_assignment ||= source.has_assignment;
 		this.#blockers = null; // so that blockers are recalculated
diff --git a/packages/svelte/src/compiler/phases/types.d.ts b/packages/svelte/src/compiler/phases/types.d.ts
index a1a85ce145..38fa80ac4b 100644
--- a/packages/svelte/src/compiler/phases/types.d.ts
+++ b/packages/svelte/src/compiler/phases/types.d.ts
@@ -63,7 +63,7 @@ export interface Analysis {
 	accessors: boolean;
 
 	/** A set of deriveds that contain `await` expressions */
-	async_deriveds: Set<CallExpression>;
+	async_deriveds: Map<CallExpression, ExpressionMetadata>;
 	/** Awaits needing context preservation */
 	pickled_awaits: Set<AwaitExpression>;
 }
diff --git a/packages/svelte/src/compiler/print/index.js b/packages/svelte/src/compiler/print/index.js
index 71efc444c4..7344b748ef 100644
--- a/packages/svelte/src/compiler/print/index.js
+++ b/packages/svelte/src/compiler/print/index.js
@@ -7,6 +7,68 @@ import { is_void } from '../../utils.js';
 /** Threshold for when content should be formatted on separate lines */
 const LINE_BREAK_THRESHOLD = 50;
 
+/** Characters that are valid in a CSS identifier without escaping */
+const REGEX_IDENTIFIER_CHAR = /^[a-zA-Z0-9_-]$/;
+
+/** Hex digits — a backslash followed by one of these is read as a hex escape */
+const REGEX_HEX_DIGIT = /[0-9a-fA-F]/;
+
+/**
+ * Re-escape a CSS identifier name so that it prints as valid CSS.
+ *
+ * `parse` decodes CSS escape sequences when building the AST — `\31` becomes `1`,
+ * `\a` becomes a newline — but keeps single-character escapes such as `\.` and
+ * escaped backslashes intact. When printing we therefore only need to escape the
+ * characters that would be illegal in a bare identifier: a leading digit, `-`
+ * followed by a digit, whitespace and control characters, and anything else that
+ * is not already escaped.
+ * @param {string} name
+ */
+function escape_identifier(name) {
+	let escaped = '';
+	let i = 0;
+
+	while (i < name.length) {
+		const char = name[i];
+
+		if (char === '\\') {
+			const next = name.charAt(i + 1);
+			if (next === '' || REGEX_HEX_DIGIT.test(next)) {
+				// A literal backslash in a name must itself be escaped: `\5c `
+				// re-parses to a backslash, whereas a backslash followed by a hex
+				// digit (or by nothing) would be read back as a hex escape.
+				escaped += '\\5c ';
+				i += 1;
+				continue;
+			}
+
+			// Already escaped — copy the backslash and the escaped character as-is.
+			escaped += '\\' + next;
+			i += 2;
+			continue;
+		}
+
+		const code = /** @type {number} */ (char.codePointAt(0));
+		const is_leading_digit = i === 0 && char >= '0' && char <= '9';
+		const is_leading_hyphen_digit =
+			i === 0 && char === '-' && name.charAt(i + 1) >= '0' && name.charAt(i + 1) <= '9';
+
+		if (
+			is_leading_digit ||
+			is_leading_hyphen_digit ||
+			!(REGEX_IDENTIFIER_CHAR.test(char) || code >= 160)
+		) {
+			escaped += `\\${code.toString(16)} `;
+		} else {
+			escaped += char;
+		}
+
+		i += 1;
+	}
+
+	return escaped;
+}
+
 /**
  * `print` converts a Svelte AST node back into Svelte source code.
  * It is primarily intended for tools that parse and transform components using the compiler’s modern AST representation.
@@ -19,6 +81,10 @@ const LINE_BREAK_THRESHOLD = 50;
  */
 export function print(ast, options = undefined) {
 	const comments = (ast.type === 'Root' && ast.comments) || [];
+	const state = { preserve_whitespace: 0 };
+	const css_comments =
+		(ast.type === 'Root' ? ast.css?.comments : ast.type === 'StyleSheet' ? ast.comments : null) ||
+		[];
 
 	return esrap.print(
 		ast,
@@ -28,18 +94,27 @@ export function print(ast, options = undefined) {
 				getLeadingComments: options?.getLeadingComments,
 				getTrailingComments: options?.getTrailingComments
 			}),
-			...svelte_visitors(comments),
-			...css_visitors
-		})
+			...svelte_visitors(comments, state),
+			...css_visitors(css_comments, comments)
+		}),
+		{
+			indent: options?.indent
+		}
 	);
 }
 
 /**
  * @param {Context} context
  * @param {AST.SvelteNode} node
+ * @param {boolean} preserve_whitespace
  * @param {boolean} allow_inline
  */
-function block(context, node, allow_inline = false) {
+function block(context, node, preserve_whitespace = false, allow_inline = false) {
+	if (preserve_whitespace) {
+		context.visit(node);
+		return;
+	}
+
 	const child_context = context.new();
 	child_context.visit(node);
 
@@ -79,6 +154,7 @@ function attributes(node, attributes, context, comments) {
 	}
 
 	const separator = context.new();
+	let previous_attribute_end = node.start;
 
 	const children = attributes.map((attribute) => {
 		const child_context = context.new();
@@ -87,12 +163,16 @@ function attributes(node, attributes, context, comments) {
 			const comment = comments[comment_index];
 
 			if (comment.start < attribute.start) {
-				if (comment.type === 'Line') {
-					child_context.write('//' + comment.value);
-					child_context.newline();
-				} else {
-					child_context.write('/*' + comment.value + '*/'); // TODO match indentation?
-					child_context.append(separator);
+				// Inside a previous attribute's value can be comments which don't
+				// advance comment_index, therefore this additional check
+				if (comment.start >= previous_attribute_end) {
+					if (comment.type === 'Line') {
+						child_context.write('//' + comment.value);
+						child_context.newline();
+					} else {
+						child_context.write('/*' + comment.value + '*/'); // TODO match indentation?
+						child_context.append(separator);
+					}
 				}
 
 				comment_index += 1;
@@ -102,6 +182,7 @@ function attributes(node, attributes, context, comments) {
 		}
 
 		child_context.visit(attribute);
+		previous_attribute_end = attribute.end;
 
 		length += child_context.measure() + 1;
 
@@ -134,8 +215,9 @@ function attributes(node, attributes, context, comments) {
  * @param {AST.BaseElement} node
  * @param {Context} context
  * @param {AST.JSComment[]} comments
+ * @param {{ preserve_whitespace: number }} state
  */
-function base_element(node, context, comments) {
+function base_element(node, context, comments, state) {
 	const child_context = context.new();
 
 	child_context.write('<' + node.name);
@@ -161,174 +243,298 @@ function base_element(node, context, comments) {
 		child_context.write(`${multiline_attributes ? '' : ' '}/>`);
 	} else {
 		child_context.write('>');
-		block(child_context, node.fragment, true);
+		block(child_context, node.fragment, state.preserve_whitespace > 0, true);
 		child_context.write(`</${node.name}>`);
 	}
 
 	context.append(child_context);
 }
 
-/** @type {Visitors<AST.SvelteNode>} */
-const css_visitors = {
-	Atrule(node, context) {
-		context.write(`@${node.name}`);
-		if (node.prelude) context.write(` ${node.prelude}`);
+/**
+ * @param {AST.BaseElement} node
+ * @param {Context} context
+ * @param {AST.JSComment[]} comments
+ * @param {{ preserve_whitespace: number }} state
+ */
+function print_element(node, context, comments, state) {
+	const name = node.name.toLowerCase();
+	const preserve =
+		(node.type === 'RegularElement' || node.type === 'TitleElement') &&
+		(name === 'pre' || name === 'textarea' || name === 'title');
+
+	if (preserve) state.preserve_whitespace += 1;
+	base_element(node, context, comments, state);
+	if (preserve) state.preserve_whitespace -= 1;
+}
 
-		if (node.block) {
-			context.write(' ');
-			context.visit(node.block);
-		} else {
-			context.write(';');
-		}
-	},
+/**
+ * @param {AST.CSS.CSSComment[]} comments
+ * @param {AST.JSComment[]} js_comments
+ * @returns {Visitors<AST.SvelteNode>}
+ */
+function css_visitors(comments, js_comments) {
+	let comment_index = 0;
+
+	/** @param {number} end */
+	const has_comment_before = (end) => comments[comment_index]?.start < end;
+
+	/**
+	 * @param {Context} context
+	 * @param {AST.CSS.CSSComment} comment
+	 */
+	function write_comment(context, comment) {
+		context.write(`/*${comment.value}*/`);
+	}
 
-	AttributeSelector(node, context) {
-		context.write(`[${node.name}`);
-		if (node.matcher) {
-			context.write(node.matcher);
-			context.write(`"${node.value}"`);
-			if (node.flags) {
-				context.write(` ${node.flags}`);
-			}
+	/**
+	 * @param {Context} context
+	 * @param {number} end
+	 */
+	function write_inline_comments(context, end) {
+		let written = false;
+
+		while (has_comment_before(end)) {
+			if (written) context.write(' ');
+			write_comment(context, comments[comment_index++]);
+			written = true;
 		}
-		context.write(']');
-	},
 
-	Block(node, context) {
-		context.write('{');
+		return written;
+	}
 
-		if (node.children.length > 0) {
-			context.indent();
-			context.newline();
+	/**
+	 * @param {Context} context
+	 * @param {string} value
+	 * @param {number} end
+	 */
+	function write_value(context, value, end) {
+		let offset = 0;
+
+		while (has_comment_before(end)) {
+			const comment = comments[comment_index++];
+			const position = Math.max(offset, Math.min(comment.position ?? 0, value.length));
+			context.write(value.slice(offset, position));
+			write_comment(context, comment);
+			offset = position;
+		}
 
-			let started = false;
+		context.write(value.slice(offset));
+	}
 
-			for (const child of node.children) {
-				if (started) {
-					context.newline();
-				}
+	/**
+	 * @param {Context} context
+	 * @param {Array<AST.CSS.Rule | AST.CSS.Atrule | AST.CSS.Declaration>} children
+	 * @param {number} end
+	 * @param {boolean} margins
+	 */
+	function print_children(context, children, end, margins) {
+		let started = false;
 
-				context.visit(child);
+		const separate = () => {
+			if (!started) return;
+			if (margins) context.margin();
+			context.newline();
+		};
 
+		for (const child of children) {
+			while (has_comment_before(child.start)) {
+				separate();
+				write_comment(context, comments[comment_index++]);
 				started = true;
 			}
 
-			context.dedent();
-			context.newline();
+			separate();
+			context.visit(child);
+			started = true;
 		}
 
-		context.write('}');
-	},
+		while (has_comment_before(end)) {
+			separate();
+			write_comment(context, comments[comment_index++]);
+			started = true;
+		}
+	}
 
-	ClassSelector(node, context) {
-		context.write(`.${node.name}`);
-	},
+	/**
+	 * @param {AST.CSS.SelectorList} node
+	 * @param {Context} context
+	 * @param {boolean} multiline
+	 */
+	function print_selector_list(node, context, multiline) {
+		let needs_separator = false;
+		let remaining_selectors = node.children.length;
 
-	ComplexSelector(node, context) {
 		for (const selector of node.children) {
+			while (has_comment_before(selector.start)) {
+				if (needs_separator) context.write(' ');
+				write_comment(context, comments[comment_index++]);
+				needs_separator = true;
+			}
+
+			if (needs_separator) {
+				if (multiline) context.newline();
+				else context.write(' ');
+			}
+
 			context.visit(selector);
+			needs_separator = true;
+			remaining_selectors -= 1;
+
+			if (remaining_selectors > 0) context.write(',');
 		}
-	},
+	}
 
-	Declaration(node, context) {
-		context.write(`${node.property}: ${node.value};`);
-	},
+	return {
+		Atrule(node, context) {
+			context.write(`@${escape_identifier(node.name)}`);
 
-	IdSelector(node, context) {
-		context.write(`#${node.name}`);
-	},
+			const prelude_end = node.block?.start ?? node.end;
+			if (node.prelude || has_comment_before(prelude_end)) {
+				context.write(' ');
+				write_value(context, node.prelude, prelude_end);
+			}
 
-	NestingSelector(node, context) {
-		context.write('&');
-	},
+			if (node.block) {
+				context.write(' ');
+				context.visit(node.block);
+			} else {
+				context.write(';');
+			}
+		},
+
+		AttributeSelector(node, context) {
+			context.write(`[${escape_identifier(node.name)}`);
+			if (node.matcher) {
+				context.write(node.matcher);
+				context.write(`"${node.value}"`);
+				if (node.flags) context.write(` ${node.flags}`);
+			}
+			context.write(']');
+		},
 
-	Nth(node, context) {
-		context.write(node.value);
-	},
+		Block(node, context) {
+			context.write('{');
 
-	Percentage(node, context) {
-		context.write(node.value);
-	},
+			if (node.children.length > 0 || has_comment_before(node.end)) {
+				context.indent();
+				context.newline();
+				print_children(context, node.children, node.end, false);
+				context.dedent();
+				context.newline();
+			}
 
-	PseudoClassSelector(node, context) {
-		context.write(`:${node.name}`);
+			context.write('}');
+		},
 
-		if (node.args) {
-			context.write('(');
+		ClassSelector(node, context) {
+			context.write(`.${escape_identifier(node.name)}`);
+		},
 
-			let started = false;
+		ComplexSelector(node, context) {
+			for (const selector of node.children) context.visit(selector);
+		},
 
-			for (const arg of node.args.children) {
-				if (started) {
-					context.write(', ');
-				}
+		Declaration(node, context) {
+			context.write(`${node.property}: `);
+			write_value(context, node.value, node.end);
+			context.write(';');
+		},
 
-				context.visit(arg);
+		IdSelector(node, context) {
+			context.write(`#${escape_identifier(node.name)}`);
+		},
 
-				started = true;
-			}
+		NestingSelector(node, context) {
+			context.write('&');
+		},
 
-			context.write(')');
-		}
-	},
+		Nth(node, context) {
+			context.write(node.value);
+		},
 
-	PseudoElementSelector(node, context) {
-		context.write(`::${node.name}`);
-	},
+		Percentage(node, context) {
+			context.write(node.value);
+		},
 
-	RelativeSelector(node, context) {
-		if (node.combinator) {
-			if (node.combinator.name === ' ') {
-				context.write(' ');
-			} else {
-				context.write(` ${node.combinator.name} `);
+		PseudoClassSelector(node, context) {
+			context.write(`:${escape_identifier(node.name)}`);
+
+			if (node.args) {
+				context.write('(');
+				context.visit(node.args);
+				if (has_comment_before(node.end)) {
+					context.write(' ');
+					write_inline_comments(context, node.end);
+				}
+				context.write(')');
 			}
-		}
+		},
+
+		PseudoElementSelector(node, context) {
+			context.write(`::${escape_identifier(node.name)}`);
+			if (node.args) {
+				context.write('(');
+				context.visit(node.args);
+				if (has_comment_before(node.end)) {
+					context.write(' ');
+					write_inline_comments(context, node.end);
+				}
+				context.write(')');
+			}
+		},
 
-		for (const selector of node.selectors) {
-			context.visit(selector);
-		}
-	},
+		RelativeSelector(node, context) {
+			if (node.combinator) {
+				if (node.combinator.name === ' ') context.write(' ');
+				else context.write(` ${node.combinator.name} `);
+			}
 
-	Rule(node, context) {
-		let started = false;
+			for (const selector of node.selectors) context.visit(selector);
+		},
 
-		for (const selector of node.prelude.children) {
-			if (started) {
-				context.write(',');
-				context.newline();
-			}
+		Rule(node, context) {
+			print_selector_list(node.prelude, context, true);
+			context.write(' ');
+			if (write_inline_comments(context, node.block.start)) context.write(' ');
+			context.visit(node.block);
+		},
 
-			context.visit(selector);
-			started = true;
-		}
+		SelectorList(node, context) {
+			print_selector_list(node, context, false);
+		},
 
-		context.write(' ');
-		context.visit(node.block);
-	},
+		StyleSheet(node, context) {
+			context.write('<style');
+			attributes(node, node.attributes, context, js_comments);
+			context.write('>');
 
-	SelectorList(node, context) {
-		let started = false;
-		for (const selector of node.children) {
-			if (started) {
-				context.write(', ');
+			if (node.children.length > 0 || node.comments.length > 0) {
+				context.indent();
+				context.newline();
+				print_children(context, node.children, node.content.end, true);
+				context.dedent();
+				context.newline();
 			}
 
-			context.visit(selector);
-			started = true;
-		}
-	},
+			context.write('</style>');
+		},
 
-	TypeSelector(node, context) {
-		context.write(node.name);
-	}
-};
+		TypeSelector(node, context) {
+			if (node.namespace !== undefined) {
+				context.write(node.namespace === '*' ? '*' : escape_identifier(node.namespace));
+				context.write('|');
+			}
+			context.write(node.name === '*' ? node.name : escape_identifier(node.name));
+		}
+	};
+}
 
 /**
  * @param {AST.JSComment[]} comments
+ * @param {{ preserve_whitespace: number }} state
  * @returns {Visitors<AST.SvelteNode>}
  */
-const svelte_visitors = (comments) => ({
+const svelte_visitors = (comments, state) => ({
 	Root(node, context) {
 		if (node.options) {
 			context.write('<svelte:options');
@@ -360,20 +566,40 @@ const svelte_visitors = (comments) => ({
 		context.write('<script');
 		attributes(node, node.attributes, context, comments);
 		context.write('>');
-		block(context, node.content);
+		block(context, node.content, state.preserve_whitespace > 0);
 		context.write('</script>');
 	},
 
 	Fragment(node, context) {
-		/** @type {AST.SvelteNode[][]} */
+		if (state.preserve_whitespace > 0) {
+			for (const child of node.nodes) {
+				context.visit(child);
+				context.multiline ||= child.type === 'Text' && /[\r\n]/.test(child.data);
+			}
+			return;
+		}
+
+		const first = node.nodes[0];
+		const last = node.nodes.at(-1);
+		const has_surrounding_whitespace =
+			first?.type === 'Text' &&
+			/^\s/.test(first.data) &&
+			last?.type === 'Text' &&
+			/\s$/.test(last.data);
+
+		/** @type {{ nodes: AST.SvelteNode[]; leading_whitespace: boolean }[]} */
 		const items = [];
 
 		/** @type {AST.SvelteNode[]} */
 		let sequence = [];
+		let leading_whitespace = false;
 
 		const flush = () => {
-			items.push(sequence);
-			sequence = [];
+			if (sequence.length > 0) {
+				items.push({ nodes: sequence, leading_whitespace });
+				sequence = [];
+				leading_whitespace = false;
+			}
 		};
 
 		for (let i = 0; i < node.nodes.length; i += 1) {
@@ -402,6 +628,7 @@ const svelte_visitors = (comments) => ({
 
 				if (child_node.data.startsWith(' ') && prev && prev.type !== 'ExpressionTag') {
 					flush();
+					leading_whitespace = true;
 					child_node.data = child_node.data.trimStart();
 				}
 
@@ -440,35 +667,39 @@ const svelte_visitors = (comments) => ({
 		let multiline = false;
 		let width = 0;
 
-		const child_contexts = items
-			.filter((x) => x.length > 0)
-			.map((sequence) => {
-				const child_context = context.new();
+		const child_contexts = items.map(({ nodes, leading_whitespace }) => {
+			const child_context = context.new();
 
-				for (const node of sequence) {
-					child_context.visit(node);
-					multiline ||= child_context.multiline;
-				}
+			for (const node of nodes) {
+				child_context.visit(node);
+				multiline ||= child_context.multiline;
+			}
 
-				width += child_context.measure();
+			width += child_context.measure() + (leading_whitespace ? 1 : 0);
 
-				return child_context;
-			});
+			return { context: child_context, leading_whitespace };
+		});
 
 		multiline ||= width > LINE_BREAK_THRESHOLD;
+		// Normally context.newline() also makes context.multiline true, but the below loop only
+		// does that if we have more than one child context. If there's one long text block inside
+		// with whitespace at the edges we wanna split that up, too.
+		context.multiline ||= has_surrounding_whitespace && width > LINE_BREAK_THRESHOLD * 2;
 
 		for (let i = 0; i < child_contexts.length; i += 1) {
 			const prev = child_contexts[i];
 			const next = child_contexts[i + 1];
 
-			context.append(prev);
+			context.append(prev.context);
 
 			if (next) {
-				if (prev.multiline || next.multiline) {
+				if (prev.context.multiline || next.context.multiline) {
 					context.margin();
 					context.newline();
 				} else if (multiline) {
 					context.newline();
+				} else if (next.leading_whitespace) {
+					context.write(' ');
 				}
 			}
 		}
@@ -522,7 +753,7 @@ const svelte_visitors = (comments) => ({
 
 		if (node.pending) {
 			context.write('}');
-			block(context, node.pending);
+			block(context, node.pending, state.preserve_whitespace > 0);
 			context.write('{:');
 		} else {
 			context.write(' ');
@@ -533,7 +764,7 @@ const svelte_visitors = (comments) => ({
 			if (node.value) context.visit(node.value);
 			context.write('}');
 
-			block(context, node.then);
+			block(context, node.then, state.preserve_whitespace > 0);
 
 			if (node.catch) {
 				context.write('{:');
@@ -541,11 +772,11 @@ const svelte_visitors = (comments) => ({
 		}
 
 		if (node.catch) {
-			context.write(node.value ? 'catch ' : 'catch');
+			context.write(node.error ? 'catch ' : 'catch');
 			if (node.error) context.visit(node.error);
 			context.write('}');
 
-			block(context, node.catch);
+			block(context, node.catch, state.preserve_whitespace > 0);
 		}
 
 		context.write('{/await}');
@@ -589,7 +820,7 @@ const svelte_visitors = (comments) => ({
 	},
 
 	Component(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	ConstTag(node, context) {
@@ -679,11 +910,11 @@ const svelte_visitors = (comments) => ({
 
 		context.write('}');
 
-		block(context, node.body);
+		block(context, node.body, state.preserve_whitespace > 0);
 
 		if (node.fallback) {
 			context.write('{:else}');
-			block(context, node.fallback);
+			block(context, node.fallback, state.preserve_whitespace > 0);
 		}
 
 		context.write('{/each}');
@@ -707,13 +938,13 @@ const svelte_visitors = (comments) => ({
 			context.visit(node.test);
 			context.write('}');
 
-			block(context, node.consequent);
+			block(context, node.consequent, state.preserve_whitespace > 0);
 		} else {
 			context.write('{#if ');
 			context.visit(node.test);
 			context.write('}');
 
-			block(context, node.consequent);
+			block(context, node.consequent, state.preserve_whitespace > 0);
 		}
 
 		if (node.alternate !== null) {
@@ -725,7 +956,7 @@ const svelte_visitors = (comments) => ({
 				)
 			) {
 				context.write('{:else}');
-				block(context, node.alternate);
+				block(context, node.alternate, state.preserve_whitespace > 0);
 			} else {
 				context.visit(node.alternate);
 			}
@@ -740,7 +971,7 @@ const svelte_visitors = (comments) => ({
 		context.write('{#key ');
 		context.visit(node.expression);
 		context.write('}');
-		block(context, node.fragment);
+		block(context, node.fragment, state.preserve_whitespace > 0);
 		context.write('{/key}');
 	},
 
@@ -786,7 +1017,7 @@ const svelte_visitors = (comments) => ({
 	},
 
 	RegularElement(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	RenderTag(node, context) {
@@ -796,7 +1027,7 @@ const svelte_visitors = (comments) => ({
 	},
 
 	SlotElement(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	SnippetBlock(node, context) {
@@ -815,7 +1046,7 @@ const svelte_visitors = (comments) => ({
 		}
 
 		context.write(')}');
-		block(context, node.body);
+		block(context, node.body, state.preserve_whitespace > 0);
 		context.write('{/snippet}');
 	},
 
@@ -850,40 +1081,12 @@ const svelte_visitors = (comments) => ({
 		}
 	},
 
-	StyleSheet(node, context) {
-		context.write('<style');
-		attributes(node, node.attributes, context, comments);
-		context.write('>');
-
-		if (node.children.length > 0) {
-			context.indent();
-			context.newline();
-
-			let started = false;
-
-			for (const child of node.children) {
-				if (started) {
-					context.margin();
-					context.newline();
-				}
-
-				context.visit(child);
-				started = true;
-			}
-
-			context.dedent();
-			context.newline();
-		}
-
-		context.write('</style>');
-	},
-
 	SvelteBody(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	SvelteBoundary(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	SvelteComponent(node, context) {
@@ -895,7 +1098,7 @@ const svelte_visitors = (comments) => ({
 		attributes(node, node.attributes, context, comments);
 		if (node.fragment && node.fragment.nodes.length > 0) {
 			context.write('>');
-			block(context, node.fragment, true);
+			block(context, node.fragment, state.preserve_whitespace > 0, true);
 			context.write(`</svelte:component>`);
 		} else {
 			context.write(' />');
@@ -903,7 +1106,7 @@ const svelte_visitors = (comments) => ({
 	},
 
 	SvelteDocument(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	SvelteElement(node, context) {
@@ -916,7 +1119,7 @@ const svelte_visitors = (comments) => ({
 
 		if (node.fragment && node.fragment.nodes.length > 0) {
 			context.write('>');
-			block(context, node.fragment);
+			block(context, node.fragment, state.preserve_whitespace > 0);
 			context.write(`</svelte:element>`);
 		} else {
 			context.write(' />');
@@ -924,19 +1127,19 @@ const svelte_visitors = (comments) => ({
 	},
 
 	SvelteFragment(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	SvelteHead(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	SvelteSelf(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	SvelteWindow(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	Text(node, context) {
@@ -944,7 +1147,7 @@ const svelte_visitors = (comments) => ({
 	},
 
 	TitleElement(node, context) {
-		base_element(node, context, comments);
+		print_element(node, context, comments, state);
 	},
 
 	TransitionDirective(node, context) {
diff --git a/packages/svelte/src/compiler/print/types.d.ts b/packages/svelte/src/compiler/print/types.d.ts
index d0ff909525..9eccebb6f3 100644
--- a/packages/svelte/src/compiler/print/types.d.ts
+++ b/packages/svelte/src/compiler/print/types.d.ts
@@ -4,4 +4,5 @@ import type ts from 'esrap/languages/ts';
 export type Options = {
 	getLeadingComments?: NonNullable<Parameters<typeof ts>[0]>['getLeadingComments'] | undefined;
 	getTrailingComments?: NonNullable<Parameters<typeof ts>[0]>['getTrailingComments'] | undefined;
+	indent?: string; // default tab
 };
diff --git a/packages/svelte/src/compiler/types/css.d.ts b/packages/svelte/src/compiler/types/css.d.ts
index 13eb880d83..96b2bc3a7d 100644
--- a/packages/svelte/src/compiler/types/css.d.ts
+++ b/packages/svelte/src/compiler/types/css.d.ts
@@ -8,6 +8,15 @@ export namespace _CSS {
 
 	export interface StyleSheetBase extends BaseNode {
 		children: Array<Atrule | Rule>;
+		/** CSS comments in source order */
+		comments: CSSComment[];
+	}
+
+	export interface CSSComment extends BaseNode {
+		type: 'CSSComment';
+		value: string;
+		/** Character offset in a containing declaration value or at-rule prelude */
+		position?: number;
 	}
 
 	export interface StyleSheetFile extends StyleSheetBase {
@@ -112,6 +121,7 @@ export namespace _CSS {
 	export interface TypeSelector extends BaseNode {
 		type: 'TypeSelector';
 		name: string;
+		namespace?: string;
 	}
 
 	export interface IdSelector extends BaseNode {
@@ -135,6 +145,7 @@ export namespace _CSS {
 	export interface PseudoElementSelector extends BaseNode {
 		type: 'PseudoElementSelector';
 		name: string;
+		args?: SelectorList;
 	}
 
 	export interface PseudoClassSelector extends BaseNode {
diff --git a/packages/svelte/src/compiler/utils/mapped_code.js b/packages/svelte/src/compiler/utils/mapped_code.js
index 7686ba59c6..635743c0c4 100644
--- a/packages/svelte/src/compiler/utils/mapped_code.js
+++ b/packages/svelte/src/compiler/utils/mapped_code.js
@@ -311,6 +311,13 @@ function apply_preprocessor_sourcemap(filename, svelte_map, preprocessor_map_inp
 		typeof preprocessor_map_input === 'string'
 			? JSON.parse(preprocessor_map_input)
 			: preprocessor_map_input;
+	// A preprocessor map with a missing/empty `sources[0]` (e.g. from a MagicString transform
+	// created without a `source` option) can't be matched against `filename` during combination,
+	// which silently drops the chain instead of erroring. Normalize it to `filename` first, the
+	// same way Vite treats an empty `sources[0]` as referring to the file being transformed.
+	if (preprocessor_map.sources?.length === 1 && !preprocessor_map.sources[0]) {
+		preprocessor_map.sources = [filename];
+	}
 	const result_map = combine_sourcemaps(filename, [svelte_map, preprocessor_map]);
 	// Svelte expects a SourceMap which includes toUrl and toString. Instead of wrapping our output in a class,
 	// we just tack on the extra properties.
diff --git a/packages/svelte/src/easing/index.js b/packages/svelte/src/easing/index.js
index 08c86933ab..c2f7e63bc0 100644
--- a/packages/svelte/src/easing/index.js
+++ b/packages/svelte/src/easing/index.js
@@ -4,6 +4,8 @@ Distributed under MIT License https://github.com/mattdesl/eases/blob/master/LICE
 */
 
 /**
+ * Returns value as is.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -12,6 +14,8 @@ export function linear(t) {
 }
 
 /**
+ * Rebound effect on start and end of value range.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -22,6 +26,8 @@ export function backInOut(t) {
 }
 
 /**
+ * Rebound effect on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -31,6 +37,8 @@ export function backIn(t) {
 }
 
 /**
+ * Rebound effect on end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -40,6 +48,8 @@ export function backOut(t) {
 }
 
 /**
+ * Bounce effect on end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -61,6 +71,8 @@ export function bounceOut(t) {
 }
 
 /**
+ * Bounce effect on start and end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -69,6 +81,8 @@ export function bounceInOut(t) {
 }
 
 /**
+ * Bounce effect on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -77,6 +91,8 @@ export function bounceIn(t) {
 }
 
 /**
+ * Circular effect, accelerate on start, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -86,6 +102,8 @@ export function circInOut(t) {
 }
 
 /**
+ * Circular effect, accelerate on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -94,6 +112,8 @@ export function circIn(t) {
 }
 
 /**
+ * Circular effect, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -102,6 +122,8 @@ export function circOut(t) {
 }
 
 /**
+ * Cubic scaling, accelerate on start, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -110,6 +132,8 @@ export function cubicInOut(t) {
 }
 
 /**
+ * Cubic scaling, accelerate on start
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -118,6 +142,8 @@ export function cubicIn(t) {
 }
 
 /**
+ * Cubic scaling, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -127,6 +153,8 @@ export function cubicOut(t) {
 }
 
 /**
+ * Elastic effect on start and end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -140,6 +168,8 @@ export function elasticInOut(t) {
 }
 
 /**
+ * Elastic effect on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -148,6 +178,8 @@ export function elasticIn(t) {
 }
 
 /**
+ * Elastic effect on end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -156,6 +188,8 @@ export function elasticOut(t) {
 }
 
 /**
+ * Exponential effect on start and end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -168,6 +202,8 @@ export function expoInOut(t) {
 }
 
 /**
+ * Exponential effect on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -176,6 +212,8 @@ export function expoIn(t) {
 }
 
 /**
+ * Exponential effect on end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -184,6 +222,8 @@ export function expoOut(t) {
 }
 
 /**
+ * Quadratic scaling, accelerate on start, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -195,6 +235,8 @@ export function quadInOut(t) {
 }
 
 /**
+ * Quadratic scaling, accelerate on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -203,6 +245,8 @@ export function quadIn(t) {
 }
 
 /**
+ * Quadratic scaling, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -211,6 +255,8 @@ export function quadOut(t) {
 }
 
 /**
+ * Quartic scaling, accelerate on start, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -219,6 +265,8 @@ export function quartInOut(t) {
 }
 
 /**
+ * Quartic scaling, accelerate on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -227,6 +275,8 @@ export function quartIn(t) {
 }
 
 /**
+ * Quartic scaling, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -235,6 +285,8 @@ export function quartOut(t) {
 }
 
 /**
+ * Quintic scaling, accelerate on start, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -244,6 +296,8 @@ export function quintInOut(t) {
 }
 
 /**
+ * Quintic scaling, accelerate on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -252,6 +306,8 @@ export function quintIn(t) {
 }
 
 /**
+ * Quintic scaling, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -260,6 +316,8 @@ export function quintOut(t) {
 }
 
 /**
+ * Sinusoidal effect, accelerate on start, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -268,6 +326,8 @@ export function sineInOut(t) {
 }
 
 /**
+ * Sinusoidal effect, accelerate on start.
+ *
  * @param {number} t
  * @returns {number}
  */
@@ -278,6 +338,8 @@ export function sineIn(t) {
 }
 
 /**
+ * Sinusoidal effect, decelerate towards end.
+ *
  * @param {number} t
  * @returns {number}
  */
diff --git a/packages/svelte/src/internal/client/constants.js b/packages/svelte/src/internal/client/constants.js
index 043b50b4b2..e0b7a8779b 100644
--- a/packages/svelte/src/internal/client/constants.js
+++ b/packages/svelte/src/internal/client/constants.js
@@ -15,6 +15,13 @@ export const BLOCK_EFFECT = 1 << 4;
 export const BRANCH_EFFECT = 1 << 5;
 export const ROOT_EFFECT = 1 << 6;
 export const BOUNDARY_EFFECT = 1 << 7;
+/**
+ * Set on the effect that `pause_effect` was called on, i.e. the root of a paused subtree,
+ * as opposed to its descendants which are merely `INERT`. This allows `resume_effect` on
+ * an ancestor to skip subtrees that were paused for their own reasons (such as a block
+ * whose condition is still false) rather than resurrecting them
+ */
+export const PAUSED = 1 << 8;
 /**
  * Indicates that a reaction is connected to an effect root — either it is an effect,
  * or it is a derived that is depended on by at least one effect. If a derived has
@@ -60,6 +67,8 @@ export const ASYNC = 1 << 22;
 export const ERROR_VALUE = 1 << 23;
 
 export const STATE_SYMBOL = Symbol('$state');
+/** Marks component export objects, so that `proxy(...)` leaves them untouched */
+export const COMPONENT_SYMBOL = Symbol('component');
 export const LEGACY_PROPS = Symbol('legacy props');
 export const LOADING_ATTR_SYMBOL = Symbol('');
 export const PROXY_PATH_SYMBOL = Symbol('proxy path');
diff --git a/packages/svelte/src/internal/client/context.js b/packages/svelte/src/internal/client/context.js
index 0baef5c63e..e1571862ed 100644
--- a/packages/svelte/src/internal/client/context.js
+++ b/packages/svelte/src/internal/client/context.js
@@ -5,7 +5,9 @@ import { active_effect, active_reaction } from './runtime.js';
 import { create_user_effect } from './reactivity/effects.js';
 import { async_mode_flag, legacy_mode_flag } from '../flags/index.js';
 import { FILENAME } from '../../constants.js';
-import { BRANCH_EFFECT } from './constants.js';
+import { BRANCH_EFFECT, COMPONENT_SYMBOL } from './constants.js';
+import { define_property } from '../shared/utils.js';
+import { create_context, get_or_init_context_map } from '../shared/context.js';
 
 /** @type {ComponentContext | null} */
 export let component_context = null;
@@ -72,29 +74,23 @@ export function set_dev_current_component_function(fn) {
 /**
  * Returns a `[get, set]` pair of functions for working with context in a type-safe way.
  *
- * `get` will throw an error if no parent component called `set`.
+ * `get` will throw an error if `set` has not yet been called in the current component or any of
+ * its ancestors.
  *
  * @template T
  * @returns {[() => T, (context: T) => T]}
  * @since 5.40.0
  */
 export function createContext() {
-	const key = {};
-
-	return [
-		() => {
-			if (!hasContext(key)) {
-				e.missing_context();
-			}
-
-			return getContext(key);
-		},
-		(context) => setContext(key, context)
-	];
+	return /** @type {[() => T, (context: T) => T]} */ (
+		create_context(getContext, setContext, hasContext)
+	);
 }
 
 /**
- * Retrieves the context that belongs to the closest parent component with the specified `key`.
+ * Retrieves the context set with the specified `key` in the current component or any of its
+ * ancestors. If multiple components set the same key, the value from the closest one is returned.
+ * A `setContext` call in the current component is only visible to `getContext` calls that run after it.
  * Must be called during component initialisation.
  *
  * [`createContext`](https://svelte.dev/docs/svelte/svelte#createContext) is a type-safe alternative.
@@ -104,15 +100,15 @@ export function createContext() {
  * @returns {T}
  */
 export function getContext(key) {
-	const context_map = get_or_init_context_map('getContext');
+	const context_map = get_or_init_context_map(component_context, 'getContext');
 	const result = /** @type {T} */ (context_map.get(key));
 	return result;
 }
 
 /**
  * Associates an arbitrary `context` object with the current component and the specified `key`
- * and returns that object. The context is then available to children of the component
- * (including slotted content) with `getContext`.
+ * and returns that object. The context is then available to the component itself and all of its
+ * descendants (including slotted content) with `getContext`.
  *
  * Like lifecycle functions, this must be called during component initialisation.
  *
@@ -124,7 +120,7 @@ export function getContext(key) {
  * @returns {T}
  */
 export function setContext(key, context) {
-	const context_map = get_or_init_context_map('setContext');
+	const context_map = get_or_init_context_map(component_context, 'setContext');
 
 	if (async_mode_flag) {
 		var flags = /** @type {Effect} */ (active_effect).f;
@@ -144,27 +140,27 @@ export function setContext(key, context) {
 }
 
 /**
- * Checks whether a given `key` has been set in the context of a parent component.
- * Must be called during component initialisation.
+ * Checks whether a given `key` has been set in the context of the current component or any of
+ * its ancestors. Must be called during component initialisation.
  *
  * @param {any} key
  * @returns {boolean}
  */
 export function hasContext(key) {
-	const context_map = get_or_init_context_map('hasContext');
+	const context_map = get_or_init_context_map(component_context, 'hasContext');
 	return context_map.has(key);
 }
 
 /**
- * Retrieves the whole context map that belongs to the closest parent component.
- * Must be called during component initialisation. Useful, for example, if you
- * programmatically create a component and want to pass the existing context to it.
+ * Retrieves the whole context map that belongs to the current component, including entries
+ * inherited from its ancestors. Must be called during component initialisation. Useful, for
+ * example, if you programmatically create a component and want to pass the existing context to it.
  *
  * @template {Map<any, any>} [T=Map<any, any>]
  * @returns {T}
  */
 export function getAllContexts() {
-	const context_map = get_or_init_context_map('getAllContexts');
+	const context_map = get_or_init_context_map(component_context, 'getAllContexts');
 	return /** @type {T} */ (context_map);
 }
 
@@ -222,38 +218,19 @@ export function pop(component) {
 		dev_current_component_function = component_context?.function ?? null;
 	}
 
-	return component ?? /** @type {T} */ ({});
-}
-
-/** @returns {boolean} */
-export function is_runes() {
-	return !legacy_mode_flag || (component_context !== null && component_context.l === null);
+	return mark_as_component(component);
 }
 
 /**
- * @param {string} name
- * @returns {Map<unknown, unknown>}
+ * Add a symbol to the object (or create one if undefined) to mark it as a component so it isn't proxified.
+ * @param {any} component
  */
-function get_or_init_context_map(name) {
-	if (component_context === null) {
-		e.lifecycle_outside_component(name);
-	}
-
-	return (component_context.c ??= new Map(get_parent_context(component_context) || undefined));
+export function mark_as_component(component = {}) {
+	define_property(component, COMPONENT_SYMBOL, { value: true });
+	return component;
 }
 
-/**
- * @param {ComponentContext} component_context
- * @returns {Map<unknown, unknown> | null}
- */
-function get_parent_context(component_context) {
-	let parent = component_context.p;
-	while (parent !== null) {
-		const context_map = parent.c;
-		if (context_map !== null) {
-			return context_map;
-		}
-		parent = parent.p;
-	}
-	return null;
+/** @returns {boolean} */
+export function is_runes() {
+	return !legacy_mode_flag || (component_context !== null && component_context.l === null);
 }
diff --git a/packages/svelte/src/internal/client/dev/hmr.js b/packages/svelte/src/internal/client/dev/hmr.js
index 73dba95f9b..0e988fe66d 100644
--- a/packages/svelte/src/internal/client/dev/hmr.js
+++ b/packages/svelte/src/internal/client/dev/hmr.js
@@ -57,10 +57,21 @@ export function hmr(fn) {
 				if (ran) set_should_intro(true);
 			});
 
-			// Forward the nodes from the inner effect to the outer active effect which would
-			// get them if the HMR wrapper wasn't there. Do this inside the block not outside
-			// so that HMR updates to the component will also update the nodes on the active effect.
-			/** @type {Effect} */ (active_effect).nodes = effect.nodes;
+			// Forward the start/end DOM nodes from the inner effect to the outer active effect
+			// which would get them if the HMR wrapper wasn't there. Do this inside the block not
+			// outside so that HMR updates to the component will also update the nodes on the
+			// active effect. We copy only start/end, not the full nodes object, so that
+			// pause_children does not collect transitions from both effects and fire outroend twice.
+			var inner_nodes = effect.nodes;
+			if (inner_nodes) {
+				var ae = /** @type {Effect} */ (active_effect);
+				if (ae.nodes) {
+					ae.nodes.start = inner_nodes.start;
+					ae.nodes.end = inner_nodes.end;
+				} else {
+					ae.nodes = { start: inner_nodes.start, end: inner_nodes.end, a: null, t: null };
+				}
+			}
 		}, EFFECT_TRANSPARENT);
 
 		ran = true;
diff --git a/packages/svelte/src/internal/client/dom/blocks/boundary.js b/packages/svelte/src/internal/client/dom/blocks/boundary.js
index 0c0903ff52..fd6bbdf5b4 100644
--- a/packages/svelte/src/internal/client/dom/blocks/boundary.js
+++ b/packages/svelte/src/internal/client/dom/blocks/boundary.js
@@ -1,14 +1,8 @@
 /** @import { Effect, Source, TemplateNode, } from '#client' */
-import {
-	BOUNDARY_EFFECT,
-	DIRTY,
-	EFFECT_PRESERVED,
-	EFFECT_TRANSPARENT,
-	MAYBE_DIRTY
-} from '#client/constants';
+import { BOUNDARY_EFFECT, EFFECT_PRESERVED, EFFECT_TRANSPARENT } from '#client/constants';
 import { HYDRATION_START_ELSE, HYDRATION_START_FAILED } from '../../../../constants.js';
 import { component_context, set_component_context } from '../../context.js';
-import { handle_error, invoke_error_boundary } from '../../error-handling.js';
+import { invoke_error_boundary } from '../../error-handling.js';
 import {
 	block,
 	branch,
@@ -199,17 +193,68 @@ export class Boundary {
 	 */
 	#hydrate_failed_content(error) {
 		const failed = this.#props.failed;
+		const { reset, invoke_onerror } = this.#create_reset(error);
+
+		// `onerror` may mutate state, which is disallowed while hydrating
+		queue_micro_task(invoke_onerror);
+
 		if (!failed) return;
 
 		this.#failed_effect = branch(() => {
 			failed(
 				this.#anchor,
 				() => error,
-				() => () => {}
+				() => reset
 			);
 		});
 	}
 
+	/**
+	 * Creates the `reset` function for a failed boundary, along with a function
+	 * that invokes `onerror` with it (if provided)
+	 * @param {unknown} error
+	 * @returns {{ reset: () => void, invoke_onerror: () => void }}
+	 */
+	#create_reset(error) {
+		var did_reset = false;
+		var calling_on_error = false;
+
+		const reset = () => {
+			if (did_reset) {
+				w.svelte_boundary_reset_noop();
+				return;
+			}
+
+			did_reset = true;
+
+			if (calling_on_error) {
+				e.svelte_boundary_reset_onerror();
+			}
+
+			if (this.#failed_effect !== null) {
+				pause_effect(this.#failed_effect, () => {
+					this.#failed_effect = null;
+				});
+			}
+
+			this.#run(() => {
+				this.#render();
+			});
+		};
+
+		const invoke_onerror = () => {
+			try {
+				calling_on_error = true;
+				this.#props.onerror?.(error, reset);
+				calling_on_error = false;
+			} catch (err) {
+				invoke_error_boundary(err, this.#effect && this.#effect.parent);
+			}
+		};
+
+		return { reset, invoke_onerror };
+	}
+
 	#hydrate_pending_content() {
 		const pending = this.#props.pending;
 		if (!pending) return;
@@ -220,13 +265,31 @@ export class Boundary {
 		queue_micro_task(() => {
 			var fragment = (this.#offscreen_fragment = document.createDocumentFragment());
 			var anchor = create_text();
+			var handled = false;
 
 			fragment.append(anchor);
 
 			this.#main_effect = this.#run(() => {
-				return branch(() => this.#children(anchor));
+				try {
+					return branch(() => this.#children(anchor));
+				} catch (error) {
+					try {
+						this.error(error);
+						handled = true;
+					} catch (error) {
+						invoke_error_boundary(error, this.#effect.parent);
+					}
+
+					return null;
+				}
 			});
 
+			if (this.#main_effect === null) {
+				this.#offscreen_fragment = null;
+				if (handled) this.#resolve(/** @type {Batch} */ (current_batch));
+				return;
+			}
+
 			if (this.#pending_count === 0) {
 				this.#anchor.before(fragment);
 				this.#offscreen_fragment = null;
@@ -311,9 +374,6 @@ export class Boundary {
 		try {
 			Batch.ensure();
 			return fn();
-		} catch (e) {
-			handle_error(e);
-			return null;
 		} finally {
 			set_active_effect(previous_effect);
 			set_active_reaction(previous_reaction);
@@ -429,43 +489,13 @@ export class Boundary {
 			set_hydrate_node(skip_nodes());
 		}
 
-		var onerror = this.#props.onerror;
 		let failed = this.#props.failed;
-		var did_reset = false;
-		var calling_on_error = false;
-
-		const reset = () => {
-			if (did_reset) {
-				w.svelte_boundary_reset_noop();
-				return;
-			}
-
-			did_reset = true;
-
-			if (calling_on_error) {
-				e.svelte_boundary_reset_onerror();
-			}
-
-			if (this.#failed_effect !== null) {
-				pause_effect(this.#failed_effect, () => {
-					this.#failed_effect = null;
-				});
-			}
-
-			this.#run(() => {
-				this.#render();
-			});
-		};
 
 		/** @param {unknown} transformed_error */
 		const handle_error_result = (transformed_error) => {
-			try {
-				calling_on_error = true;
-				onerror?.(transformed_error, reset);
-				calling_on_error = false;
-			} catch (error) {
-				invoke_error_boundary(error, this.#effect && this.#effect.parent);
-			}
+			const { reset, invoke_onerror } = this.#create_reset(transformed_error);
+
+			invoke_onerror();
 
 			if (failed) {
 				this.#failed_effect = this.#run(() => {
diff --git a/packages/svelte/src/internal/client/dom/blocks/css-props.js b/packages/svelte/src/internal/client/dom/blocks/css-props.js
index 084a5561be..e5b5458d49 100644
--- a/packages/svelte/src/internal/client/dom/blocks/css-props.js
+++ b/packages/svelte/src/internal/client/dom/blocks/css-props.js
@@ -18,10 +18,10 @@ export function css_props(element, get_styles) {
 		for (var key in styles) {
 			var value = styles[key];
 
-			if (value) {
-				element.style.setProperty(key, value);
-			} else {
+			if (value == null || value === '') {
 				element.style.removeProperty(key);
+			} else {
+				element.style.setProperty(key, value);
 			}
 		}
 	});
diff --git a/packages/svelte/src/internal/client/dom/blocks/each.js b/packages/svelte/src/internal/client/dom/blocks/each.js
index 2df1d6ffa1..9a2504f887 100644
--- a/packages/svelte/src/internal/client/dom/blocks/each.js
+++ b/packages/svelte/src/internal/client/dom/blocks/each.js
@@ -103,8 +103,12 @@ function pause_effects(state, to_destroy, controlled_anchor) {
 	if (remaining === 0) {
 		// If we're in a controlled each block (i.e. the block is the only child of an
 		// element), and we are removing all items, _and_ there are no out transitions,
-		// we can use the fast path — emptying the element and replacing the anchor
-		var fast_path = transitions.length === 0 && controlled_anchor !== null;
+		// we can use the fast path — emptying the element and replacing the anchor.
+		// Skip the fast path when another batch is still pending on this each block:
+		// that batch's keys still reference EachItems in `state.items`, which
+		// `destroy_effects` needs to preserve offscreen (see #18610).
+		var fast_path =
+			transitions.length === 0 && controlled_anchor !== null && state.pending.size === 0;
 
 		if (fast_path) {
 			var anchor = /** @type {Element} */ (controlled_anchor);
diff --git a/packages/svelte/src/internal/client/dom/blocks/slot.js b/packages/svelte/src/internal/client/dom/blocks/slot.js
index 10b2959582..491f04a5ea 100644
--- a/packages/svelte/src/internal/client/dom/blocks/slot.js
+++ b/packages/svelte/src/internal/client/dom/blocks/slot.js
@@ -1,4 +1,6 @@
 import { hydrate_next, hydrating } from '../hydration.js';
+import { create_element, create_text } from '../operations.js';
+import { append } from '../template.js';
 
 /**
  * @param {Comment} anchor
@@ -12,6 +14,23 @@ export function slot(anchor, $$props, name, slot_props, fallback_fn) {
 		hydrate_next();
 	}
 
+	// Custom element slots are native DOM slots.
+	// Use the stored reference because the shadow root may be closed.
+	if ($$props.$$host?.$$shadowRoot) {
+		const element = create_element('slot');
+		if (name !== 'default') element.name = name;
+
+		append(anchor, element);
+
+		if (fallback_fn !== null) {
+			const fallback_anchor = create_text();
+			element.append(fallback_anchor);
+			fallback_fn(fallback_anchor);
+		}
+
+		return;
+	}
+
 	var slot_fn = $$props.$$slots?.[name];
 	// Interop: Can use snippets to fill slots
 	var is_interop = false;
diff --git a/packages/svelte/src/internal/client/dom/blocks/svelte-head.js b/packages/svelte/src/internal/client/dom/blocks/svelte-head.js
index 5721f7b056..d22d74b275 100644
--- a/packages/svelte/src/internal/client/dom/blocks/svelte-head.js
+++ b/packages/svelte/src/internal/client/dom/blocks/svelte-head.js
@@ -52,6 +52,14 @@ export function head(hash, render_fn) {
 		block(() => {
 			var e = branch(() => render_fn(anchor));
 			e.f |= HEAD_EFFECT;
+
+			if (!hydrating) {
+				if (e.nodes === null) {
+					e.nodes = { start: anchor, end: anchor, a: null, t: null };
+				} else {
+					e.nodes.end = anchor;
+				}
+			}
 		});
 	} finally {
 		if (was_hydrating) {
diff --git a/packages/svelte/src/internal/client/dom/css.js b/packages/svelte/src/internal/client/dom/css.js
index 74bf2d49f9..23f4eff4f7 100644
--- a/packages/svelte/src/internal/client/dom/css.js
+++ b/packages/svelte/src/internal/client/dom/css.js
@@ -2,14 +2,19 @@ import { DEV } from 'esm-env';
 import { register_style } from '../dev/css.js';
 import { effect } from '../reactivity/effects.js';
 import { create_element } from './operations.js';
+import { active_effect } from '../runtime.js';
 
 /**
  * @param {Node} anchor
  * @param {{ hash: string, code: string }} css
  */
 export function append_styles(anchor, css) {
-	// Use `queue_micro_task` to ensure `anchor` is in the DOM, otherwise getRootNode() will yield wrong results
+	// 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
+		// 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();
 
 		var target = /** @type {ShadowRoot} */ (root).host
diff --git a/packages/svelte/src/internal/client/dom/elements/attributes.js b/packages/svelte/src/internal/client/dom/elements/attributes.js
index 589685b5f2..7439db56e9 100644
--- a/packages/svelte/src/internal/client/dom/elements/attributes.js
+++ b/packages/svelte/src/internal/client/dom/elements/attributes.js
@@ -26,7 +26,12 @@ import { set_class } from './class.js';
 import { set_style } from './style.js';
 import { ATTACHMENT_KEY, NAMESPACE_HTML, UNINITIALIZED } from '../../../../constants.js';
 import { branch, destroy_effect, effect, managed } from '../../reactivity/effects.js';
-import { init_select, select_option } from './bindings/select.js';
+import {
+	init_select,
+	select_option,
+	set_default_select_value,
+	set_selected
+} from './bindings/select.js';
 import { flatten } from '../../reactivity/async.js';
 
 export const CLASS = Symbol('class');
@@ -122,25 +127,6 @@ export function set_checked(element, checked) {
 	element.checked = checked;
 }
 
-/**
- * Sets the `selected` attribute on an `option` element.
- * Not set through the property because that doesn't reflect to the DOM,
- * which means it wouldn't be taken into account when a form is reset.
- * @param {HTMLOptionElement} element
- * @param {boolean} selected
- */
-export function set_selected(element, selected) {
-	if (selected) {
-		// The selected option could've changed via user selection, and
-		// setting the value without this check would set it back.
-		if (!element.hasAttribute('selected')) {
-			element.setAttribute('selected', '');
-		}
-	} else {
-		element.removeAttribute('selected');
-	}
-}
-
 /**
  * Applies the default checked property without influencing the current checked property.
  * @param {HTMLInputElement} element
@@ -201,7 +187,7 @@ export function set_attribute(element, attribute, value, skip_warning) {
 
 	if (value == null) {
 		element.removeAttribute(attribute);
-	} else if (typeof value !== 'string' && get_setters(element).includes(attribute)) {
+	} else if (typeof value !== 'string' && get_setters(element).has(attribute)) {
 		// @ts-ignore
 		element[attribute] = value;
 	} else {
@@ -252,7 +238,7 @@ export function set_custom_element_data(node, prop, value) {
 			// customElements may not be available in browser extension contexts
 			!customElements ||
 			customElements.get(node.getAttribute('is') || node.nodeName.toLowerCase())
-				? get_setters(node).includes(prop)
+				? get_setters(node).has(prop)
 				: value && typeof value === 'object')
 		) {
 			// @ts-expect-error
@@ -291,11 +277,8 @@ function set_attributes(
 	skip_warning = false
 ) {
 	if (hydrating && should_remove_defaults && element.nodeName === INPUT_TAG) {
-		var input = /** @type {HTMLInputElement} */ (element);
-		var attribute = input.type === 'checkbox' ? 'defaultChecked' : 'defaultValue';
-
-		if (!(attribute in next)) {
-			remove_input_defaults(input);
+		if (!('defaultValue' in next || 'defaultChecked' in next)) {
+			remove_input_defaults(/** @type {HTMLInputElement} */ (element));
 		}
 	}
 
@@ -313,9 +296,11 @@ function set_attributes(
 
 	var current = prev || {};
 	var is_option_element = element.nodeName === OPTION_TAG;
+	var is_select_element = element.nodeName === SELECT_TAG;
 
 	for (var key in prev) {
-		if (!(key in next)) {
+		// don't null our internal $$onX listeners
+		if (!(key in next) && key[0] + key[1] !== '$$') {
 			next[key] = null;
 		}
 	}
@@ -448,6 +433,9 @@ function set_attributes(
 
 			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;
 
@@ -472,7 +460,7 @@ function set_attributes(
 				}
 			} else if (
 				is_default ||
-				(setters.includes(name) && (is_custom_element || typeof value !== 'string'))
+				((is_custom_element || typeof value !== 'string') && setters.has(name))
 			) {
 				// @ts-ignore
 				element[name] = value;
@@ -533,8 +521,16 @@ export function attribute_effect(
 				skip_warning
 			);
 
-			if (inited && is_select && 'value' in next) {
-				select_option(/** @type {HTMLSelectElement} */ (element), next.value);
+			if (inited && is_select) {
+				var select = /** @type {HTMLSelectElement} */ (element);
+
+				if ('defaultValue' in next) {
+					set_default_select_value(select, next.defaultValue, false);
+				}
+
+				if ('value' in next) {
+					select_option(select, next.value);
+				}
 			}
 
 			for (let symbol of Object.getOwnPropertySymbols(effects)) {
@@ -559,7 +555,13 @@ export function attribute_effect(
 			var select = /** @type {HTMLSelectElement} */ (element);
 
 			effect(() => {
-				select_option(select, /** @type {Record<string | symbol, any>} */ (prev).value, true);
+				var attrs = /** @type {Record<string | symbol, any>} */ (prev);
+
+				if ('defaultValue' in attrs) {
+					set_default_select_value(select, attrs.defaultValue, true);
+				}
+
+				select_option(select, attrs.value, true);
 				init_select(select);
 			});
 		}
@@ -581,7 +583,7 @@ function get_attributes(element) {
 	);
 }
 
-/** @type {Map<string, string[]>} */
+/** @type {Map<string, Set<string>>} */
 var setters_cache = new Map();
 
 /** @param {Element} element */
@@ -589,7 +591,7 @@ function get_setters(element) {
 	var cache_key = element.getAttribute('is') || element.nodeName;
 	var setters = setters_cache.get(cache_key);
 	if (setters) return setters;
-	setters_cache.set(cache_key, (setters = []));
+	setters_cache.set(cache_key, (setters = new Set()));
 
 	var descriptors;
 	var proto = element; // In the case of custom elements there might be setters on the instance
@@ -608,7 +610,7 @@ function get_setters(element) {
 				key !== 'textContent' &&
 				key !== 'innerText'
 			) {
-				setters.push(key);
+				setters.add(key);
 			}
 		}
 
diff --git a/packages/svelte/src/internal/client/dom/elements/bindings/select.js b/packages/svelte/src/internal/client/dom/elements/bindings/select.js
index eb26062653..fd1ebb92b8 100644
--- a/packages/svelte/src/internal/client/dom/elements/bindings/select.js
+++ b/packages/svelte/src/internal/client/dom/elements/bindings/select.js
@@ -6,6 +6,50 @@ import * as w from '../../../warnings.js';
 import { Batch, current_batch, previous_batch } from '../../../reactivity/batch.js';
 import { async_mode_flag } from '../../../../flags/index.js';
 
+/**
+ * Sets the `selected` attribute on an option so form reset can restore it.
+ * @param {HTMLOptionElement} option
+ * @param {boolean} selected
+ */
+export function set_selected(option, selected) {
+	if (selected) {
+		if (!option.hasAttribute('selected')) option.setAttribute('selected', '');
+	} else {
+		option.removeAttribute('selected');
+	}
+}
+
+/**
+ * Sets the options a form reset should restore without changing the current selection.
+ * The initial call is allowed to establish the current selection when no value exists.
+ * @param {HTMLSelectElement} select
+ * @param {any} value
+ * @param {boolean} [mounting]
+ */
+export function set_default_select_value(select, value, mounting = !('__defaultValue' in select)) {
+	// The DOM cannot recover unmatched, object or multiple defaults from selected options.
+	// Keep the requested value so option mutations can reapply it; property presence also
+	// distinguishes the initial application from later updates when the value is undefined.
+	// @ts-expect-error
+	select.__defaultValue = value;
+	var values = select.multiple ? (value == null ? [] : value) : null;
+
+	if (select.multiple && !is_array(values)) return;
+	var selected = !mounting || '__value' in select ? new Set(select.selectedOptions) : null;
+
+	for (var option of select.options) {
+		var option_value = get_option_value(option);
+		var is_selected = select.multiple
+			? /** @type {any[]} */ (values).includes(option_value)
+			: is(option_value, value);
+		set_selected(option, is_selected);
+	}
+
+	if (selected !== null) {
+		for (option of select.options) option.selected = selected.has(option);
+	}
+}
+
 /**
  * Selects the correct option(s) (depending on whether this is a multiple select)
  * @template V
@@ -55,9 +99,20 @@ export function select_option(select, value, mounting = false) {
  * @param {HTMLSelectElement} select
  */
 export function init_select(select) {
-	var observer = new MutationObserver(() => {
-		// @ts-ignore
-		select_option(select, select.__value);
+	var observer = new MutationObserver((entries) => {
+		// Mutations related to `<selectedcontent>` can never affect the option list.
+		// Reacting to them could revert a user-initiated selection change, because the
+		// records are delivered as soon as any listener returns (e.g. a delegated `input`
+		// handler), which can happen before the `change` handler has updated `__value`
+		if (entries.every(is_selectedcontent_mutation)) return;
+
+		if ('__defaultValue' in select) {
+			set_default_select_value(select, select.__defaultValue, false);
+		}
+
+		if ('__value' in select) {
+			select_option(select, select.__value);
+		}
 		// Deliberately don't update the potential binding value,
 		// the model should be preserved unless explicitly changed
 	});
@@ -162,3 +217,22 @@ function get_option_value(option) {
 		return option.value;
 	}
 }
+
+/**
+ * Returns `true` if the mutation stems from the browser mirroring the selected
+ * option's content into `<selectedcontent>`, or from us replacing the
+ * `<selectedcontent>` element with a clone of itself
+ * @param {MutationRecord} entry
+ */
+function is_selectedcontent_mutation(entry) {
+	if (/** @type {Element} */ (entry.target).closest('selectedcontent') !== null) {
+		return true;
+	}
+
+	if (entry.type === 'childList') {
+		var nodes = [...entry.addedNodes, ...entry.removedNodes];
+		return nodes.length > 0 && nodes.every((node) => node.nodeName === 'SELECTEDCONTENT');
+	}
+
+	return false;
+}
diff --git a/packages/svelte/src/internal/client/dom/elements/bindings/this.js b/packages/svelte/src/internal/client/dom/elements/bindings/this.js
index 52f0c213d3..705adc99ec 100644
--- a/packages/svelte/src/internal/client/dom/elements/bindings/this.js
+++ b/packages/svelte/src/internal/client/dom/elements/bindings/this.js
@@ -1,6 +1,6 @@
 /** @import { ComponentContext, Effect } from '#client' */
 import { DESTROYING, STATE_SYMBOL } from '#client/constants';
-import { component_context } from '../../../context.js';
+import { component_context, mark_as_component } from '../../../context.js';
 import { effect, render_effect } from '../../../reactivity/effects.js';
 import { active_effect, untrack } from '../../../runtime.js';
 
@@ -23,7 +23,12 @@ function is_bound_this(bound_value, element_or_component) {
  * 										returns all the parts of the each block context that are used in the expression
  * @returns {void}
  */
-export function bind_this(element_or_component = {}, update, get_value, get_parts) {
+export function bind_this(
+	element_or_component = mark_as_component(),
+	update,
+	get_value,
+	get_parts
+) {
 	var component_effect = /** @type {ComponentContext} */ (component_context).r;
 	var parent = /** @type {Effect} */ (active_effect);
 
diff --git a/packages/svelte/src/internal/client/dom/elements/events.js b/packages/svelte/src/internal/client/dom/elements/events.js
index 45e042a8c6..068c64b9ab 100644
--- a/packages/svelte/src/internal/client/dom/elements/events.js
+++ b/packages/svelte/src/internal/client/dom/elements/events.js
@@ -159,12 +159,15 @@ export function delegate(events) {
 }
 
 // used to store the reference to the currently propagated event
-// to prevent garbage collection between microtasks in Firefox
+// to prevent garbage collection between microtasks in Firefox (<= 141)
 // If the event object is GCed too early, the expando __root property
 // set on the event object is lost, causing the event delegation
 // to process the event twice
 let last_propagated_event = null;
 
+// whether a task is already queued to clear `last_propagated_event`
+let last_propagated_event_clear_scheduled = false;
+
 /**
  * @this {EventTarget}
  * @param {Event} event
@@ -179,6 +182,21 @@ export function handle_event_propagation(event) {
 
 	last_propagated_event = event;
 
+	// The reference is only needed while the event can still reach another
+	// delegated root, i.e. during the current (synchronous) dispatch and its
+	// microtask checkpoints. Clearing it in a later task preserves the
+	// Firefox workaround while making sure the slot doesn't retain the last
+	// event forever — through `event.target` it would otherwise keep the
+	// entire detached subtree of whatever the user last clicked in alive
+	// until the next delegated event happens to arrive.
+	if (!last_propagated_event_clear_scheduled) {
+		last_propagated_event_clear_scheduled = true;
+		setTimeout(() => {
+			last_propagated_event_clear_scheduled = false;
+			last_propagated_event = null;
+		});
+	}
+
 	// composedPath contains list of nodes the event has propagated through.
 	// We check `event_symbol` to skip all nodes below it in case this is a
 	// parent of the `event_symbol` node, which indicates that there's nested
diff --git a/packages/svelte/src/internal/client/dom/elements/transitions.js b/packages/svelte/src/internal/client/dom/elements/transitions.js
index 7c4d385807..67b177841a 100644
--- a/packages/svelte/src/internal/client/dom/elements/transitions.js
+++ b/packages/svelte/src/internal/client/dom/elements/transitions.js
@@ -337,6 +337,7 @@ export function transition(flags, element, get_fn, get_params) {
  */
 function animate(element, options, counterpart, t2, on_begin, on_finish) {
 	var is_intro = t2 === 1;
+	var aborted = false;
 
 	if (is_function(options)) {
 		// In the case of a deferred transition (such as `crossfade`), `option` will be
@@ -344,7 +345,6 @@ function animate(element, options, counterpart, t2, on_begin, on_finish) {
 		// once the DOM has been updated...
 		/** @type {Animation} */
 		var a;
-		var aborted = false;
 
 		queue_micro_task(() => {
 			if (aborted) return;
@@ -381,99 +381,112 @@ function animate(element, options, counterpart, t2, on_begin, on_finish) {
 
 	const { delay = 0, css, tick, easing = linear } = options;
 
-	var keyframes = [];
+	/** @type {globalThis.Animation} */
+	var animation;
 
-	if (is_intro && counterpart === undefined) {
-		if (tick) {
-			tick(0, 1); // TODO put in nested effect, to avoid interleaved reads/writes?
-		}
+	var get_t = () => 1 - t2;
 
-		if (css) {
-			var styles = css_to_keyframe(css(0, 1));
-			keyframes.push(styles, styles);
-		}
-	}
+	// wait a microtask before applying the initial styles and creating the dummy animation,
+	// so that transitions created in the same batch (e.g. on nested elements) all measure
+	// the DOM first (#18421). this still happens before the next paint, so the element
+	// won't be rendered without styles applied (#14732)
+	queue_micro_task(() => {
+		if (aborted) return;
 
-	var get_t = () => 1 - t2;
+		var keyframes = [];
 
-	// create a dummy animation that lasts as long as the delay (but with whatever devtools
-	// multiplier is in effect). in the common case that it is `0`, we keep it anyway so that
-	// the CSS keyframes aren't created until the DOM is updated
-	//
-	// fill forwards to prevent the element from rendering without styles applied
-	// see https://github.com/sveltejs/svelte/issues/14732
-	var animation = element.animate(keyframes, { duration: delay, fill: 'forwards' });
+		if (is_intro && counterpart === undefined) {
+			if (tick) {
+				tick(0, 1); // TODO put in nested effect, to avoid interleaved reads/writes?
+			}
 
-	animation.onfinish = () => {
-		// remove dummy animation from the stack to prevent conflict with main animation
-		animation.cancel();
+			if (css) {
+				var styles = css_to_keyframe(css(0, 1));
+				keyframes.push(styles, styles);
+			}
+		}
 
-		on_begin();
+		// create a dummy animation that lasts as long as the delay (but with whatever devtools
+		// multiplier is in effect). in the common case that it is `0`, we keep it anyway so that
+		// the CSS keyframes aren't created until the DOM is updated
+		//
+		// fill forwards to prevent the element from rendering without styles applied
+		// see https://github.com/sveltejs/svelte/issues/14732
+		animation = element.animate(keyframes, { duration: delay, fill: 'forwards' });
 
-		// for bidirectional transitions, we start from the current position,
-		// rather than doing a full intro/outro
-		var t1 = counterpart?.t() ?? 1 - t2;
-		counterpart?.abort();
+		animation.onfinish = () => {
+			// remove dummy animation from the stack to prevent conflict with main animation
+			animation.cancel();
 
-		var delta = t2 - t1;
-		var duration = /** @type {number} */ (options.duration) * Math.abs(delta);
-		var keyframes = [];
+			on_begin();
 
-		if (duration > 0) {
-			/**
-			 * Whether or not the CSS includes `overflow: hidden`, in which case we need to
-			 * add it as an inline style to work around a Safari <18 bug
-			 * TODO 6.0 remove this, if possible
-			 */
-			var needs_overflow_hidden = false;
+			// for bidirectional transitions, we start from the current position,
+			// rather than doing a full intro/outro
+			var t1 = counterpart?.t() ?? 1 - t2;
+			counterpart?.abort();
 
-			if (css) {
-				var n = Math.ceil(duration / (1000 / 60)); // `n` must be an integer, or we risk missing the `t2` value
+			var delta = t2 - t1;
+			var duration = /** @type {number} */ (options.duration) * Math.abs(delta);
+			var keyframes = [];
+
+			if (duration > 0) {
+				/**
+				 * Whether or not the CSS includes `overflow: hidden`, in which case we need to
+				 * add it as an inline style to work around a Safari <18 bug
+				 * TODO 6.0 remove this, if possible
+				 */
+				var needs_overflow_hidden = false;
 
-				for (var i = 0; i <= n; i += 1) {
-					var t = t1 + delta * easing(i / n);
-					var styles = css_to_keyframe(css(t, 1 - t));
-					keyframes.push(styles);
+				if (css) {
+					var n = Math.ceil(duration / (1000 / 60)); // `n` must be an integer, or we risk missing the `t2` value
 
-					needs_overflow_hidden ||= styles.overflow === 'hidden';
+					for (var i = 0; i <= n; i += 1) {
+						var t = t1 + delta * easing(i / n);
+						var styles = css_to_keyframe(css(t, 1 - t));
+						keyframes.push(styles);
+
+						needs_overflow_hidden ||= styles.overflow === 'hidden';
+					}
 				}
-			}
 
-			if (needs_overflow_hidden) {
-				/** @type {HTMLElement} */ (element).style.overflow = 'hidden';
-			}
+				if (needs_overflow_hidden) {
+					/** @type {HTMLElement} */ (element).style.overflow = 'hidden';
+				}
 
-			get_t = () => {
-				var time = /** @type {number} */ (
-					/** @type {globalThis.Animation} */ (animation).currentTime
-				);
+				get_t = () => {
+					var time = /** @type {number} */ (
+						/** @type {globalThis.Animation} */ (animation).currentTime
+					);
 
-				return t1 + delta * easing(time / duration);
-			};
+					return t1 + delta * easing(time / duration);
+				};
 
-			if (tick) {
-				loop(() => {
-					if (animation.playState !== 'running') return false;
+				if (tick) {
+					loop(() => {
+						if (animation.playState !== 'running') return false;
 
-					var t = get_t();
-					tick(t, 1 - t);
+						var t = get_t();
+						tick(t, 1 - t);
 
-					return true;
-				});
+						return true;
+					});
+				}
 			}
-		}
 
-		animation = element.animate(keyframes, { duration, fill: 'forwards' });
+			animation = element.animate(keyframes, { duration, fill: 'forwards' });
 
-		animation.onfinish = () => {
-			get_t = () => t2;
-			tick?.(t2, 1 - t2);
-			on_finish();
+			animation.onfinish = () => {
+				get_t = () => t2;
+				tick?.(t2, 1 - t2);
+				on_finish();
+			};
 		};
-	};
+	});
 
 	return {
 		abort: () => {
+			aborted = true;
+
 			if (animation) {
 				animation.cancel();
 				// This prevents memory leaks in Chromium
diff --git a/packages/svelte/src/internal/client/dom/operations.js b/packages/svelte/src/internal/client/dom/operations.js
index bc12a0b07e..21b5ee4ecb 100644
--- a/packages/svelte/src/internal/client/dom/operations.js
+++ b/packages/svelte/src/internal/client/dom/operations.js
@@ -1,5 +1,5 @@
 /** @import { Effect, TemplateNode } from '#client' */
-import { hydrate_node, hydrating, set_hydrate_node } from './hydration.js';
+import { hydrate_node, hydrating, reset, set_hydrate_node } from './hydration.js';
 import { DEV } from 'esm-env';
 import { init_array_prototype_warnings } from '../dev/equality.js';
 import { get_descriptor, is_extensible } from '../../shared/utils.js';
@@ -165,6 +165,26 @@ export function first_child(node, is_text = false) {
 	return hydrate_node;
 }
 
+/**
+ * `child`, for the very common case of an element with exactly one child. Resetting the
+ * hydration cursor is part of the same step, so the compiler doesn't have to emit a
+ * separate `reset` call for every `<p>{text}</p>` in an app.
+ * Don't mark this as side-effect-free, hydration needs to walk all nodes
+ * @param {TemplateNode} node
+ * @param {boolean} [is_text]
+ * @returns {TemplateNode | null}
+ */
+export function only_child(node, is_text = false) {
+	if (!hydrating) {
+		return get_first_child(node);
+	}
+
+	var first = child(node, is_text);
+	reset(node);
+
+	return first;
+}
+
 /**
  * Don't mark this as side-effect-free, hydration needs to walk all nodes
  * @param {TemplateNode} node
diff --git a/packages/svelte/src/internal/client/error-handling.js b/packages/svelte/src/internal/client/error-handling.js
index 7c404dd933..a46281d36c 100644
--- a/packages/svelte/src/internal/client/error-handling.js
+++ b/packages/svelte/src/internal/client/error-handling.js
@@ -3,7 +3,14 @@
 import { DEV } from 'esm-env';
 import { FILENAME } from '../../constants.js';
 import { is_firefox } from './dom/operations.js';
-import { ERROR_VALUE, BOUNDARY_EFFECT, REACTION_RAN, EFFECT, DESTROYED } from './constants.js';
+import {
+	ERROR_VALUE,
+	BOUNDARY_EFFECT,
+	REACTION_RAN,
+	EFFECT,
+	DESTROYED,
+	DESTROYING
+} from './constants.js';
 import { define_property, get_descriptor } from '../shared/utils.js';
 import { active_effect, active_reaction } from './runtime.js';
 
@@ -50,7 +57,8 @@ export function invoke_error_boundary(error, effect) {
 	}
 
 	while (effect !== null) {
-		if ((effect.f & BOUNDARY_EFFECT) !== 0) {
+		// Skip boundaries that are destroyed/destroying and cannot meaningfully handle the error.
+		if ((effect.f & BOUNDARY_EFFECT) !== 0 && (effect.f & (DESTROYED | DESTROYING)) === 0) {
 			if ((effect.f & REACTION_RAN) === 0) {
 				// we are still creating the boundary effect
 				throw error;
diff --git a/packages/svelte/src/internal/client/error-handling.test.ts b/packages/svelte/src/internal/client/error-handling.test.ts
new file mode 100644
index 0000000000..2eb6093a2c
--- /dev/null
+++ b/packages/svelte/src/internal/client/error-handling.test.ts
@@ -0,0 +1,39 @@
+import { assert, test } from 'vitest';
+import { BOUNDARY_EFFECT, DESTROYED, REACTION_RAN } from './constants';
+import { invoke_error_boundary } from './error-handling';
+import type { Effect } from './types';
+
+test('ignores errors from a destroyed entry effect', () => {
+	const error = new Error('original');
+	let handled = null;
+	const boundary = {
+		f: BOUNDARY_EFFECT | REACTION_RAN,
+		b: { error: (error: unknown) => (handled = error) },
+		parent: null
+	} as unknown as Effect;
+	const effect = { f: DESTROYED, parent: boundary } as Effect;
+
+	invoke_error_boundary(error, effect);
+
+	assert.equal(handled, null);
+});
+
+test('skips destroyed boundary ancestors without masking the error', () => {
+	const error = new Error('original');
+	let handled = null;
+	const live_boundary = {
+		f: BOUNDARY_EFFECT | REACTION_RAN,
+		b: { error: (error: unknown) => (handled = error) },
+		parent: null
+	} as unknown as Effect;
+	const destroyed_boundary = {
+		f: BOUNDARY_EFFECT | DESTROYED | REACTION_RAN,
+		b: null,
+		parent: live_boundary
+	} as unknown as Effect;
+	const effect = { f: 0, parent: destroyed_boundary } as Effect;
+
+	invoke_error_boundary(error, effect);
+
+	assert.equal(handled, error);
+});
diff --git a/packages/svelte/src/internal/client/index.js b/packages/svelte/src/internal/client/index.js
index 89fd485e04..f19edf935b 100644
--- a/packages/svelte/src/internal/client/index.js
+++ b/packages/svelte/src/internal/client/index.js
@@ -34,7 +34,6 @@ export {
 	set_xlink_attribute,
 	set_value,
 	set_checked,
-	set_selected,
 	set_default_checked,
 	set_default_value,
 	CLASS,
@@ -63,7 +62,13 @@ export {
 } from './dom/elements/bindings/media.js';
 export { bind_online } from './dom/elements/bindings/navigator.js';
 export { bind_prop } from './dom/elements/bindings/props.js';
-export { bind_select_value, init_select, select_option } from './dom/elements/bindings/select.js';
+export {
+	bind_select_value,
+	init_select,
+	select_option,
+	set_selected,
+	set_default_select_value
+} from './dom/elements/bindings/select.js';
 export { bind_element_size, bind_resize_observer } from './dom/elements/bindings/size.js';
 export { bind_this } from './dom/elements/bindings/this.js';
 export {
@@ -104,6 +109,7 @@ export {
 	run,
 	save,
 	track_reactivity_loss,
+	unsave,
 	run_after_blockers,
 	wait
 } from './reactivity/async.js';
@@ -164,6 +170,7 @@ export { proxy } from './proxy.js';
 export { create_custom_element } from './dom/elements/custom-element.js';
 export {
 	child,
+	only_child,
 	first_child,
 	sibling,
 	$window as window,
diff --git a/packages/svelte/src/internal/client/proxy.js b/packages/svelte/src/internal/client/proxy.js
index 51333e597f..91d82f8903 100644
--- a/packages/svelte/src/internal/client/proxy.js
+++ b/packages/svelte/src/internal/client/proxy.js
@@ -22,7 +22,7 @@ import {
 	flush_eager_effects,
 	set_eager_effects_deferred
 } from './reactivity/sources.js';
-import { PROXY_PATH_SYMBOL, STATE_SYMBOL } from '#client/constants';
+import { COMPONENT_SYMBOL, PROXY_PATH_SYMBOL, STATE_SYMBOL } from '#client/constants';
 import { UNINITIALIZED } from '../../constants.js';
 import * as e from './errors.js';
 import { tag } from './dev/tracing.js';
@@ -38,8 +38,13 @@ const regex_is_valid_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
  * @returns {T}
  */
 export function proxy(value) {
-	// if non-proxyable, or is already a proxy, return `value`
-	if (typeof value !== 'object' || value === null || STATE_SYMBOL in value) {
+	// if non-proxyable, a component instance, or already a proxy, return `value`
+	if (
+		typeof value !== 'object' ||
+		value === null ||
+		STATE_SYMBOL in value ||
+		COMPONENT_SYMBOL in value
+	) {
 		return value;
 	}
 
diff --git a/packages/svelte/src/internal/client/reactivity/async.js b/packages/svelte/src/internal/client/reactivity/async.js
index 2e7df92dc0..a75f97a54f 100644
--- a/packages/svelte/src/internal/client/reactivity/async.js
+++ b/packages/svelte/src/internal/client/reactivity/async.js
@@ -8,7 +8,6 @@ import {
 	set_component_context,
 	set_dev_stack
 } from '../context.js';
-import { Boundary } from '../dom/blocks/boundary.js';
 import { invoke_error_boundary } from '../error-handling.js';
 import {
 	active_effect,
@@ -25,7 +24,6 @@ import {
 	set_reactivity_loss_tracker
 } from './deriveds.js';
 import { aborted } from './effects.js';
-import { queue_micro_task } from '../dom/task.js';
 
 /**
  * @param {Blocker[]} blockers
@@ -156,6 +154,9 @@ export function capture() {
 	};
 }
 
+/** `true` between a `save` thunk restoring a context and the end of that synchronous segment */
+var restored = false;
+
 /**
  * Wraps an `await` expression in such a way that the effect context that was
  * active before the expression evaluated can be reapplied afterwards —
@@ -166,15 +167,32 @@ export function capture() {
  */
 export async function save(promise) {
 	var restore = capture();
+	// the context restored by an earlier `save` in this expression must not
+	// outlive the synchronous segment that is about to end at this `await`
+	unsave();
 	var value = await promise;
 
 	return () => {
 		restore();
-		queue_micro_task(unset_context);
+		restored = true;
 		return value;
 	};
 }
 
+/**
+ * Unset the context if a `save` thunk restored it in the current synchronous segment,
+ * so that a foreign microtask can never run inside a restored reaction context.
+ * Called at every suspension point, and at the end of async expression bodies —
+ * `async () => (await $.save(a))().b` becomes `async () => { try { return (await $.save(a))().b; } finally { $.unsave(); } }`
+ * @template T
+ * @param {T} [value]
+ * @returns {T}
+ */
+export function unsave(value) {
+	if (restored) unset_context();
+	return /** @type {T} */ (value);
+}
+
 /**
  * Reset `current_async_effect` after the `promise` resolves, so
  * that we can emit `await_reactivity_loss` warnings
@@ -183,6 +201,7 @@ export async function save(promise) {
  * @returns {Promise<() => T>}
  */
 export async function track_reactivity_loss(promise) {
+	unsave();
 	var previous_reactivity_loss_tracker = reactivity_loss_tracker;
 	// Ensure that unrelated reads after an async operation is kicked off don't cause false positives
 	queueMicrotask(() => {
@@ -269,6 +288,7 @@ export async function* for_await_track_reactivity_loss(iterable) {
 }
 
 export function unset_context(deactivate_batch = true) {
+	restored = false;
 	set_active_effect(null);
 	set_active_reaction(null);
 	set_component_context(null);
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index cb493d805c..2ae6b21b13 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -426,6 +426,7 @@ export class Batch {
 		}
 
 		if (next_batch !== null) {
+			old_values.clear();
 			next_batch.#process();
 		}
 	}
@@ -536,6 +537,12 @@ export class Batch {
 		const mark = (value) => {
 			var reactions = value.reactions;
 			if (reactions === null) return;
+			// skip if value is derived and is neither dirty nor maybe dirty. transitive
+			// deriveds (a derived depending on another derived) are only MAYBE_DIRTY, so
+			// we must continue traversing them to reach the effects that depend on them
+			if ((value.f & DERIVED) !== 0 && (value.f & (DIRTY | MAYBE_DIRTY)) === 0) {
+				return;
+			}
 
 			for (const reaction of reactions) {
 				var flags = reaction.f;
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index fd64f3b45d..6b48bc8a23 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -28,6 +28,7 @@ import {
 	skipped_deps,
 	new_deps
 } from '../runtime.js';
+import { without_reactive_context } from '../dom/elements/bindings/shared.js';
 import { equals, safe_equals } from './equality.js';
 import * as e from '../errors.js';
 import * as w from '../warnings.js';
@@ -450,14 +451,18 @@ export function freeze_derived_effects(derived) {
 		// if the effect has a teardown function or abort signal, call it
 		if (e.teardown || e.ac) {
 			e.teardown?.();
-			e.ac?.abort(STALE_REACTION);
+			if (e.ac !== null) {
+				without_reactive_context(() => {
+					/** @type {AbortController} */ (e.ac).abort(STALE_REACTION);
+					e.ac = null;
+				});
+			}
 
 			// make it a noop so it doesn't get called again if the derived
 			// is unfrozen. we don't set it to `null`, because the existence
 			// of a teardown function is what determines whether the
 			// effect runs again during unfreezing (but not for teardown-only effects)
 			if (e.fn !== null) e.teardown = noop;
-			e.ac = null;
 
 			remove_reactions(e, 0);
 			destroy_effect_children(e);
diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js
index c5d195dfae..e69a639a94 100644
--- a/packages/svelte/src/internal/client/reactivity/effects.js
+++ b/packages/svelte/src/internal/client/reactivity/effects.js
@@ -34,8 +34,10 @@ import {
 	ASYNC,
 	CONNECTED,
 	MANAGED_EFFECT,
-	DESTROYING
+	DESTROYING,
+	PAUSED
 } from '#client/constants';
+import { invoke_error_boundary } from '../error-handling.js';
 import * as e from '../errors.js';
 import { DEV } from 'esm-env';
 import { define_property } from '../../shared/utils.js';
@@ -449,6 +451,11 @@ export function execute_effect_teardown(effect) {
 		set_active_reaction(null);
 		try {
 			teardown.call(null);
+		} catch (error) {
+			// Route teardown errors through the boundary system so that a live
+			// ancestor <svelte:boundary> can handle them. Boundaries that are
+			// themselves mid-teardown are skipped by invoke_error_boundary.
+			invoke_error_boundary(error, effect.parent);
 		} finally {
 			set_is_destroying_effect(previously_destroying_effect);
 			set_active_reaction(previous_reaction);
@@ -610,6 +617,7 @@ export function pause_effect(effect, callback, destroy = true) {
 	/** @type {TransitionManager[]} */
 	var transitions = [];
 
+	effect.f |= PAUSED;
 	pause_children(effect, transitions, true);
 
 	var fn = () => {
@@ -677,6 +685,7 @@ function pause_children(effect, transitions, local) {
  * @param {Effect} effect
  */
 export function resume_effect(effect) {
+	effect.f &= ~PAUSED;
 	resume_children(effect, true);
 }
 
@@ -685,6 +694,10 @@ export function resume_effect(effect) {
  * @param {boolean} local
  */
 function resume_children(effect, local) {
+	// this subtree was paused for its own reasons (e.g. a block whose condition
+	// is still false) — its controller will resume or destroy it
+	if ((effect.f & PAUSED) !== 0) return;
+
 	if ((effect.f & INERT) === 0) return;
 	effect.f ^= INERT;
 
diff --git a/packages/svelte/src/internal/client/reactivity/props.js b/packages/svelte/src/internal/client/reactivity/props.js
index c2f3698809..274d780b1e 100644
--- a/packages/svelte/src/internal/client/reactivity/props.js
+++ b/packages/svelte/src/internal/client/reactivity/props.js
@@ -91,10 +91,7 @@ const rest_props_handler = {
  */
 /*#__NO_SIDE_EFFECTS__*/
 export function rest_props(props, exclude, name) {
-	return new Proxy(
-		DEV ? { props, exclude, name, other: {}, to_proxy: [] } : { props, exclude },
-		rest_props_handler
-	);
+	return new Proxy(DEV ? { props, exclude, name } : { props, exclude }, rest_props_handler);
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js
index 218941ab67..70be6489a4 100644
--- a/packages/svelte/src/internal/client/reactivity/sources.js
+++ b/packages/svelte/src/internal/client/reactivity/sources.js
@@ -180,7 +180,13 @@ export function set(source, value, should_proxy = false) {
  */
 export function internal_set(source, value, updated_during_traversal = null) {
 	if (!source.equals(value)) {
-		old_values.set(source, is_destroying_effect ? value : source.v);
+		if (is_destroying_effect) {
+			old_values.set(source, value);
+		} else if (!old_values.has(source)) {
+			// only record the value from before the first write in this flush, otherwise a
+			// teardown would see the value from before whichever write happened to be last
+			old_values.set(source, source.v);
+		}
 
 		var batch = Batch.ensure();
 		batch.capture(source, value);
diff --git a/packages/svelte/src/internal/client/render.js b/packages/svelte/src/internal/client/render.js
index 50832fb3ff..2abedb3a55 100644
--- a/packages/svelte/src/internal/client/render.js
+++ b/packages/svelte/src/internal/client/render.js
@@ -10,7 +10,7 @@ import {
 } from './dom/operations.js';
 import { HYDRATION_END, HYDRATION_ERROR, HYDRATION_START } from '../../constants.js';
 import { active_effect } from './runtime.js';
-import { push, pop, component_context } from './context.js';
+import { push, pop, component_context, mark_as_component } from './context.js';
 import { component_root } from './reactivity/effects.js';
 import { hydrate_node, hydrating, set_hydrate_node, set_hydrating } from './dom/hydration.js';
 import { array_from } from '../shared/utils.js';
@@ -23,7 +23,7 @@ import * as w from './warnings.js';
 import * as e from './errors.js';
 import { assign_nodes } from './dom/template.js';
 import { is_passive_event } from '../../utils.js';
-import { COMMENT_NODE, STATE_SYMBOL, TEXT_CACHE } from './constants.js';
+import { COMMENT_NODE, TEXT_CACHE } from './constants.js';
 import { boundary } from './dom/blocks/boundary.js';
 
 /**
@@ -193,7 +193,7 @@ function _mount(
 
 				should_intro = intro;
 				// @ts-expect-error the public typings are not what the actual function looks like
-				component = Component(anchor_node, props) || {};
+				component = Component(anchor_node, props) || mark_as_component();
 				should_intro = true;
 
 				if (hydrating) {
@@ -323,11 +323,7 @@ export function unmount(component, options) {
 	}
 
 	if (DEV) {
-		if (STATE_SYMBOL in component) {
-			w.state_proxy_unmount();
-		} else {
-			w.lifecycle_double_unmount();
-		}
+		w.lifecycle_double_unmount();
 	}
 
 	return Promise.resolve();
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index 227203523e..a881403f58 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -61,6 +61,9 @@ 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;
@@ -130,7 +133,7 @@ export function set_untracked_writes(value) {
  **/
 export let write_version = 1;
 
-/** @type {number} Used to version each read of a source of derived to avoid duplicating depedencies inside a reaction */
+/** @type {number} Used to version each read of a source of derived to avoid duplicating dependencies inside a reaction */
 let read_version = 0;
 
 export let update_version = read_version;
@@ -255,37 +258,7 @@ export function update_reaction(reaction) {
 		var fn = /** @type {Function} */ (reaction.fn);
 		var result = fn();
 		reaction.f |= REACTION_RAN;
-		var deps = reaction.deps;
-
-		// Don't remove reactions during fork;
-		// they must remain for when fork is discarded
-		var is_fork = current_batch?.is_fork;
-
-		if (new_deps !== null) {
-			var i;
-
-			if (!is_fork) {
-				remove_reactions(reaction, skipped_deps);
-			}
-
-			if (deps !== null && skipped_deps > 0) {
-				deps.length = skipped_deps + new_deps.length;
-				for (i = 0; i < new_deps.length; i++) {
-					deps[skipped_deps + i] = new_deps[i];
-				}
-			} else {
-				reaction.deps = deps = new_deps;
-			}
-
-			if (effect_tracking() && (reaction.f & CONNECTED) !== 0) {
-				for (i = skipped_deps; i < deps.length; i++) {
-					(deps[i].reactions ??= []).push(reaction);
-				}
-			}
-		} else if (!is_fork && deps !== null && skipped_deps < deps.length) {
-			remove_reactions(reaction, skipped_deps);
-			deps.length = skipped_deps;
-		}
+		var deps = update_dependencies(reaction);
 
 		// If we're inside an effect and we have untracked writes, then we need to
 		// ensure that if any of those untracked writes result in re-invalidation
@@ -297,7 +270,7 @@ export function update_reaction(reaction) {
 			deps !== null &&
 			(reaction.f & (DERIVED | MAYBE_DIRTY | DIRTY)) === 0
 		) {
-			for (i = 0; i < /** @type {Source[]} */ (untracked_writes).length; i++) {
+			for (var i = 0; i < /** @type {Source[]} */ (untracked_writes).length; i++) {
 				schedule_possible_effect_self_invalidation(
 					untracked_writes[i],
 					/** @type {Effect} */ (reaction)
@@ -341,6 +314,9 @@ export function update_reaction(reaction) {
 
 		return result;
 	} catch (error) {
+		// still commit the deps read before the throw, otherwise deriveds connected by this run keep no reader and the reaction never re-runs when they change
+		update_dependencies(reaction);
+
 		return handle_error(error);
 	} finally {
 		reaction.f ^= REACTION_IS_UPDATING;
@@ -355,6 +331,45 @@ export function update_reaction(reaction) {
 	}
 }
 
+/**
+ * @param {Reaction} reaction
+ */
+function update_dependencies(reaction) {
+	var deps = reaction.deps;
+
+	// Don't remove reactions during fork;
+	// they must remain for when fork is discarded
+	var is_fork = current_batch?.is_fork;
+
+	if (new_deps !== null) {
+		var i;
+
+		if (!is_fork) {
+			remove_reactions(reaction, skipped_deps);
+		}
+
+		if (deps !== null && skipped_deps > 0) {
+			deps.length = skipped_deps + new_deps.length;
+			for (i = 0; i < new_deps.length; i++) {
+				deps[skipped_deps + i] = new_deps[i];
+			}
+		} else {
+			reaction.deps = deps = new_deps;
+		}
+
+		if (effect_tracking() && (reaction.f & CONNECTED) !== 0) {
+			for (i = skipped_deps; i < deps.length; i++) {
+				(deps[i].reactions ??= []).push(reaction);
+			}
+		}
+	} else if (!is_fork && deps !== null && skipped_deps < deps.length) {
+		remove_reactions(reaction, skipped_deps);
+		deps.length = skipped_deps;
+	}
+
+	return deps;
+}
+
 /**
  * @template V
  * @param {Reaction} signal
@@ -405,6 +420,16 @@ function remove_reaction(signal, dependency) {
 			update_derived_status(derived);
 		}
 
+		// Call abort controller, noone's listening to this derived anymore
+		if (derived.ac !== null) {
+			without_reactive_context(() => {
+				/** @type {AbortController} */ (derived.ac).abort(STALE_REACTION);
+				derived.ac = null;
+				// ensure it reruns right away next time instead of potentially returning a rejected promise as its value
+				set_signal_status(derived, DIRTY);
+			});
+		}
+
 		// freeze any effects inside this derived
 		freeze_derived_effects(derived);
 
@@ -444,7 +469,7 @@ export function update_effect(effect) {
 	var was_updating_effect = is_updating_effect;
 
 	active_effect = effect;
-	is_updating_effect = true;
+	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;
diff --git a/packages/svelte/src/internal/client/warnings.js b/packages/svelte/src/internal/client/warnings.js
index f4e605ac96..ced1a8b2c3 100644
--- a/packages/svelte/src/internal/client/warnings.js
+++ b/packages/svelte/src/internal/client/warnings.js
@@ -247,17 +247,6 @@ export function state_proxy_equality_mismatch(operator) {
 	}
 }
 
-/**
- * Tried to unmount a state proxy, rather than a component
- */
-export function state_proxy_unmount() {
-	if (DEV) {
-		console.warn(`%c[svelte] state_proxy_unmount\n%cTried to unmount a state proxy, rather than a component\nhttps://svelte.dev/e/state_proxy_unmount`, bold, normal);
-	} else {
-		console.warn(`https://svelte.dev/e/state_proxy_unmount`);
-	}
-}
-
 /**
  * A `<svelte:boundary>` `reset` function only resets the boundary the first time it is called
  */
diff --git a/packages/svelte/src/internal/server/abort-signal.js b/packages/svelte/src/internal/server/abort-signal.js
index a769a46e3d..16047bdbb1 100644
--- a/packages/svelte/src/internal/server/abort-signal.js
+++ b/packages/svelte/src/internal/server/abort-signal.js
@@ -1,13 +1,12 @@
-import { STALE_REACTION } from '#client/constants';
+import { ssr_context } from './context.js';
 
-/** @type {AbortController | null} */
-let controller = null;
+export function getAbortSignal() {
+	let context = ssr_context;
 
-export function abort() {
-	controller?.abort(STALE_REACTION);
-	controller = null;
-}
+	while (context !== null) {
+		if (context.r !== null) return context.r.global.get_abort_signal();
+		context = context.p;
+	}
 
-export function getAbortSignal() {
-	return (controller ??= new AbortController()).signal;
+	return new AbortController().signal;
 }
diff --git a/packages/svelte/src/internal/server/context.js b/packages/svelte/src/internal/server/context.js
index 6a7dc1f883..de11c11282 100644
--- a/packages/svelte/src/internal/server/context.js
+++ b/packages/svelte/src/internal/server/context.js
@@ -1,6 +1,6 @@
 /** @import { SSRContext } from '#server' */
 import { DEV } from 'esm-env';
-import * as e from './errors.js';
+import { create_context, get_or_init_context_map } from '../shared/context.js';
 
 /** @type {SSRContext | null} */
 export var ssr_context = null;
@@ -16,18 +16,9 @@ export function set_ssr_context(v) {
  * @since 5.40.0
  */
 export function createContext() {
-	const key = {};
-
-	return [
-		() => {
-			if (!hasContext(key)) {
-				e.missing_context();
-			}
-
-			return getContext(key);
-		},
-		(context) => setContext(key, context)
-	];
+	return /** @type {[() => T, (context: T) => T]} */ (
+		create_context(getContext, setContext, hasContext)
+	);
 }
 
 /**
@@ -36,7 +27,7 @@ export function createContext() {
  * @returns {T}
  */
 export function getContext(key) {
-	const context_map = get_or_init_context_map('getContext');
+	const context_map = get_or_init_context_map(ssr_context, 'getContext');
 	const result = /** @type {T} */ (context_map.get(key));
 
 	return result;
@@ -49,7 +40,7 @@ export function getContext(key) {
  * @returns {T}
  */
 export function setContext(key, context) {
-	get_or_init_context_map('setContext').set(key, context);
+	get_or_init_context_map(ssr_context, 'setContext').set(key, context);
 	return context;
 }
 
@@ -58,24 +49,12 @@ export function setContext(key, context) {
  * @returns {boolean}
  */
 export function hasContext(key) {
-	return get_or_init_context_map('hasContext').has(key);
+	return get_or_init_context_map(ssr_context, 'hasContext').has(key);
 }
 
 /** @returns {Map<any, any>} */
 export function getAllContexts() {
-	return get_or_init_context_map('getAllContexts');
-}
-
-/**
- * @param {string} name
- * @returns {Map<unknown, unknown>}
- */
-function get_or_init_context_map(name) {
-	if (ssr_context === null) {
-		e.lifecycle_outside_component(name);
-	}
-
-	return (ssr_context.c ??= new Map(get_parent_context(ssr_context) || undefined));
+	return get_or_init_context_map(ssr_context, 'getAllContexts');
 }
 
 /**
@@ -94,24 +73,6 @@ export function pop() {
 	ssr_context = /** @type {SSRContext} */ (ssr_context).p;
 }
 
-/**
- * @param {SSRContext} ssr_context
- * @returns {Map<unknown, unknown> | null}
- */
-function get_parent_context(ssr_context) {
-	let parent = ssr_context.p;
-
-	while (parent !== null) {
-		const context_map = parent.c;
-		if (context_map !== null) {
-			return context_map;
-		}
-		parent = parent.p;
-	}
-
-	return null;
-}
-
 /**
  * Wraps an `await` expression in such a way that the component context that was
  * active before the expression evaluated can be reapplied afterwards —
diff --git a/packages/svelte/src/internal/server/index.js b/packages/svelte/src/internal/server/index.js
index e25ae184d8..37471a72a7 100644
--- a/packages/svelte/src/internal/server/index.js
+++ b/packages/svelte/src/internal/server/index.js
@@ -1,5 +1,5 @@
 /** @import { ComponentType, SvelteComponent, Component } from 'svelte' */
-/** @import { Csp, RenderOutput } from '#server' */
+/** @import { Csp, RenderOutput } from '../../server/public.js' */
 /** @import { Store } from '#shared' */
 export { FILENAME, HMR } from '../../constants.js';
 import { attr, clsx, to_class, to_style } from '../shared/attributes.js';
diff --git a/packages/svelte/src/internal/server/renderer.js b/packages/svelte/src/internal/server/renderer.js
index 921342be36..bd495c91f2 100644
--- a/packages/svelte/src/internal/server/renderer.js
+++ b/packages/svelte/src/internal/server/renderer.js
@@ -1,8 +1,9 @@
 /** @import { Component } from 'svelte' */
-/** @import { Csp, HydratableContext, RenderOutput, SSRContext, SyncRenderOutput, Sha256Source } from './types.js' */
+/** @import { HydratableContext, SSRContext } from './types.js' */
+/** @import { Csp, RenderOutput, SyncRenderOutput, Sha256Source } from '../../server/public.js' */
 /** @import { MaybePromise } from '#shared' */
 import { async_mode_flag } from '../flags/index.js';
-import { abort } from './abort-signal.js';
+import { STALE_REACTION } from '../client/constants.js';
 import { pop, push, set_ssr_context, ssr_context } from './context.js';
 import * as e from './errors.js';
 import * as w from './warnings.js';
@@ -12,7 +13,7 @@ import { attributes } from './index.js';
 import { get_render_context, with_render_context, init_render_context } from './render-context.js';
 import { sha256 } from './crypto.js';
 import * as devalue from 'devalue';
-import { has_own_property, noop } from '../shared/utils.js';
+import { has_own_property, is_array, noop } from '../shared/utils.js';
 import { escape_html } from '../../escaping.js';
 
 /** @typedef {'head' | 'body'} RendererType */
@@ -88,7 +89,7 @@ export class Renderer {
 	 * State that is local to the branch it is declared in.
 	 * It will be shallow-copied to all children.
 	 *
-	 * @type {{ select_value: string | undefined }}
+	 * @type {{ select_value: any, select_default_multiple: boolean }}
 	 */
 	local;
 
@@ -100,7 +101,9 @@ export class Renderer {
 		this.#parent = parent;
 
 		this.global = global;
-		this.local = parent ? { ...parent.local } : { select_value: undefined };
+		this.local = parent
+			? { ...parent.local }
+			: { select_value: undefined, select_default_multiple: false };
 		this.type = parent ? parent.type : 'body';
 	}
 
@@ -179,7 +182,7 @@ export class Renderer {
 		// prevent unhandled rejections, and attach the promise to the renderer instance
 		// so that rejections correctly cause rendering to fail
 		promise.catch(noop);
-		this.promise = promise;
+		this.promise = this.global.track(promise);
 
 		return promises;
 	}
@@ -224,7 +227,7 @@ export class Renderer {
 				e.await_invalid();
 			}
 
-			child.promise = result;
+			child.promise = child.global.track(result);
 		}
 
 		return child;
@@ -272,7 +275,7 @@ export class Renderer {
 					e.await_invalid();
 				}
 				result.catch(noop);
-				child.promise = result;
+				child.promise = child.global.track(result);
 			}
 		} catch (error) {
 			// synchronous errors are handled here, async errors will be handled in #collect_content_async
@@ -292,12 +295,14 @@ export class Renderer {
 					e.await_invalid();
 				}
 
-				child.promise = /** @type {Promise<unknown>} */ (result).then((transformed) => {
-					set_ssr_context(parent_context);
-					child.#out.push(Renderer.#serialize_failed_boundary(transformed));
-					failed_snippet(child, transformed, noop);
-					child.#out.push(BLOCK_CLOSE);
-				});
+				child.promise = child.global.track(
+					/** @type {Promise<unknown>} */ (result).then((transformed) => {
+						set_ssr_context(parent_context);
+						child.#out.push(Renderer.#serialize_failed_boundary(transformed));
+						failed_snippet(child, transformed, noop);
+						child.#out.push(BLOCK_CLOSE);
+					})
+				);
 				child.promise.catch(noop);
 			} else {
 				child.#out.push(Renderer.#serialize_failed_boundary(result));
@@ -316,8 +321,11 @@ export class Renderer {
 	 */
 	component(fn, component_fn) {
 		push(component_fn);
-		const child = this.child(fn);
-		child.#is_component_body = true;
+		// mark before running so `onDestroy` callbacks are still collected if `fn` throws
+		this.child((renderer) => {
+			renderer.#is_component_body = true;
+			return fn(renderer);
+		});
 		pop();
 	}
 
@@ -332,11 +340,14 @@ export class Renderer {
 	 * @returns {void}
 	 */
 	select(attrs, fn, css_hash, classes, styles, flags, is_rich) {
-		const { value, ...select_attrs } = attrs;
+		const { value, defaultValue, ...select_attrs } = attrs;
+		if (select_attrs.multiple === '') select_attrs.multiple = true;
 
 		this.push(`<select${attributes(select_attrs, css_hash, classes, styles, flags)}>`);
 		this.child((renderer) => {
-			renderer.local.select_value = value;
+			renderer.local.select_value = value === undefined ? defaultValue : value;
+			renderer.local.select_default_multiple =
+				value === undefined && Boolean(select_attrs.multiple);
 			fn(renderer);
 		});
 		this.push(`${is_rich ? '<!>' : ''}</select>`);
@@ -364,7 +375,11 @@ export class Renderer {
 				value = attrs.value;
 			}
 
-			if (value === this.local.select_value) {
+			if (
+				this.local.select_default_multiple
+					? is_array(this.local.select_value) && this.local.select_value.includes(value)
+					: value === this.local.select_value
+			) {
 				renderer.#out.push(' selected=""');
 			}
 
@@ -481,6 +496,7 @@ export class Renderer {
 	 */
 	copy() {
 		const copy = new Renderer(this.global, this.#parent);
+		copy.type = this.type;
 		copy.#out = this.#out.map((item) => (item instanceof Renderer ? item.copy() : item));
 		copy.promise = this.promise;
 		return copy;
@@ -654,6 +670,49 @@ export class Renderer {
 		}
 	}
 
+	/**
+	 * Runs every `onDestroy` callback in this renderer tree. On a failed render,
+	 * cleanup errors are suppressed so they do not mask the render error.
+	 * @param {boolean} suppress_errors
+	 */
+	#run_on_destroy(suppress_errors) {
+		let first_error;
+		let has_error = false;
+
+		for (const cleanup of this.#collect_on_destroy()) {
+			try {
+				cleanup();
+			} catch (error) {
+				if (!suppress_errors && !has_error) {
+					first_error = error;
+					has_error = true;
+				}
+			}
+		}
+
+		if (has_error) throw first_error;
+	}
+
+	/**
+	 * @param {'sync' | 'async'} mode
+	 * @param {{ idPrefix?: string; csp?: Csp; transformError?: (error: unknown) => unknown }} options
+	 * @returns {Renderer}
+	 */
+	static #create(mode, options) {
+		if (options.idPrefix?.includes('--')) {
+			e.invalid_id_prefix();
+		}
+
+		return new Renderer(
+			new SSRState(
+				mode,
+				options.idPrefix ? options.idPrefix + '-' : '',
+				options.csp,
+				options.transformError
+			)
+		);
+	}
+
 	/**
 	 * Render a component. Throws if any of the children are performing asynchronous work.
 	 *
@@ -664,26 +723,43 @@ export class Renderer {
 	 */
 	static #render(component, options) {
 		var previous_context = ssr_context;
+		const renderer = Renderer.#create('sync', options);
+		/** @type {AccumulatedContent | undefined} */
+		let result;
+		let render_error;
+		let failed = false;
+
 		try {
-			const renderer = Renderer.#open_render('sync', component, options);
-			const content = renderer.#collect_content();
-
-			for (const portal of renderer.global.portals.values()) {
-				if (portal.id === undefined) continue;
-
-				for (const item of portal.renderers) {
-					if (item instanceof Renderer) {
-						const portal_content = item.#collect_content();
-						item.#out.length = 0;
-						content.body = content.body.replaceAll(portal.id, portal.id + portal_content.body);
-						content.head = content.head.replaceAll(portal.id, portal.id + portal_content.body);
+			try {
+				Renderer.#open_render(renderer, component, options);
+
+				const content = renderer.#collect_content();
+
+				for (const portal of renderer.global.portals.values()) {
+					if (portal.id === undefined) continue;
+
+					for (const item of portal.renderers) {
+						if (item instanceof Renderer) {
+							const portal_content = item.#collect_content();
+							item.#out.length = 0;
+							content.body = content.body.replaceAll(portal.id, portal.id + portal_content.body);
+							content.head = content.head.replaceAll(portal.id, portal.id + portal_content.body);
+						}
 					}
 				}
+
+				result = Renderer.#close_render(content, renderer);
+			} catch (error) {
+				render_error = error;
+				failed = true;
 			}
 
-			return Renderer.#close_render(content, renderer);
+			renderer.#run_on_destroy(failed);
+			if (failed) throw render_error;
+
+			return /** @type {AccumulatedContent} */ (result);
 		} finally {
-			abort();
+			renderer.global.abort();
 			set_ssr_context(previous_context);
 		}
 	}
@@ -698,31 +774,48 @@ export class Renderer {
 	 */
 	static async #render_async(component, options) {
 		const previous_context = ssr_context;
+		const renderer = Renderer.#create('async', options);
+		/** @type {(AccumulatedContent & { hashes: { script: Sha256Source[] } }) | undefined} */
+		let result;
+		let render_error;
+		let failed = false;
 
 		try {
-			const renderer = Renderer.#open_render('async', component, options);
-			const content = await renderer.#collect_content_async();
-			const hydratables = await renderer.#collect_hydratables();
-			if (hydratables !== null) {
-				content.head = hydratables + content.head;
-			}
+			try {
+				Renderer.#open_render(renderer, component, options);
+				const content = await renderer.#collect_content_async();
+				const hydratables = await renderer.#collect_hydratables();
+				if (hydratables !== null) {
+					content.head = hydratables + content.head;
+				}
 
-			for (const portal of renderer.global.portals.values()) {
-				if (portal.id === undefined) continue;
+				for (const portal of renderer.global.portals.values()) {
+					if (portal.id === undefined) continue;
 
-				for (const item of portal.renderers) {
-					if (item instanceof Renderer) {
-						const portal_content = await item.#collect_content_async();
-						content.body = content.body.replaceAll(portal.id, portal.id + portal_content.body);
-						content.head = content.head.replaceAll(portal.id, portal.id + portal_content.body);
+					for (const item of portal.renderers) {
+						if (item instanceof Renderer) {
+							const portal_content = await item.#collect_content_async();
+							content.body = content.body.replaceAll(portal.id, portal.id + portal_content.body);
+							content.head = content.head.replaceAll(portal.id, portal.id + portal_content.body);
+						}
 					}
 				}
+
+				result = Renderer.#close_render(content, renderer);
+			} catch (error) {
+				render_error = error;
+				failed = true;
+				renderer.global.abort();
+				await renderer.global.settle();
 			}
 
-			return Renderer.#close_render(content, renderer);
+			renderer.#run_on_destroy(failed);
+			if (failed) throw render_error;
+
+			return /** @type {AccumulatedContent & { hashes: { script: Sha256Source[] } }} */ (result);
 		} finally {
 			set_ssr_context(previous_context);
-			abort();
+			renderer.global.abort();
 		}
 	}
 
@@ -814,28 +907,15 @@ export class Renderer {
 
 	/**
 	 * @template {Record<string, any>} Props
-	 * @param {'sync' | 'async'} mode
+	 * @param {Renderer} renderer
 	 * @param {import('svelte').Component<Props>} component
 	 * @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp; transformError?: (error: unknown) => unknown }} options
-	 * @returns {Renderer}
+	 * @returns {void}
 	 */
-	static #open_render(mode, component, options) {
-		if (options.idPrefix?.includes('--')) {
-			e.invalid_id_prefix();
-		}
-
+	static #open_render(renderer, component, options) {
 		var previous_context = ssr_context;
 
 		try {
-			const renderer = new Renderer(
-				new SSRState(
-					mode,
-					options.idPrefix ? options.idPrefix + '-' : '',
-					options.csp,
-					options.transformError
-				)
-			);
-
 			/** @type {SSRContext} */
 			const context = { p: null, c: options.context ?? null, r: renderer };
 			set_ssr_context(context);
@@ -844,8 +924,6 @@ export class Renderer {
 			// @ts-expect-error
 			component(renderer, options.props ?? {});
 			renderer.push(BLOCK_CLOSE);
-
-			return renderer;
 		} finally {
 			set_ssr_context(previous_context);
 		}
@@ -857,10 +935,6 @@ export class Renderer {
 	 * @returns {AccumulatedContent & { hashes: { script: Sha256Source[] } }}
 	 */
 	static #close_render(content, renderer) {
-		for (const cleanup of renderer.#collect_on_destroy()) {
-			cleanup();
-		}
-
 		let head = content.head + renderer.global.get_title();
 		let body = content.body;
 
@@ -944,6 +1018,14 @@ export class SSRState {
 	/** @readonly @type {Set<{ hash: string; code: string }>} */
 	css = new Set();
 
+	/** @type {Set<Promise<unknown>>} */
+	#pending = new Set();
+
+	/** @type {AbortController | null} */
+	#controller = null;
+
+	#aborted = false;
+
 	/**
 	 * `transformError` passed to `render`. Called when an error boundary catches an error.
 	 * Throws by default if unset in `render`.
@@ -980,6 +1062,38 @@ export class SSRState {
 		this.uid = () => `${id_prefix}s${uid++}`;
 	}
 
+	/**
+	 * @template T
+	 * @param {Promise<T>} promise
+	 * @returns {Promise<T>}
+	 */
+	track(promise) {
+		this.#pending.add(promise);
+		promise.then(
+			() => this.#pending.delete(promise),
+			() => this.#pending.delete(promise)
+		);
+		return promise;
+	}
+
+	async settle() {
+		while (this.#pending.size > 0) {
+			await Promise.allSettled([...this.#pending]);
+		}
+	}
+
+	abort() {
+		if (this.#aborted) return;
+		this.#aborted = true;
+		this.#controller?.abort(STALE_REACTION);
+	}
+
+	get_abort_signal() {
+		const controller = (this.#controller ??= new AbortController());
+		if (this.#aborted) controller.abort(STALE_REACTION);
+		return controller.signal;
+	}
+
 	get_title() {
 		return this.#title.value;
 	}
diff --git a/packages/svelte/src/internal/server/renderer.test.ts b/packages/svelte/src/internal/server/renderer.test.ts
index 8e98c41796..1adfdda64c 100644
--- a/packages/svelte/src/internal/server/renderer.test.ts
+++ b/packages/svelte/src/internal/server/renderer.test.ts
@@ -2,6 +2,7 @@ import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 import { Renderer, SSRState } from './renderer.js';
 import type { Component } from 'svelte';
 import { disable_async_mode_flag, enable_async_mode_flag } from '../flags/index.js';
+import { getAbortSignal } from './abort-signal.js';
 
 test('collects synchronous body content by default', () => {
 	const component = (renderer: Renderer) => {
@@ -466,4 +467,176 @@ describe('async', () => {
 		await Renderer.render(component as unknown as Component);
 		expect(destroyed).toEqual(['c', 'e', 'a', 'b', 'b*', 'd']);
 	});
+
+	test('on_destroy callbacks run when a sync render throws', () => {
+		const destroyed: string[] = [];
+		const component = (renderer: Renderer) => {
+			renderer.component((renderer) => {
+				renderer.on_destroy(() => destroyed.push('a'));
+				renderer.child(() => {
+					throw new Error('boom');
+				});
+			});
+		};
+
+		expect(() => Renderer.render(component as unknown as Component).body).toThrow('boom');
+		expect(destroyed).toEqual(['a']);
+	});
+
+	test('on_destroy callbacks run when an async render rejects', async () => {
+		const destroyed: string[] = [];
+		const component = (renderer: Renderer) => {
+			renderer.component((renderer) => {
+				renderer.on_destroy(() => destroyed.push('a'));
+				renderer.child(async () => {
+					await Promise.resolve();
+					throw new Error('boom');
+				});
+			});
+		};
+
+		await expect(Renderer.render(component as unknown as Component)).rejects.toThrow('boom');
+		expect(destroyed).toEqual(['a']);
+	});
+
+	test('on_destroy waits for in-flight renderers when an async render rejects', async () => {
+		const events: string[] = [];
+		let initialised = false;
+
+		const component = (renderer: Renderer) => {
+			renderer.component((renderer) => {
+				// rejects while the sibling component below is still in flight
+				renderer.child(async () => {
+					await Promise.resolve();
+					throw new Error('boom');
+				});
+
+				renderer.component((renderer) => {
+					renderer.on_destroy(() => events.push(`before-await (initialised: ${initialised})`));
+					renderer.child(async () => {
+						await new Promise((f) => setTimeout(f, 10));
+						initialised = true;
+						renderer.on_destroy(() => events.push('after-await'));
+					});
+				});
+			});
+		};
+
+		await expect(Renderer.render(component as unknown as Component)).rejects.toThrow('boom');
+		expect(events).toEqual(['before-await (initialised: true)', 'after-await']);
+	});
+
+	test('aborts in-flight renderers before waiting for them', async () => {
+		const events: string[] = [];
+		const component = (renderer: Renderer) => {
+			renderer.component((renderer) => {
+				renderer.child(async () => {
+					await Promise.resolve();
+					throw new Error('boom');
+				});
+
+				renderer.component((renderer) => {
+					renderer.on_destroy(() => events.push('destroyed'));
+					renderer.child(async () => {
+						const signal = getAbortSignal();
+						await new Promise((_, reject) => {
+							signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+						});
+					});
+				});
+			});
+		};
+
+		await expect(Renderer.render(component as unknown as Component)).rejects.toThrow('boom');
+		expect(events).toEqual(['destroyed']);
+	});
+
+	test('on_destroy waits for every run invocation when an async render rejects', async () => {
+		const events: string[] = [];
+		let initialised = false;
+		const component = (renderer: Renderer) => {
+			renderer.component((renderer) => {
+				renderer.on_destroy(() => events.push(`destroyed (initialised: ${initialised})`));
+				renderer.run([
+					async () => {
+						await new Promise((resolve) => setTimeout(resolve, 10));
+						initialised = true;
+						renderer.on_destroy(() => events.push('destroyed after await'));
+					}
+				]);
+				renderer.run([
+					async () => {
+						await Promise.resolve();
+						throw new Error('boom');
+					}
+				]);
+			});
+		};
+
+		await expect(Renderer.render(component as unknown as Component)).rejects.toThrow('boom');
+		expect(events).toEqual(['destroyed (initialised: true)', 'destroyed after await']);
+	});
+
+	test('abort signals are scoped to a render', async () => {
+		let signal: AbortSignal;
+		let start!: () => void;
+		let resume!: () => void;
+		const started = new Promise<void>((resolve) => (start = resolve));
+		const resumed = new Promise<void>((resolve) => (resume = resolve));
+		const component = (renderer: Renderer) => {
+			renderer.child(async () => {
+				signal = getAbortSignal();
+				start();
+				await resumed;
+			});
+		};
+
+		const first_render = Promise.resolve(Renderer.render(component as unknown as Component));
+		await started;
+		await Renderer.render((() => {}) as unknown as Component);
+		expect(signal!.aborted).toBe(false);
+
+		resume();
+		await first_render;
+		expect(signal!.aborted).toBe(true);
+	});
+
+	test('a throwing on_destroy callback does not mask a sync render error', () => {
+		const destroyed: string[] = [];
+		const component = (renderer: Renderer) => {
+			renderer.component((renderer) => {
+				renderer.on_destroy(() => {
+					destroyed.push('a');
+					throw new Error('cleanup failed');
+				});
+				renderer.on_destroy(() => destroyed.push('b'));
+				renderer.child(() => {
+					throw new Error('boom');
+				});
+			});
+		};
+
+		expect(() => Renderer.render(component as unknown as Component).body).toThrow('boom');
+		expect(destroyed).toEqual(['a', 'b']);
+	});
+
+	test('a throwing on_destroy callback does not mask an async render error', async () => {
+		const destroyed: string[] = [];
+		const component = (renderer: Renderer) => {
+			renderer.component((renderer) => {
+				renderer.on_destroy(() => {
+					destroyed.push('a');
+					throw new Error('cleanup failed');
+				});
+				renderer.on_destroy(() => destroyed.push('b'));
+				renderer.child(async () => {
+					await Promise.resolve();
+					throw new Error('boom');
+				});
+			});
+		};
+
+		await expect(Renderer.render(component as unknown as Component)).rejects.toThrow('boom');
+		expect(destroyed).toEqual(['a', 'b']);
+	});
 });
diff --git a/packages/svelte/src/internal/server/types.d.ts b/packages/svelte/src/internal/server/types.d.ts
index c16e2d827b..5420cd48c3 100644
--- a/packages/svelte/src/internal/server/types.d.ts
+++ b/packages/svelte/src/internal/server/types.d.ts
@@ -1,4 +1,3 @@
-import type { MaybePromise } from '#shared';
 import type { Element } from './dev';
 import type { Renderer } from './renderer';
 
@@ -25,8 +24,6 @@ export interface Payload {
 	};
 }
 
-export type Csp = { nonce?: string; hash?: boolean };
-
 export interface HydratableLookupEntry {
 	value: unknown;
 	serialized: string;
@@ -44,19 +41,3 @@ export interface HydratableContext {
 export interface RenderContext {
 	hydratable: HydratableContext;
 }
-
-export type Sha256Source = `sha256-${string}`;
-
-export interface SyncRenderOutput {
-	/** HTML that goes into the `<head>` */
-	head: string;
-	/** @deprecated use `body` instead */
-	html: string;
-	/** HTML that goes somewhere into the `<body>` */
-	body: string;
-	hashes: {
-		script: Sha256Source[];
-	};
-}
-
-export type RenderOutput = SyncRenderOutput & PromiseLike<SyncRenderOutput>;
diff --git a/packages/svelte/src/internal/shared/attributes.js b/packages/svelte/src/internal/shared/attributes.js
index 487a40baf3..bb1abf22c1 100644
--- a/packages/svelte/src/internal/shared/attributes.js
+++ b/packages/svelte/src/internal/shared/attributes.js
@@ -142,8 +142,9 @@ export function to_style(value, styles) {
 		}
 
 		if (value) {
+			// strip comments; surrounding whitespace is handled by the trims below (which is much faster than doing it through regex)
 			value = String(value)
-				.replaceAll(/\s*\/\*.*?\*\/\s*/g, '')
+				.replaceAll(/\/\*.*?\*\//g, '')
 				.trim();
 
 			/** @type {boolean | '"' | "'"} */
diff --git a/packages/svelte/src/internal/shared/clone.js b/packages/svelte/src/internal/shared/clone.js
index 1a83adf8c5..ba0c731047 100644
--- a/packages/svelte/src/internal/shared/clone.js
+++ b/packages/svelte/src/internal/shared/clone.js
@@ -105,6 +105,8 @@ function clone(value, cloned, path, paths, original = null, no_tojson = false) {
 		}
 
 		if (value instanceof Date) {
+			// Ensure SvelteDate snapshots are tracked
+			value.getTime();
 			return /** @type {Snapshot<T>} */ (structuredClone(value));
 		}
 
diff --git a/packages/svelte/src/internal/shared/context.js b/packages/svelte/src/internal/shared/context.js
new file mode 100644
index 0000000000..943e15e415
--- /dev/null
+++ b/packages/svelte/src/internal/shared/context.js
@@ -0,0 +1,52 @@
+import { lifecycle_outside_component, missing_context } from './errors.js';
+
+/**
+ * @template T
+ * @param {(key: object) => T} get_context
+ * @param {(key: object, context: T) => T} set_context
+ * @param {(key: object) => boolean} has_context
+ * @returns {[() => T, (context: T) => T]}
+ */
+export function create_context(get_context, set_context, has_context) {
+	const key = {};
+
+	return [
+		() => {
+			if (!has_context(key)) {
+				missing_context();
+			}
+
+			return get_context(key);
+		},
+		(context) => set_context(key, context)
+	];
+}
+
+/**
+ * @typedef {{ p: Context | null, c: Map<unknown, unknown> | null }} Context
+ */
+
+/**
+ * @param {Context} context
+ * @returns {Map<unknown, unknown> | null}
+ */
+function get_parent_context(context) {
+	let parent = context.p;
+	while (parent !== null && parent.c === null) {
+		parent = parent.p;
+	}
+	return parent?.c ?? null;
+}
+
+/**
+ * @param {Context | null} context
+ * @param {string} name
+ * @returns {Map<unknown, unknown>}
+ */
+export function get_or_init_context_map(context, name) {
+	if (context === null) {
+		lifecycle_outside_component(name);
+	}
+
+	return (context.c ??= new Map(get_parent_context(context) || undefined));
+}
diff --git a/packages/svelte/src/internal/shared/errors.js b/packages/svelte/src/internal/shared/errors.js
index a4ad8cecff..9e41788dc1 100644
--- a/packages/svelte/src/internal/shared/errors.js
+++ b/packages/svelte/src/internal/shared/errors.js
@@ -86,12 +86,12 @@ export function lifecycle_outside_component(name) {
 }
 
 /**
- * Context was not set in a parent component
+ * Context was not set in the current component or any of its ancestors
  * @returns {never}
  */
 export function missing_context() {
 	if (DEV) {
-		const error = new Error(`missing_context\nContext was not set in a parent component\nhttps://svelte.dev/e/missing_context`);
+		const error = new Error(`missing_context\nContext was not set in the current component or any of its ancestors\nhttps://svelte.dev/e/missing_context`);
 
 		error.name = 'Svelte error';
 
diff --git a/packages/svelte/src/legacy/legacy-server.js b/packages/svelte/src/legacy/legacy-server.js
index 2c43aab6ac..913f2dccb2 100644
--- a/packages/svelte/src/legacy/legacy-server.js
+++ b/packages/svelte/src/legacy/legacy-server.js
@@ -1,5 +1,5 @@
 /** @import { SvelteComponent } from '../index.js' */
-/** @import { Csp } from '#server' */
+/** @import { Csp } from '../server/public.js' */
 import { asClassComponent as as_class_component, createClassComponent } from './legacy-client.js';
 import { render } from '../internal/server/index.js';
 import { async_mode_flag } from '../internal/flags/index.js';
diff --git a/packages/svelte/src/motion/tweened.js b/packages/svelte/src/motion/tweened.js
index a24148d075..460db0df64 100644
--- a/packages/svelte/src/motion/tweened.js
+++ b/packages/svelte/src/motion/tweened.js
@@ -275,6 +275,7 @@ export class Tween {
 				}
 
 				previous_task?.abort();
+				previous_task = null;
 			}
 
 			const elapsed = now - start;
diff --git a/packages/svelte/src/reactivity/url.js b/packages/svelte/src/reactivity/url.js
index 549a20baa7..1e24e774ee 100644
--- a/packages/svelte/src/reactivity/url.js
+++ b/packages/svelte/src/reactivity/url.js
@@ -163,6 +163,8 @@ export class SvelteURL extends URL {
 	set protocol(value) {
 		super.protocol = value;
 		set(this.#protocol, super.protocol);
+		// changing the protocol can clear the port when it matches the new scheme's default
+		set(this.#port, super.port);
 	}
 
 	get search() {
diff --git a/packages/svelte/src/reactivity/url.test.ts b/packages/svelte/src/reactivity/url.test.ts
index d698116421..72518d730a 100644
--- a/packages/svelte/src/reactivity/url.test.ts
+++ b/packages/svelte/src/reactivity/url.test.ts
@@ -240,3 +240,25 @@ test('url.searchParams.forEach re-runs when the search string changes via the UR
 
 	cleanup();
 });
+
+test('url.port is updated when the protocol change clears the port', () => {
+	const url = new SvelteURL('http://example.com:443/');
+	const log: any = [];
+
+	const cleanup = effect_root(() => {
+		render_effect(() => {
+			log.push(url.port);
+		});
+	});
+
+	flushSync(() => {
+		// 443 is the default port for https, so it gets stripped
+		url.protocol = 'https:';
+	});
+
+	assert.equal(url.port, '');
+	assert.equal(url.href, 'https://example.com/');
+	assert.deepEqual(log, ['443', '']);
+
+	cleanup();
+});
diff --git a/packages/svelte/src/server/index.d.ts b/packages/svelte/src/server/index.d.ts
index db75afb9ed..7297c57490 100644
--- a/packages/svelte/src/server/index.d.ts
+++ b/packages/svelte/src/server/index.d.ts
@@ -1,6 +1,8 @@
-import type { Csp, RenderOutput } from '#server';
+import type { Csp, RenderOutput } from './public.js';
 import type { ComponentProps, Component, SvelteComponent, ComponentType } from 'svelte';
 
+export type { Csp, RenderOutput, SyncRenderOutput, Sha256Source } from './public.js';
+
 /**
  * Only available on the server and when compiling with the `server` option.
  * Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
diff --git a/packages/svelte/src/server/public.d.ts b/packages/svelte/src/server/public.d.ts
new file mode 100644
index 0000000000..8ef98aef9c
--- /dev/null
+++ b/packages/svelte/src/server/public.d.ts
@@ -0,0 +1,17 @@
+export type Csp = { nonce?: string; hash?: boolean };
+
+export type Sha256Source = `sha256-${string}`;
+
+export interface SyncRenderOutput {
+	/** HTML that goes into the `<head>` */
+	head: string;
+	/** @deprecated use `body` instead */
+	html: string;
+	/** HTML that goes somewhere into the `<body>` */
+	body: string;
+	hashes: {
+		script: Sha256Source[];
+	};
+}
+
+export type RenderOutput = SyncRenderOutput & PromiseLike<SyncRenderOutput>;
diff --git a/packages/svelte/src/transition/index.js b/packages/svelte/src/transition/index.js
index 898a929eb1..31e8fbde2b 100644
--- a/packages/svelte/src/transition/index.js
+++ b/packages/svelte/src/transition/index.js
@@ -28,6 +28,17 @@ function split_css_unit(value) {
 	return split ? [parseFloat(split[1]), split[2] || 'px'] : [/** @type {number} */ (value), 'px'];
 }
 
+/**
+ * Omits unresolved dimensions rather than passing invalid values to Web Animations.
+ *
+ * @param {string} property
+ * @param {number} value
+ * @param {number} t
+ */
+function css_dimension(property, value, t) {
+	return Number.isNaN(value) ? '' : `${property}: ${t * value}px;`;
+}
+
 /**
  * Animates a `blur` filter alongside an element's opacity.
  *
@@ -138,13 +149,13 @@ export function slide(node, { delay = 0, duration = 400, easing = cubic_out, axi
 		css: (t) =>
 			'overflow: hidden;' +
 			`opacity: ${Math.min(t * 20, 1) * opacity};` +
-			`${primary_property}: ${t * primary_property_value}px;` +
-			`padding-${secondary_properties[0]}: ${t * padding_start_value}px;` +
-			`padding-${secondary_properties[1]}: ${t * padding_end_value}px;` +
-			`margin-${secondary_properties[0]}: ${t * margin_start_value}px;` +
-			`margin-${secondary_properties[1]}: ${t * margin_end_value}px;` +
-			`border-${secondary_properties[0]}-width: ${t * border_width_start_value}px;` +
-			`border-${secondary_properties[1]}-width: ${t * border_width_end_value}px;` +
+			css_dimension(primary_property, primary_property_value, t) +
+			css_dimension(`padding-${secondary_properties[0]}`, padding_start_value, t) +
+			css_dimension(`padding-${secondary_properties[1]}`, padding_end_value, t) +
+			css_dimension(`margin-${secondary_properties[0]}`, margin_start_value, t) +
+			css_dimension(`margin-${secondary_properties[1]}`, margin_end_value, t) +
+			css_dimension(`border-${secondary_properties[0]}-width`, border_width_start_value, t) +
+			css_dimension(`border-${secondary_properties[1]}-width`, border_width_end_value, t) +
 			`min-${primary_property}: 0`
 	};
 }
diff --git a/packages/svelte/src/version.js b/packages/svelte/src/version.js
index ef468a2f79..b9f1637abb 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.56.4';
+export const VERSION = '5.56.10';
 export const PUBLIC_VERSION = '5';
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-export-let-derived/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-export-let-derived/_config.js
new file mode 100644
index 0000000000..852f56ebcc
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/runes-export-let-derived/_config.js
@@ -0,0 +1,9 @@
+import { test } from '../../test';
+
+export default test({
+	error: {
+		code: 'derived_invalid_export',
+		message:
+			'Cannot export derived state from a module. To expose the current derived value, export a function returning its value'
+	}
+});
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-export-let-derived/main.svelte b/packages/svelte/tests/compiler-errors/samples/runes-export-let-derived/main.svelte
new file mode 100644
index 0000000000..512caf75f8
--- /dev/null
+++ b/packages/svelte/tests/compiler-errors/samples/runes-export-let-derived/main.svelte
@@ -0,0 +1,4 @@
+<script>
+	let count = $state(0);
+	export let double = $derived(count * 2);
+</script>
diff --git a/packages/svelte/tests/css-parse.test.ts b/packages/svelte/tests/css-parse.test.ts
index 3a53e97955..18903f0619 100644
--- a/packages/svelte/tests/css-parse.test.ts
+++ b/packages/svelte/tests/css-parse.test.ts
@@ -69,9 +69,21 @@ describe('parseCss', () => {
 	});
 
 	it('parses comments', () => {
-		const ast = parseCss('/* comment */ div { color: red; }');
+		const ast = parseCss(
+			'/* top */ div, /* selector */ span { /* block */ color: /* value */ red; }'
+		);
 		assert.equal(ast.children.length, 1);
 		assert.equal(ast.children[0].type, 'Rule');
+		assert.deepEqual(
+			ast.comments.map((comment) => comment.value),
+			[' top ', ' selector ', ' block ', ' value ']
+		);
+		assert.deepEqual(ast.comments[0], {
+			type: 'CSSComment',
+			value: ' top ',
+			start: 0,
+			end: 9
+		});
 	});
 
 	it('parses complex selectors', () => {
diff --git a/packages/svelte/tests/css/samples/namespaced-type-selector/expected.css b/packages/svelte/tests/css/samples/namespaced-type-selector/expected.css
new file mode 100644
index 0000000000..7672a34dcf
--- /dev/null
+++ b/packages/svelte/tests/css/samples/namespaced-type-selector/expected.css
@@ -0,0 +1,17 @@
+	@namespace svg url(http://www.w3.org/2000/svg);
+
+	svg|circle.svelte-xyz {
+		fill: red;
+	}
+
+	*|circle.svelte-xyz {
+		stroke: blue;
+	}
+
+	svg|*.svelte-xyz {
+		color: green;
+	}
+
+	*|*.svelte-xyz {
+		opacity: 0.5;
+	}
diff --git a/packages/svelte/tests/css/samples/namespaced-type-selector/input.svelte b/packages/svelte/tests/css/samples/namespaced-type-selector/input.svelte
new file mode 100644
index 0000000000..17586eab6f
--- /dev/null
+++ b/packages/svelte/tests/css/samples/namespaced-type-selector/input.svelte
@@ -0,0 +1,21 @@
+<svg><circle /></svg>
+
+<style>
+	@namespace svg url(http://www.w3.org/2000/svg);
+
+	svg|circle {
+		fill: red;
+	}
+
+	*|circle {
+		stroke: blue;
+	}
+
+	svg|* {
+		color: green;
+	}
+
+	*|* {
+		opacity: 0.5;
+	}
+</style>
diff --git a/packages/svelte/tests/css/samples/snippet-exported/_config.js b/packages/svelte/tests/css/samples/snippet-exported/_config.js
new file mode 100644
index 0000000000..30953854ad
--- /dev/null
+++ b/packages/svelte/tests/css/samples/snippet-exported/_config.js
@@ -0,0 +1,5 @@
+import { test } from '../../test';
+
+export default test({
+	hasGlobal: true
+});
diff --git a/packages/svelte/tests/css/samples/snippet-exported/expected.css b/packages/svelte/tests/css/samples/snippet-exported/expected.css
new file mode 100644
index 0000000000..65d0c35e7c
--- /dev/null
+++ b/packages/svelte/tests/css/samples/snippet-exported/expected.css
@@ -0,0 +1,4 @@
+
+	.inner.svelte-xyz {
+		color: red;
+	}
diff --git a/packages/svelte/tests/css/samples/snippet-exported/input.svelte b/packages/svelte/tests/css/samples/snippet-exported/input.svelte
new file mode 100644
index 0000000000..3aef144e26
--- /dev/null
+++ b/packages/svelte/tests/css/samples/snippet-exported/input.svelte
@@ -0,0 +1,13 @@
+<script module>
+	export { outer };
+</script>
+
+{#snippet outer()}
+	<p class="inner"></p>
+{/snippet}
+
+<style>
+	.inner {
+		color: red;
+	}
+</style>
diff --git a/packages/svelte/tests/hydration/samples/head-css-no-class/_expected_head.html b/packages/svelte/tests/hydration/samples/head-css-no-class/_expected_head.html
new file mode 100644
index 0000000000..497ca987cc
--- /dev/null
+++ b/packages/svelte/tests/hydration/samples/head-css-no-class/_expected_head.html
@@ -0,0 +1 @@
+<meta name="author" content="Re:Designed"> <link rel="author" href="https://example.com"> <script type="application/ld+json"></script>
\ No newline at end of file
diff --git a/packages/svelte/tests/hydration/samples/head-css-no-class/main.svelte b/packages/svelte/tests/hydration/samples/head-css-no-class/main.svelte
new file mode 100644
index 0000000000..29336a17ba
--- /dev/null
+++ b/packages/svelte/tests/hydration/samples/head-css-no-class/main.svelte
@@ -0,0 +1,11 @@
+<svelte:head>
+	<meta name="author" content="Re:Designed" />
+	<link rel="author" href="https://example.com" />
+	<script type="application/ld+json"></script>
+</svelte:head>
+
+<div>dummy</div>
+
+<style>
+	* { color: red }
+</style>
diff --git a/packages/svelte/tests/migrate/samples/props-export-alias/input.svelte b/packages/svelte/tests/migrate/samples/props-export-alias/input.svelte
index 1cb57ef5fd..fc06166e21 100644
--- a/packages/svelte/tests/migrate/samples/props-export-alias/input.svelte
+++ b/packages/svelte/tests/migrate/samples/props-export-alias/input.svelte
@@ -1,3 +1,4 @@
+<!-- @component x -->
 <script lang="ts">
 	let klass = '';
 	export { klass as class }
diff --git a/packages/svelte/tests/migrate/samples/props-export-alias/output.svelte b/packages/svelte/tests/migrate/samples/props-export-alias/output.svelte
index c697083b28..433a9d04ed 100644
--- a/packages/svelte/tests/migrate/samples/props-export-alias/output.svelte
+++ b/packages/svelte/tests/migrate/samples/props-export-alias/output.svelte
@@ -1,3 +1,4 @@
+<!-- @component x -->
 <script lang="ts">
 	interface Props {
 		class?: string;
diff --git a/packages/svelte/tests/parser-legacy/samples/convert-entities-line-feed/input.svelte b/packages/svelte/tests/parser-legacy/samples/convert-entities-line-feed/input.svelte
new file mode 100644
index 0000000000..3ce2c605d6
--- /dev/null
+++ b/packages/svelte/tests/parser-legacy/samples/convert-entities-line-feed/input.svelte
@@ -0,0 +1 @@
+<p title="A&#x0A;B">A&#x0A;B</p>
diff --git a/packages/svelte/tests/parser-legacy/samples/convert-entities-line-feed/output.json b/packages/svelte/tests/parser-legacy/samples/convert-entities-line-feed/output.json
new file mode 100644
index 0000000000..5d1127ccdc
--- /dev/null
+++ b/packages/svelte/tests/parser-legacy/samples/convert-entities-line-feed/output.json
@@ -0,0 +1,53 @@
+{
+	"html": {
+		"type": "Fragment",
+		"start": 0,
+		"end": 32,
+		"children": [
+			{
+				"type": "Element",
+				"start": 0,
+				"end": 32,
+				"name": "p",
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 3,
+						"end": 19,
+						"name": "title",
+						"name_loc": {
+							"start": {
+								"line": 1,
+								"column": 3,
+								"character": 3
+							},
+							"end": {
+								"line": 1,
+								"column": 8,
+								"character": 8
+							}
+						},
+						"value": [
+							{
+								"start": 10,
+								"end": 18,
+								"type": "Text",
+								"raw": "A&#x0A;B",
+								"data": "A\nB"
+							}
+						]
+					}
+				],
+				"children": [
+					{
+						"type": "Text",
+						"start": 20,
+						"end": 28,
+						"raw": "A&#x0A;B",
+						"data": "A B"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/packages/svelte/tests/parser-legacy/samples/css/output.json b/packages/svelte/tests/parser-legacy/samples/css/output.json
index b3ecd7b671..82be06eeac 100644
--- a/packages/svelte/tests/parser-legacy/samples/css/output.json
+++ b/packages/svelte/tests/parser-legacy/samples/css/output.json
@@ -33,6 +33,7 @@
 		"type": "Style",
 		"start": 16,
 		"end": 56,
+		"comments": [],
 		"attributes": [],
 		"children": [
 			{
diff --git a/packages/svelte/tests/parser-legacy/samples/whitespace-after-style-tag/output.json b/packages/svelte/tests/parser-legacy/samples/whitespace-after-style-tag/output.json
index 2cadbc672f..3d17122d1f 100644
--- a/packages/svelte/tests/parser-legacy/samples/whitespace-after-style-tag/output.json
+++ b/packages/svelte/tests/parser-legacy/samples/whitespace-after-style-tag/output.json
@@ -33,6 +33,7 @@
 		"type": "Style",
 		"start": 16,
 		"end": 66,
+		"comments": [],
 		"attributes": [],
 		"children": [
 			{
diff --git a/packages/svelte/tests/parser-modern/samples/css-nth-of-minified/input.svelte b/packages/svelte/tests/parser-modern/samples/css-nth-of-minified/input.svelte
new file mode 100644
index 0000000000..3aeda2abc7
--- /dev/null
+++ b/packages/svelte/tests/parser-modern/samples/css-nth-of-minified/input.svelte
@@ -0,0 +1,28 @@
+<style>
+	/* minifiers drop the whitespace after `of`, since the following token ends the identifier */
+	li:nth-child(2n of.important) {
+		background: red;
+	}
+	li:nth-child(even of#first) {
+		background: red;
+	}
+	li:nth-last-child(-n+3 of[data-active]) {
+		background: red;
+	}
+	li:nth-child(2n of*) {
+		background: red;
+	}
+	li:nth-child(2n of:not(.excluded)) {
+		background: red;
+	}
+	li:nth-child(2n of.a, .b) {
+		background: red;
+	}
+	ul {
+		& li:nth-child(2n of&.important) {
+			background: red;
+		}
+	}
+</style>
+
+<li>Foo</li>
diff --git a/packages/svelte/tests/parser-modern/samples/css-nth-of-minified/output.json b/packages/svelte/tests/parser-modern/samples/css-nth-of-minified/output.json
new file mode 100644
index 0000000000..04de9a5e0a
--- /dev/null
+++ b/packages/svelte/tests/parser-modern/samples/css-nth-of-minified/output.json
@@ -0,0 +1,799 @@
+{
+	"css": {
+		"type": "StyleSheet",
+		"start": 0,
+		"end": 511,
+		"attributes": [],
+		"children": [
+			{
+				"type": "Rule",
+				"prelude": {
+					"type": "SelectorList",
+					"start": 104,
+					"end": 133,
+					"children": [
+						{
+							"type": "ComplexSelector",
+							"start": 104,
+							"end": 133,
+							"children": [
+								{
+									"type": "RelativeSelector",
+									"combinator": null,
+									"selectors": [
+										{
+											"type": "TypeSelector",
+											"name": "li",
+											"start": 104,
+											"end": 106
+										},
+										{
+											"type": "PseudoClassSelector",
+											"name": "nth-child",
+											"args": {
+												"type": "SelectorList",
+												"start": 117,
+												"end": 132,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 117,
+														"end": 132,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "Nth",
+																		"value": "2n of",
+																		"start": 117,
+																		"end": 122
+																	},
+																	{
+																		"type": "ClassSelector",
+																		"name": "important",
+																		"start": 122,
+																		"end": 132
+																	}
+																],
+																"start": 117,
+																"end": 132
+															}
+														]
+													}
+												]
+											},
+											"start": 106,
+											"end": 133
+										}
+									],
+									"start": 104,
+									"end": 133
+								}
+							]
+						}
+					]
+				},
+				"block": {
+					"type": "Block",
+					"start": 134,
+					"end": 157,
+					"children": [
+						{
+							"type": "Declaration",
+							"start": 138,
+							"end": 153,
+							"property": "background",
+							"value": "red"
+						}
+					]
+				},
+				"start": 104,
+				"end": 157
+			},
+			{
+				"type": "Rule",
+				"prelude": {
+					"type": "SelectorList",
+					"start": 159,
+					"end": 186,
+					"children": [
+						{
+							"type": "ComplexSelector",
+							"start": 159,
+							"end": 186,
+							"children": [
+								{
+									"type": "RelativeSelector",
+									"combinator": null,
+									"selectors": [
+										{
+											"type": "TypeSelector",
+											"name": "li",
+											"start": 159,
+											"end": 161
+										},
+										{
+											"type": "PseudoClassSelector",
+											"name": "nth-child",
+											"args": {
+												"type": "SelectorList",
+												"start": 172,
+												"end": 185,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 172,
+														"end": 185,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "Nth",
+																		"value": "even of",
+																		"start": 172,
+																		"end": 179
+																	},
+																	{
+																		"type": "IdSelector",
+																		"name": "first",
+																		"start": 179,
+																		"end": 185
+																	}
+																],
+																"start": 172,
+																"end": 185
+															}
+														]
+													}
+												]
+											},
+											"start": 161,
+											"end": 186
+										}
+									],
+									"start": 159,
+									"end": 186
+								}
+							]
+						}
+					]
+				},
+				"block": {
+					"type": "Block",
+					"start": 187,
+					"end": 210,
+					"children": [
+						{
+							"type": "Declaration",
+							"start": 191,
+							"end": 206,
+							"property": "background",
+							"value": "red"
+						}
+					]
+				},
+				"start": 159,
+				"end": 210
+			},
+			{
+				"type": "Rule",
+				"prelude": {
+					"type": "SelectorList",
+					"start": 212,
+					"end": 251,
+					"children": [
+						{
+							"type": "ComplexSelector",
+							"start": 212,
+							"end": 251,
+							"children": [
+								{
+									"type": "RelativeSelector",
+									"combinator": null,
+									"selectors": [
+										{
+											"type": "TypeSelector",
+											"name": "li",
+											"start": 212,
+											"end": 214
+										},
+										{
+											"type": "PseudoClassSelector",
+											"name": "nth-last-child",
+											"args": {
+												"type": "SelectorList",
+												"start": 230,
+												"end": 250,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 230,
+														"end": 250,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "Nth",
+																		"value": "-n+3 of",
+																		"start": 230,
+																		"end": 237
+																	},
+																	{
+																		"type": "AttributeSelector",
+																		"start": 237,
+																		"end": 250,
+																		"name": "data-active",
+																		"matcher": null,
+																		"value": null,
+																		"flags": null
+																	}
+																],
+																"start": 230,
+																"end": 250
+															}
+														]
+													}
+												]
+											},
+											"start": 214,
+											"end": 251
+										}
+									],
+									"start": 212,
+									"end": 251
+								}
+							]
+						}
+					]
+				},
+				"block": {
+					"type": "Block",
+					"start": 252,
+					"end": 275,
+					"children": [
+						{
+							"type": "Declaration",
+							"start": 256,
+							"end": 271,
+							"property": "background",
+							"value": "red"
+						}
+					]
+				},
+				"start": 212,
+				"end": 275
+			},
+			{
+				"type": "Rule",
+				"prelude": {
+					"type": "SelectorList",
+					"start": 277,
+					"end": 297,
+					"children": [
+						{
+							"type": "ComplexSelector",
+							"start": 277,
+							"end": 297,
+							"children": [
+								{
+									"type": "RelativeSelector",
+									"combinator": null,
+									"selectors": [
+										{
+											"type": "TypeSelector",
+											"name": "li",
+											"start": 277,
+											"end": 279
+										},
+										{
+											"type": "PseudoClassSelector",
+											"name": "nth-child",
+											"args": {
+												"type": "SelectorList",
+												"start": 290,
+												"end": 296,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 290,
+														"end": 296,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "Nth",
+																		"value": "2n of",
+																		"start": 290,
+																		"end": 295
+																	},
+																	{
+																		"type": "TypeSelector",
+																		"name": "*",
+																		"start": 295,
+																		"end": 296
+																	}
+																],
+																"start": 290,
+																"end": 296
+															}
+														]
+													}
+												]
+											},
+											"start": 279,
+											"end": 297
+										}
+									],
+									"start": 277,
+									"end": 297
+								}
+							]
+						}
+					]
+				},
+				"block": {
+					"type": "Block",
+					"start": 298,
+					"end": 321,
+					"children": [
+						{
+							"type": "Declaration",
+							"start": 302,
+							"end": 317,
+							"property": "background",
+							"value": "red"
+						}
+					]
+				},
+				"start": 277,
+				"end": 321
+			},
+			{
+				"type": "Rule",
+				"prelude": {
+					"type": "SelectorList",
+					"start": 323,
+					"end": 357,
+					"children": [
+						{
+							"type": "ComplexSelector",
+							"start": 323,
+							"end": 357,
+							"children": [
+								{
+									"type": "RelativeSelector",
+									"combinator": null,
+									"selectors": [
+										{
+											"type": "TypeSelector",
+											"name": "li",
+											"start": 323,
+											"end": 325
+										},
+										{
+											"type": "PseudoClassSelector",
+											"name": "nth-child",
+											"args": {
+												"type": "SelectorList",
+												"start": 336,
+												"end": 356,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 336,
+														"end": 356,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "Nth",
+																		"value": "2n of",
+																		"start": 336,
+																		"end": 341
+																	},
+																	{
+																		"type": "PseudoClassSelector",
+																		"name": "not",
+																		"args": {
+																			"type": "SelectorList",
+																			"start": 346,
+																			"end": 355,
+																			"children": [
+																				{
+																					"type": "ComplexSelector",
+																					"start": 346,
+																					"end": 355,
+																					"children": [
+																						{
+																							"type": "RelativeSelector",
+																							"combinator": null,
+																							"selectors": [
+																								{
+																									"type": "ClassSelector",
+																									"name": "excluded",
+																									"start": 346,
+																									"end": 355
+																								}
+																							],
+																							"start": 346,
+																							"end": 355
+																						}
+																					]
+																				}
+																			]
+																		},
+																		"start": 341,
+																		"end": 356
+																	}
+																],
+																"start": 336,
+																"end": 356
+															}
+														]
+													}
+												]
+											},
+											"start": 325,
+											"end": 357
+										}
+									],
+									"start": 323,
+									"end": 357
+								}
+							]
+						}
+					]
+				},
+				"block": {
+					"type": "Block",
+					"start": 358,
+					"end": 381,
+					"children": [
+						{
+							"type": "Declaration",
+							"start": 362,
+							"end": 377,
+							"property": "background",
+							"value": "red"
+						}
+					]
+				},
+				"start": 323,
+				"end": 381
+			},
+			{
+				"type": "Rule",
+				"prelude": {
+					"type": "SelectorList",
+					"start": 383,
+					"end": 408,
+					"children": [
+						{
+							"type": "ComplexSelector",
+							"start": 383,
+							"end": 408,
+							"children": [
+								{
+									"type": "RelativeSelector",
+									"combinator": null,
+									"selectors": [
+										{
+											"type": "TypeSelector",
+											"name": "li",
+											"start": 383,
+											"end": 385
+										},
+										{
+											"type": "PseudoClassSelector",
+											"name": "nth-child",
+											"args": {
+												"type": "SelectorList",
+												"start": 396,
+												"end": 407,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 396,
+														"end": 403,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "Nth",
+																		"value": "2n of",
+																		"start": 396,
+																		"end": 401
+																	},
+																	{
+																		"type": "ClassSelector",
+																		"name": "a",
+																		"start": 401,
+																		"end": 403
+																	}
+																],
+																"start": 396,
+																"end": 403
+															}
+														]
+													},
+													{
+														"type": "ComplexSelector",
+														"start": 405,
+														"end": 407,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "ClassSelector",
+																		"name": "b",
+																		"start": 405,
+																		"end": 407
+																	}
+																],
+																"start": 405,
+																"end": 407
+															}
+														]
+													}
+												]
+											},
+											"start": 385,
+											"end": 408
+										}
+									],
+									"start": 383,
+									"end": 408
+								}
+							]
+						}
+					]
+				},
+				"block": {
+					"type": "Block",
+					"start": 409,
+					"end": 432,
+					"children": [
+						{
+							"type": "Declaration",
+							"start": 413,
+							"end": 428,
+							"property": "background",
+							"value": "red"
+						}
+					]
+				},
+				"start": 383,
+				"end": 432
+			},
+			{
+				"type": "Rule",
+				"prelude": {
+					"type": "SelectorList",
+					"start": 434,
+					"end": 436,
+					"children": [
+						{
+							"type": "ComplexSelector",
+							"start": 434,
+							"end": 436,
+							"children": [
+								{
+									"type": "RelativeSelector",
+									"combinator": null,
+									"selectors": [
+										{
+											"type": "TypeSelector",
+											"name": "ul",
+											"start": 434,
+											"end": 436
+										}
+									],
+									"start": 434,
+									"end": 436
+								}
+							]
+						}
+					]
+				},
+				"block": {
+					"type": "Block",
+					"start": 437,
+					"end": 502,
+					"children": [
+						{
+							"type": "Rule",
+							"prelude": {
+								"type": "SelectorList",
+								"start": 441,
+								"end": 473,
+								"children": [
+									{
+										"type": "ComplexSelector",
+										"start": 441,
+										"end": 473,
+										"children": [
+											{
+												"type": "RelativeSelector",
+												"combinator": null,
+												"selectors": [
+													{
+														"type": "NestingSelector",
+														"name": "&",
+														"start": 441,
+														"end": 442
+													}
+												],
+												"start": 441,
+												"end": 442
+											},
+											{
+												"type": "RelativeSelector",
+												"combinator": {
+													"type": "Combinator",
+													"name": " ",
+													"start": 442,
+													"end": 443
+												},
+												"selectors": [
+													{
+														"type": "TypeSelector",
+														"name": "li",
+														"start": 443,
+														"end": 445
+													},
+													{
+														"type": "PseudoClassSelector",
+														"name": "nth-child",
+														"args": {
+															"type": "SelectorList",
+															"start": 456,
+															"end": 472,
+															"children": [
+																{
+																	"type": "ComplexSelector",
+																	"start": 456,
+																	"end": 472,
+																	"children": [
+																		{
+																			"type": "RelativeSelector",
+																			"combinator": null,
+																			"selectors": [
+																				{
+																					"type": "Nth",
+																					"value": "2n of",
+																					"start": 456,
+																					"end": 461
+																				},
+																				{
+																					"type": "NestingSelector",
+																					"name": "&",
+																					"start": 461,
+																					"end": 462
+																				},
+																				{
+																					"type": "ClassSelector",
+																					"name": "important",
+																					"start": 462,
+																					"end": 472
+																				}
+																			],
+																			"start": 456,
+																			"end": 472
+																		}
+																	]
+																}
+															]
+														},
+														"start": 445,
+														"end": 473
+													}
+												],
+												"start": 442,
+												"end": 473
+											}
+										]
+									}
+								]
+							},
+							"block": {
+								"type": "Block",
+								"start": 474,
+								"end": 499,
+								"children": [
+									{
+										"type": "Declaration",
+										"start": 479,
+										"end": 494,
+										"property": "background",
+										"value": "red"
+									}
+								]
+							},
+							"start": 441,
+							"end": 499
+						}
+					]
+				},
+				"start": 434,
+				"end": 502
+			}
+		],
+		"comments": [
+			{
+				"type": "CSSComment",
+				"value": " minifiers drop the whitespace after `of`, since the following token ends the identifier ",
+				"start": 9,
+				"end": 102
+			}
+		],
+		"content": {
+			"start": 7,
+			"end": 503,
+			"styles": "\n\t/* minifiers drop the whitespace after `of`, since the following token ends the identifier */\n\tli:nth-child(2n of.important) {\n\t\tbackground: red;\n\t}\n\tli:nth-child(even of#first) {\n\t\tbackground: red;\n\t}\n\tli:nth-last-child(-n+3 of[data-active]) {\n\t\tbackground: red;\n\t}\n\tli:nth-child(2n of*) {\n\t\tbackground: red;\n\t}\n\tli:nth-child(2n of:not(.excluded)) {\n\t\tbackground: red;\n\t}\n\tli:nth-child(2n of.a, .b) {\n\t\tbackground: red;\n\t}\n\tul {\n\t\t& li:nth-child(2n of&.important) {\n\t\t\tbackground: red;\n\t\t}\n\t}\n",
+			"comment": null
+		}
+	},
+	"js": [],
+	"start": 0,
+	"end": 525,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": [
+			{
+				"type": "Text",
+				"start": 511,
+				"end": 513,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 513,
+				"end": 525,
+				"name": "li",
+				"name_loc": {
+					"start": {
+						"line": 28,
+						"column": 1,
+						"character": 514
+					},
+					"end": {
+						"line": 28,
+						"column": 3,
+						"character": 516
+					}
+				},
+				"attributes": [],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": [
+						{
+							"type": "Text",
+							"start": 517,
+							"end": 520,
+							"raw": "Foo",
+							"data": "Foo"
+						}
+					]
+				}
+			}
+		]
+	},
+	"options": null,
+	"comments": []
+}
diff --git a/packages/svelte/tests/parser-modern/samples/css-nth-syntax/output.json b/packages/svelte/tests/parser-modern/samples/css-nth-syntax/output.json
index 3ce5f33d09..e0adab2b9f 100644
--- a/packages/svelte/tests/parser-modern/samples/css-nth-syntax/output.json
+++ b/packages/svelte/tests/parser-modern/samples/css-nth-syntax/output.json
@@ -1071,6 +1071,14 @@
 				"end": 797
 			}
 		],
+		"comments": [
+			{
+				"type": "CSSComment",
+				"value": " test that all these are parsed correctly ",
+				"start": 12,
+				"end": 58
+			}
+		],
 		"content": {
 			"start": 7,
 			"end": 798,
@@ -1125,5 +1133,6 @@
 			}
 		]
 	},
-	"options": null
+	"options": null,
+	"comments": []
 }
diff --git a/packages/svelte/tests/parser-modern/samples/css-pseudo-classes/output.json b/packages/svelte/tests/parser-modern/samples/css-pseudo-classes/output.json
index d052affe46..714bb9ee19 100644
--- a/packages/svelte/tests/parser-modern/samples/css-pseudo-classes/output.json
+++ b/packages/svelte/tests/parser-modern/samples/css-pseudo-classes/output.json
@@ -25,7 +25,35 @@
 											"type": "PseudoElementSelector",
 											"name": "view-transition-old",
 											"start": 60,
-											"end": 81
+											"end": 86,
+											"args": {
+												"type": "SelectorList",
+												"start": 82,
+												"end": 85,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 82,
+														"end": 85,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "TypeSelector",
+																		"name": "x-y",
+																		"start": 82,
+																		"end": 85
+																	}
+																],
+																"start": 82,
+																"end": 85
+															}
+														]
+													}
+												]
+											}
 										}
 									],
 									"start": 60,
@@ -89,7 +117,35 @@
 																		"type": "PseudoElementSelector",
 																		"name": "view-transition-old",
 																		"start": 119,
-																		"end": 140
+																		"end": 145,
+																		"args": {
+																			"type": "SelectorList",
+																			"start": 141,
+																			"end": 144,
+																			"children": [
+																				{
+																					"type": "ComplexSelector",
+																					"start": 141,
+																					"end": 144,
+																					"children": [
+																						{
+																							"type": "RelativeSelector",
+																							"combinator": null,
+																							"selectors": [
+																								{
+																									"type": "TypeSelector",
+																									"name": "x-y",
+																									"start": 141,
+																									"end": 144
+																								}
+																							],
+																							"start": 141,
+																							"end": 144
+																						}
+																					]
+																				}
+																			]
+																		}
 																	}
 																],
 																"start": 119,
@@ -147,7 +203,35 @@
 											"type": "PseudoElementSelector",
 											"name": "highlight",
 											"start": 171,
-											"end": 182
+											"end": 199,
+											"args": {
+												"type": "SelectorList",
+												"start": 183,
+												"end": 198,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 183,
+														"end": 198,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "TypeSelector",
+																		"name": "rainbow-color-1",
+																		"start": 183,
+																		"end": 198
+																	}
+																],
+																"start": 183,
+																"end": 198
+															}
+														]
+													}
+												]
+											}
 										}
 									],
 									"start": 171,
@@ -200,7 +284,35 @@
 											"type": "PseudoElementSelector",
 											"name": "part",
 											"start": 234,
-											"end": 240
+											"end": 245,
+											"args": {
+												"type": "SelectorList",
+												"start": 241,
+												"end": 244,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 241,
+														"end": 244,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "TypeSelector",
+																		"name": "foo",
+																		"start": 241,
+																		"end": 244
+																	}
+																],
+																"start": 241,
+																"end": 244
+															}
+														]
+													}
+												]
+											}
 										}
 									],
 									"start": 220,
@@ -247,7 +359,35 @@
 											"type": "PseudoElementSelector",
 											"name": "slotted",
 											"start": 266,
-											"end": 275
+											"end": 285,
+											"args": {
+												"type": "SelectorList",
+												"start": 276,
+												"end": 284,
+												"children": [
+													{
+														"type": "ComplexSelector",
+														"start": 276,
+														"end": 284,
+														"children": [
+															{
+																"type": "RelativeSelector",
+																"combinator": null,
+																"selectors": [
+																	{
+																		"type": "ClassSelector",
+																		"name": "content",
+																		"start": 276,
+																		"end": 284
+																	}
+																],
+																"start": 276,
+																"end": 284
+															}
+														]
+													}
+												]
+											}
 										}
 									],
 									"start": 266,
@@ -390,6 +530,26 @@
 				"end": 377
 			}
 		],
+		"comments": [
+			{
+				"type": "CSSComment",
+				"value": " test that all these are parsed correctly ",
+				"start": 12,
+				"end": 58
+			},
+			{
+				"type": "CSSComment",
+				"value": "button",
+				"start": 311,
+				"end": 321
+			},
+			{
+				"type": "CSSComment",
+				"value": "p after h1",
+				"start": 332,
+				"end": 346
+			}
+		],
 		"content": {
 			"start": 7,
 			"end": 378,
@@ -405,5 +565,6 @@
 		"type": "Fragment",
 		"nodes": []
 	},
-	"options": null
+	"options": null,
+	"comments": []
 }
diff --git a/packages/svelte/tests/parser-modern/samples/script-style-no-markup/output.json b/packages/svelte/tests/parser-modern/samples/script-style-no-markup/output.json
index db58a62148..68c38da524 100644
--- a/packages/svelte/tests/parser-modern/samples/script-style-no-markup/output.json
+++ b/packages/svelte/tests/parser-modern/samples/script-style-no-markup/output.json
@@ -53,6 +53,7 @@
 				"end": 82
 			}
 		],
+		"comments": [],
 		"content": {
 			"start": 61,
 			"end": 83,
@@ -77,6 +78,24 @@
 		]
 	},
 	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " script and style but no markup",
+			"start": 10,
+			"end": 43,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 1
+				},
+				"end": {
+					"line": 2,
+					"column": 34
+				}
+			}
+		}
+	],
 	"instance": {
 		"type": "Script",
 		"start": 0,
diff --git a/packages/svelte/tests/parser-modern/samples/semicolon-inside-quotes/output.json b/packages/svelte/tests/parser-modern/samples/semicolon-inside-quotes/output.json
index 312bd7701e..66a63580b1 100644
--- a/packages/svelte/tests/parser-modern/samples/semicolon-inside-quotes/output.json
+++ b/packages/svelte/tests/parser-modern/samples/semicolon-inside-quotes/output.json
@@ -68,6 +68,7 @@
 				"end": 196
 			}
 		],
+		"comments": [],
 		"content": {
 			"start": 43,
 			"end": 197,
@@ -122,5 +123,6 @@
 			}
 		]
 	},
-	"options": null
+	"options": null,
+	"comments": []
 }
diff --git a/packages/svelte/tests/print/samples/await-block/input.svelte b/packages/svelte/tests/print/samples/await-block/input.svelte
index 10f0b3fb9e..ba0ba8c882 100644
--- a/packages/svelte/tests/print/samples/await-block/input.svelte
+++ b/packages/svelte/tests/print/samples/await-block/input.svelte
@@ -8,3 +8,29 @@
 	<!-- promise was rejected -->
 	<p>Something went wrong: {error.message}</p>
 {/await}
+
+{#await promise catch error}
+	<p>The error is {error}</p>
+{/await}
+
+{#await promise then value}
+	<p>The value is {value}</p>
+{/await}
+
+{#await promise catch}
+	<p>Something went wrong</p>
+{/await}
+
+{#await promise}
+	<p>waiting for the promise to resolve...</p>
+{:then}
+	<p>the promise resolved</p>
+{:catch error}
+	<p>The error is {error}</p>
+{/await}
+
+{#await promise}
+	<p>waiting for the promise to resolve...</p>
+{:catch}
+	<p>Something went wrong</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 10f0b3fb9e..ba0ba8c882 100644
--- a/packages/svelte/tests/print/samples/await-block/output.svelte
+++ b/packages/svelte/tests/print/samples/await-block/output.svelte
@@ -8,3 +8,29 @@
 	<!-- promise was rejected -->
 	<p>Something went wrong: {error.message}</p>
 {/await}
+
+{#await promise catch error}
+	<p>The error is {error}</p>
+{/await}
+
+{#await promise then value}
+	<p>The value is {value}</p>
+{/await}
+
+{#await promise catch}
+	<p>Something went wrong</p>
+{/await}
+
+{#await promise}
+	<p>waiting for the promise to resolve...</p>
+{:then}
+	<p>the promise resolved</p>
+{:catch error}
+	<p>The error is {error}</p>
+{/await}
+
+{#await promise}
+	<p>waiting for the promise to resolve...</p>
+{:catch}
+	<p>Something went wrong</p>
+{/await}
diff --git a/packages/svelte/tests/print/samples/comment-inside-attribute/input.svelte b/packages/svelte/tests/print/samples/comment-inside-attribute/input.svelte
new file mode 100644
index 0000000000..4575abf75a
--- /dev/null
+++ b/packages/svelte/tests/print/samples/comment-inside-attribute/input.svelte
@@ -0,0 +1,7 @@
+<Button
+	onclick={() => {
+		// belongs to onclick
+		run();
+	}}
+	onkeydown={() => run()}
+/>
diff --git a/packages/svelte/tests/print/samples/comment-inside-attribute/output.svelte b/packages/svelte/tests/print/samples/comment-inside-attribute/output.svelte
new file mode 100644
index 0000000000..4575abf75a
--- /dev/null
+++ b/packages/svelte/tests/print/samples/comment-inside-attribute/output.svelte
@@ -0,0 +1,7 @@
+<Button
+	onclick={() => {
+		// belongs to onclick
+		run();
+	}}
+	onkeydown={() => run()}
+/>
diff --git a/packages/svelte/tests/print/samples/comment/output.svelte b/packages/svelte/tests/print/samples/comment/output.svelte
index f2f97b65be..2cac5f4048 100644
--- a/packages/svelte/tests/print/samples/comment/output.svelte
+++ b/packages/svelte/tests/print/samples/comment/output.svelte
@@ -1,3 +1,3 @@
-<!-- inline --><!-- 
+<!-- inline --> <!-- 
     multiline
 -->
diff --git a/packages/svelte/tests/print/samples/css-escape-sequences/input.svelte b/packages/svelte/tests/print/samples/css-escape-sequences/input.svelte
new file mode 100644
index 0000000000..db8e3e16a5
--- /dev/null
+++ b/packages/svelte/tests/print/samples/css-escape-sequences/input.svelte
@@ -0,0 +1,25 @@
+<div></div>
+
+<style>
+	#\31\32\33 { color: green; }
+	#\31 23 { color: green; }
+	#line\a break { color: green; }
+	#line\a
+break { color: green; }
+	li\.foo { color: green; }
+	.a\1f642 b { color: green; }
+	.a🙂b { color: green; }
+	#\2d 1foo { color: red; }
+	.a\5c b { color: red; }
+	.a\\b { color: red; }
+	.a\5c q { color: red; }
+	.a\\q { color: red; }
+	.a\5c  { color: red; }
+	.a\\ { color: red; }
+	#\5c a { color: red; }
+	[\31 data] { color: red; }
+	:\31 st-child { color: red; }
+	* { color: red; }
+	#id-selector { color: red; }
+	[data-attribute="value"] { color: red; }
+</style>
diff --git a/packages/svelte/tests/print/samples/css-escape-sequences/output.svelte b/packages/svelte/tests/print/samples/css-escape-sequences/output.svelte
new file mode 100644
index 0000000000..532d0a2562
--- /dev/null
+++ b/packages/svelte/tests/print/samples/css-escape-sequences/output.svelte
@@ -0,0 +1,83 @@
+<div></div>
+
+<style>
+	#\31 23 {
+		color: green;
+	}
+
+	#\31 23 {
+		color: green;
+	}
+
+	#line\a break {
+		color: green;
+	}
+
+	#line\a break {
+		color: green;
+	}
+
+	li\.foo {
+		color: green;
+	}
+
+	.a🙂b {
+		color: green;
+	}
+
+	.a🙂b {
+		color: green;
+	}
+
+	#\2d 1foo {
+		color: red;
+	}
+
+	.a\\b {
+		color: red;
+	}
+
+	.a\\b {
+		color: red;
+	}
+
+	.a\\q {
+		color: red;
+	}
+
+	.a\\q {
+		color: red;
+	}
+
+	.a\\ {
+		color: red;
+	}
+
+	.a\\ {
+		color: red;
+	}
+
+	#\\a {
+		color: red;
+	}
+
+	[\31 data] {
+		color: red;
+	}
+
+	:\31 st-child {
+		color: red;
+	}
+
+	* {
+		color: red;
+	}
+
+	#id-selector {
+		color: red;
+	}
+
+	[data-attribute="value"] {
+		color: red;
+	}
+</style>
diff --git a/packages/svelte/tests/print/samples/css-namespaced-type-selector/input.svelte b/packages/svelte/tests/print/samples/css-namespaced-type-selector/input.svelte
new file mode 100644
index 0000000000..5e170ceb2a
--- /dev/null
+++ b/packages/svelte/tests/print/samples/css-namespaced-type-selector/input.svelte
@@ -0,0 +1,10 @@
+<style>
+	@namespace svg url(http://www.w3.org/2000/svg);
+
+	svg|circle,
+	*|circle,
+	svg|*,
+	*|* {
+		fill: red;
+	}
+</style>
diff --git a/packages/svelte/tests/print/samples/css-namespaced-type-selector/output.svelte b/packages/svelte/tests/print/samples/css-namespaced-type-selector/output.svelte
new file mode 100644
index 0000000000..3723659b14
--- /dev/null
+++ b/packages/svelte/tests/print/samples/css-namespaced-type-selector/output.svelte
@@ -0,0 +1,12 @@
+
+
+<style>
+	@namespace svg url(http://www.w3.org/2000/svg);
+
+	svg|circle,
+	*|circle,
+	svg|*,
+	*|* {
+		fill: red;
+	}
+</style>
diff --git a/packages/svelte/tests/print/samples/element-content-wrapping/input.svelte b/packages/svelte/tests/print/samples/element-content-wrapping/input.svelte
new file mode 100644
index 0000000000..0667ace4fd
--- /dev/null
+++ b/packages/svelte/tests/print/samples/element-content-wrapping/input.svelte
@@ -0,0 +1,5 @@
+<button asdasd asdioqwjdoiqwjd qowdjqwoidjqowijdoiqj>
+    hello very long liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiine
+</button>
+
+<span>hello very long liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiine</span>
diff --git a/packages/svelte/tests/print/samples/element-content-wrapping/output.svelte b/packages/svelte/tests/print/samples/element-content-wrapping/output.svelte
new file mode 100644
index 0000000000..15622e960e
--- /dev/null
+++ b/packages/svelte/tests/print/samples/element-content-wrapping/output.svelte
@@ -0,0 +1,5 @@
+<button asdasd asdioqwjdoiqwjd qowdjqwoidjqowijdoiqj>
+	hello very long liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiine
+</button>
+
+<span>hello very long liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiine</span>
diff --git a/packages/svelte/tests/print/samples/expression-tag/output.svelte b/packages/svelte/tests/print/samples/expression-tag/output.svelte
index 9142a59631..5af5746d87 100644
--- a/packages/svelte/tests/print/samples/expression-tag/output.svelte
+++ b/packages/svelte/tests/print/samples/expression-tag/output.svelte
@@ -1 +1 @@
-<span>{name}</span><span>{count + 1}</span>
+<span>{name}</span> <span>{count + 1}</span>
diff --git a/packages/svelte/tests/print/samples/inline-element-whitespace/input.svelte b/packages/svelte/tests/print/samples/inline-element-whitespace/input.svelte
new file mode 100644
index 0000000000..e442ae954c
--- /dev/null
+++ b/packages/svelte/tests/print/samples/inline-element-whitespace/input.svelte
@@ -0,0 +1 @@
+<p>Hello <strong>bold</strong> world</p>
diff --git a/packages/svelte/tests/print/samples/inline-element-whitespace/output.svelte b/packages/svelte/tests/print/samples/inline-element-whitespace/output.svelte
new file mode 100644
index 0000000000..e442ae954c
--- /dev/null
+++ b/packages/svelte/tests/print/samples/inline-element-whitespace/output.svelte
@@ -0,0 +1 @@
+<p>Hello <strong>bold</strong> world</p>
diff --git a/packages/svelte/tests/print/samples/preserve-whitespace-elements/input.svelte b/packages/svelte/tests/print/samples/preserve-whitespace-elements/input.svelte
new file mode 100644
index 0000000000..0736fd6bf5
--- /dev/null
+++ b/packages/svelte/tests/print/samples/preserve-whitespace-elements/input.svelte
@@ -0,0 +1,19 @@
+<pre>
+
+    hel
+
+    lo
+      .
+</pre>
+
+<pre>  before
+<span>  nested
+ text  </span>
+{#if visible}  conditional
+ value{/if}</pre>
+
+<textarea>  first
+    second  </textarea>
+
+<svelte:head><title>  hello
+  world  </title></svelte:head>
diff --git a/packages/svelte/tests/print/samples/preserve-whitespace-elements/output.svelte b/packages/svelte/tests/print/samples/preserve-whitespace-elements/output.svelte
new file mode 100644
index 0000000000..345a099dfc
--- /dev/null
+++ b/packages/svelte/tests/print/samples/preserve-whitespace-elements/output.svelte
@@ -0,0 +1,21 @@
+<pre>
+
+    hel
+
+    lo
+      .
+</pre>
+
+<pre>  before
+<span>  nested
+ text  </span>
+{#if visible}  conditional
+ value{/if}</pre>
+
+<textarea>  first
+    second  </textarea>
+
+<svelte:head>
+	<title>  hello
+  world  </title>
+</svelte:head>
diff --git a/packages/svelte/tests/print/samples/regular-element/output.svelte b/packages/svelte/tests/print/samples/regular-element/output.svelte
index 0cf7c2472f..f5fd3c8f42 100644
--- a/packages/svelte/tests/print/samples/regular-element/output.svelte
+++ b/packages/svelte/tests/print/samples/regular-element/output.svelte
@@ -1 +1 @@
-<div><a href="/foo">bar</a></div><br />
+<div><a href="/foo">bar</a></div> <br />
diff --git a/packages/svelte/tests/print/samples/style-comments/input.svelte b/packages/svelte/tests/print/samples/style-comments/input.svelte
new file mode 100644
index 0000000000..71b2505891
--- /dev/null
+++ b/packages/svelte/tests/print/samples/style-comments/input.svelte
@@ -0,0 +1,26 @@
+<style>
+	/* first */
+	/* second */
+	.foo, /* between */
+	.bar /* trailing */ {
+		/* block */
+		color: r /* value */ ed;
+	}
+
+	@media screen/* media */and (width > 0) {
+		/* nested */
+		.baz {
+			display: block;
+		}
+	}
+
+	.empty {
+		/* only */
+	}
+
+	.part::part(/* argument */ label) {
+		display: block;
+	}
+
+	/* last */
+</style>
diff --git a/packages/svelte/tests/print/samples/style-comments/output.svelte b/packages/svelte/tests/print/samples/style-comments/output.svelte
new file mode 100644
index 0000000000..cb913cc0b5
--- /dev/null
+++ b/packages/svelte/tests/print/samples/style-comments/output.svelte
@@ -0,0 +1,28 @@
+<style>
+	/* first */
+
+	/* second */
+
+	.foo, /* between */
+	.bar /* trailing */ {
+		/* block */
+		color: r /* value */ ed;
+	}
+
+	@media screen/* media */and (width > 0) {
+		/* nested */
+		.baz {
+			display: block;
+		}
+	}
+
+	.empty {
+		/* only */
+	}
+
+	.part::part(/* argument */ label) {
+		display: block;
+	}
+
+	/* last */
+</style>
diff --git a/packages/svelte/tests/print/test.ts b/packages/svelte/tests/print/test.ts
index aa007a7a54..4caecf90ae 100644
--- a/packages/svelte/tests/print/test.ts
+++ b/packages/svelte/tests/print/test.ts
@@ -12,6 +12,10 @@ const { test, run } = suite<PrintTest>(async (config, cwd) => {
 	const output = print(ast);
 	const outputCode = output.code.endsWith('\n') ? output.code : output.code + '\n';
 
+	// the printed output must itself be valid Svelte — `print` should never emit
+	// code that `parse` cannot read back (e.g. CSS escape sequences must round-trip)
+	parse(outputCode, { modern: true });
+
 	// run `UPDATE_SNAPSHOTS=true pnpm test print` to update print tests
 	if (process.env.UPDATE_SNAPSHOTS) {
 		fs.writeFileSync(`${cwd}/output.svelte`, outputCode);
diff --git a/packages/svelte/tests/runtime-browser/custom-elements-samples/$$slot-dynamic-content/_config.js b/packages/svelte/tests/runtime-browser/custom-elements-samples/$$slot-dynamic-content/_config.js
index 8ade347a79..3fd5a09888 100644
--- a/packages/svelte/tests/runtime-browser/custom-elements-samples/$$slot-dynamic-content/_config.js
+++ b/packages/svelte/tests/runtime-browser/custom-elements-samples/$$slot-dynamic-content/_config.js
@@ -14,8 +14,8 @@ export default test({
 		assert.htmlEqual(
 			ce.shadowRoot.innerHTML,
 			`
-		<slot></slot>
-		<p>named fallback</p>
+		<slot>fallback</slot>
+		<slot name="named"><p>named fallback</p></slot>
 	`
 		);
 
@@ -23,8 +23,8 @@ export default test({
 		assert.htmlEqual(
 			ce.shadowRoot.innerHTML,
 			`
-		<slot></slot>
-		<p>named fallback</p>
+		<slot>fallback</slot>
+		<slot name="named"><p>named fallback</p></slot>
 	`
 		);
 	}
diff --git a/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/Child.svelte b/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/Child.svelte
new file mode 100644
index 0000000000..86064ab3b1
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/Child.svelte
@@ -0,0 +1,7 @@
+<p>child</p>
+
+<style>
+	p {
+		color: rgb(255, 0, 0);
+	}
+</style>
diff --git a/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/_config.js b/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/_config.js
new file mode 100644
index 0000000000..739921ebf5
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/_config.js
@@ -0,0 +1,24 @@
+import { assert_ok, test } from '../../assert';
+
+const tick = () => Promise.resolve();
+
+export default test({
+	async test({ assert, target }) {
+		target.innerHTML = '<my-app></my-app>';
+
+		// wait for the initial mount, the `onMount` reveal and the deferred re-render
+		await tick();
+		await tick();
+		await tick();
+		await tick();
+
+		/** @type {any} */
+		const el = target.querySelector('my-app');
+		const p = el.shadowRoot.querySelector('p');
+		assert_ok(p);
+
+		// The child's scoped styles must be injected into the shadow root, not `document.head`
+		assert_ok(el.shadowRoot.querySelector('style'));
+		assert.equal(getComputedStyle(p).color, 'rgb(255, 0, 0)');
+	}
+});
diff --git a/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/main.svelte b/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/main.svelte
new file mode 100644
index 0000000000..2bd0456fc1
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/custom-elements-samples/deferred-nested-styles/main.svelte
@@ -0,0 +1,18 @@
+<svelte:options customElement="my-app" />
+
+<script>
+	import { onMount } from 'svelte';
+	import Child from './Child.svelte';
+
+	let items = $state([]);
+
+	// Add the item _after_ the initial mount, so that the each block renders the
+	// new item into an offscreen anchor that is discarded once it's committed to
+	// the DOM. This reproduces styles being injected into `document.head` instead
+	// of the shadow root (https://github.com/sveltejs/svelte/issues/18288)
+	onMount(() => {
+		items = [1];
+	});
+</script>
+
+{#each items as item (item)}<Child />{/each}
diff --git a/packages/svelte/tests/runtime-browser/custom-elements-samples/html-slots/_config.js b/packages/svelte/tests/runtime-browser/custom-elements-samples/html-slots/_config.js
index 287e2987b8..e3e8ce072b 100644
--- a/packages/svelte/tests/runtime-browser/custom-elements-samples/html-slots/_config.js
+++ b/packages/svelte/tests/runtime-browser/custom-elements-samples/html-slots/_config.js
@@ -3,10 +3,7 @@ const tick = () => Promise.resolve();
 
 export default test({
 	async test({ assert, target }) {
-		target.innerHTML = `
-		<custom-element>
-			<strong>slotted</strong>
-		</custom-element>`;
+		target.innerHTML = '<custom-element></custom-element>';
 		await tick();
 		await tick();
 
@@ -16,7 +13,26 @@ export default test({
 		const div = el.shadowRoot.children[0];
 		const [slot0, slot1] = div.children;
 
-		assert.equal(slot0.assignedNodes()[1], target.querySelector('strong'));
-		assert.equal(slot1.innerHTML, 'foo fallback content');
+		assert.equal(slot0.localName, 'slot');
+		assert.equal(slot0.assignedNodes().length, 0);
+		assert.equal(slot0.innerHTML, '<p>default fallback content</p>');
+		assert.equal(slot1.localName, 'slot');
+		assert.equal(slot1.name, 'foo');
+		assert.equal(slot1.assignedNodes().length, 0);
+		assert.equal(slot1.innerHTML, '<p>foo fallback content</p>');
+
+		const default_content = document.createElement('strong');
+		default_content.textContent = 'default content';
+		el.append(default_content);
+
+		const named_content = document.createElement('strong');
+		named_content.slot = 'foo';
+		named_content.textContent = 'named content';
+		el.append(named_content);
+
+		assert.equal(slot0.assignedNodes().length, 1);
+		assert.equal(slot0.assignedNodes()[0], default_content);
+		assert.equal(slot1.assignedNodes().length, 1);
+		assert.equal(slot1.assignedNodes()[0], named_content);
 	}
 });
diff --git a/packages/svelte/tests/runtime-browser/custom-elements-samples/no-shadow-dom/_config.js b/packages/svelte/tests/runtime-browser/custom-elements-samples/no-shadow-dom/_config.js
index cd8550120a..e83491418a 100644
--- a/packages/svelte/tests/runtime-browser/custom-elements-samples/no-shadow-dom/_config.js
+++ b/packages/svelte/tests/runtime-browser/custom-elements-samples/no-shadow-dom/_config.js
@@ -3,7 +3,7 @@ const tick = () => Promise.resolve();
 
 export default test({
 	async test({ assert, target }) {
-		target.innerHTML = '<custom-element name="world"></custom-element>';
+		target.innerHTML = '<custom-element name="world"><span>slotted</span></custom-element>';
 		await tick();
 		await tick();
 
@@ -15,5 +15,6 @@ export default test({
 		assert.equal(el.shadowRoot, null);
 		assert.equal(h1.innerHTML, 'Hello world!');
 		assert.equal(getComputedStyle(h1).color, 'rgb(255, 0, 0)');
+		assert.equal(el.querySelector('slot').innerHTML, '');
 	}
 });
diff --git a/packages/svelte/tests/runtime-browser/custom-elements-samples/no-shadow-dom/main.svelte b/packages/svelte/tests/runtime-browser/custom-elements-samples/no-shadow-dom/main.svelte
index 36fea3c43e..1c14fb98d8 100644
--- a/packages/svelte/tests/runtime-browser/custom-elements-samples/no-shadow-dom/main.svelte
+++ b/packages/svelte/tests/runtime-browser/custom-elements-samples/no-shadow-dom/main.svelte
@@ -5,6 +5,7 @@
 </script>
 
 <h1>Hello {name}!</h1>
+<slot>fallback</slot>
 
 <style>
 	h1 {
diff --git a/packages/svelte/tests/runtime-browser/samples/selectedcontent-oninput-interfere/_config.js b/packages/svelte/tests/runtime-browser/samples/selectedcontent-oninput-interfere/_config.js
new file mode 100644
index 0000000000..d153eceeb7
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/selectedcontent-oninput-interfere/_config.js
@@ -0,0 +1,22 @@
+import { flushSync } from 'svelte';
+import { ok, test } from '../../assert';
+
+export default test({
+	async test({ target, assert }) {
+		const select = target.querySelector('select');
+		ok(select);
+
+		select.value = 'B';
+		select.dispatchEvent(new Event('input', { bubbles: true }));
+
+		// because another element has a delegated `oninput` handler, a global `input`
+		// listener runs and, once it returns, a microtask checkpoint delivers the
+		// mutation records *before* the `change` event — we emulate that checkpoint here
+		await Promise.resolve();
+
+		select.dispatchEvent(new Event('change', { bubbles: true }));
+		flushSync();
+
+		assert.equal(select.value, 'B');
+	}
+});
diff --git a/packages/svelte/tests/runtime-browser/samples/selectedcontent-oninput-interfere/main.svelte b/packages/svelte/tests/runtime-browser/samples/selectedcontent-oninput-interfere/main.svelte
new file mode 100644
index 0000000000..97634042ff
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/selectedcontent-oninput-interfere/main.svelte
@@ -0,0 +1,17 @@
+<script lang="ts">
+	let value = $state('A');
+</script>
+
+<input oninput={() => {}} />
+<select bind:value>
+	<button><selectedcontent></selectedcontent></button>
+	<option>A</option>
+	<option>B</option>
+	<option>C</option>
+</select>
+
+<style>
+	select,::picker(select){
+		appearance: base-select;
+	}
+</style>
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/Nested.svelte b/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/Nested.svelte
new file mode 100644
index 0000000000..eeb325059f
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/Nested.svelte
@@ -0,0 +1,14 @@
+<script>
+	import Nested from './Nested.svelte';
+	import { slide } from 'svelte/transition';
+
+	let { depth } = $props();
+</script>
+
+<div class="level-{depth}" in:slide|global={{ duration: 100 }}>
+	{#if depth > 0}
+		<Nested depth={depth - 1} />
+	{:else}
+		<div style="height: 100px">leaf</div>
+	{/if}
+</div>
diff --git a/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/_config.js b/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/_config.js
new file mode 100644
index 0000000000..00e5cb02a2
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/_config.js
@@ -0,0 +1,36 @@
+import { test } from '../../assert';
+
+export default test({
+	async test({ assert, target }) {
+		const button = target.querySelector('button');
+		button?.click();
+
+		// wait for the transition's keyframes to be created
+		const animation = await new Promise((resolve, reject) => {
+			const start = performance.now();
+
+			function check() {
+				const outer = target.querySelector('.level-2');
+				const animation = outer
+					?.getAnimations()
+					.find((a) => a.effect?.getTiming().duration === 100);
+
+				if (animation) {
+					resolve(animation);
+				} else if (performance.now() - start > 2000) {
+					reject(new Error('timed out waiting for the transition to start'));
+				} else {
+					requestAnimationFrame(check);
+				}
+			}
+
+			check();
+		});
+
+		// the outermost `slide` must have measured the element with its
+		// descendants at their natural size, not collapsed to zero by their
+		// own starting styles (#18421)
+		const keyframes = animation.effect?.getKeyframes() ?? [];
+		assert.equal(keyframes[keyframes.length - 1].height, '100px');
+	}
+});
diff --git a/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/main.svelte b/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/main.svelte
new file mode 100644
index 0000000000..a64a0cd2f4
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/transition-nested-measure/main.svelte
@@ -0,0 +1,11 @@
+<script>
+	import Nested from './Nested.svelte';
+
+	let visible = $state(false);
+</script>
+
+<button onclick={() => (visible = !visible)}>toggle</button>
+
+{#if visible}
+	<Nested depth={2} />
+{/if}
diff --git a/packages/svelte/tests/runtime-browser/samples/transition-slide-hidden-parent/_config.js b/packages/svelte/tests/runtime-browser/samples/transition-slide-hidden-parent/_config.js
new file mode 100644
index 0000000000..a8c1e07111
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/transition-slide-hidden-parent/_config.js
@@ -0,0 +1,27 @@
+import { ok, test } from '../../assert';
+
+export default test({
+	async test({ assert, window }) {
+		window.document.querySelector('button')?.click();
+		await new Promise((r) => setTimeout(r, 100));
+
+		const p = window.document.querySelector('p');
+		const animations = /** @type {HTMLElement} */ (p).getAnimations();
+		assert.equal(animations.length, 1);
+
+		// when the element has no layout box, computed dimensions resolve to 'auto',
+		// which must not end up as NaN values that the browser rejects (#14205)
+		const effect = /** @type {KeyframeEffect} */ (animations[0].effect);
+		const keyframes = effect.getKeyframes();
+		ok(keyframes.length > 0);
+		assert.equal(effect.getTiming().duration, 400);
+
+		for (const keyframe of keyframes) {
+			ok(!('height' in keyframe), 'unresolved height should be omitted');
+
+			for (const value of Object.values(keyframe)) {
+				ok(!String(value).includes('NaN'), `unexpected NaN in keyframe: ${value}`);
+			}
+		}
+	}
+});
diff --git a/packages/svelte/tests/runtime-browser/samples/transition-slide-hidden-parent/main.svelte b/packages/svelte/tests/runtime-browser/samples/transition-slide-hidden-parent/main.svelte
new file mode 100644
index 0000000000..e1a7c54bdb
--- /dev/null
+++ b/packages/svelte/tests/runtime-browser/samples/transition-slide-hidden-parent/main.svelte
@@ -0,0 +1,13 @@
+<script>
+	import { slide } from 'svelte/transition';
+
+	let visible = $state(false);
+</script>
+
+<button onclick={() => (visible = !visible)}>toggle</button>
+
+<div style="display: none">
+	{#if visible}
+		<p transition:slide>hello</p>
+	{/if}
+</div>
diff --git a/packages/svelte/tests/runtime-legacy/samples/html-entities/_config.js b/packages/svelte/tests/runtime-legacy/samples/html-entities/_config.js
index add763989e..82c87495c4 100644
--- a/packages/svelte/tests/runtime-legacy/samples/html-entities/_config.js
+++ b/packages/svelte/tests/runtime-legacy/samples/html-entities/_config.js
@@ -7,6 +7,7 @@ export default test({
 		<span>*</span>
 		<span>*</span>
 		<span>*</span>
+		<span>*</span>
 
 		<span></span>
 		<span>A</span>
diff --git a/packages/svelte/tests/runtime-legacy/samples/html-entities/main.svelte b/packages/svelte/tests/runtime-legacy/samples/html-entities/main.svelte
index 2d0d66c939..25a60cb930 100644
--- a/packages/svelte/tests/runtime-legacy/samples/html-entities/main.svelte
+++ b/packages/svelte/tests/runtime-legacy/samples/html-entities/main.svelte
@@ -2,6 +2,7 @@
 <span>&midast;</span>
 <span>&#x0002A;</span>
 <span>&#x0002A</span>
+<span>&#X0002A;</span>
 <span>&#42;</span>
 
 <span>&#10;</span>
diff --git a/packages/svelte/tests/runtime-legacy/samples/select-spread-preserve-selection/_config.js b/packages/svelte/tests/runtime-legacy/samples/select-spread-preserve-selection/_config.js
new file mode 100644
index 0000000000..8bc2f11e26
--- /dev/null
+++ b/packages/svelte/tests/runtime-legacy/samples/select-spread-preserve-selection/_config.js
@@ -0,0 +1,25 @@
+import { flushSync } from 'svelte';
+import { ok, test } from '../../test';
+
+export default test({
+	mode: ['client', 'hydrate'],
+
+	async test({ assert, component, target }) {
+		const select = target.querySelector('select');
+		ok(select);
+
+		assert.equal(select.selectedIndex, 0);
+
+		component.toggle();
+		flushSync();
+		await Promise.resolve();
+
+		assert.equal(select.selectedIndex, 0);
+
+		component.toggle();
+		flushSync();
+		await Promise.resolve();
+
+		assert.equal(select.selectedIndex, 0);
+	}
+});
diff --git a/packages/svelte/tests/runtime-legacy/samples/select-spread-preserve-selection/main.svelte b/packages/svelte/tests/runtime-legacy/samples/select-spread-preserve-selection/main.svelte
new file mode 100644
index 0000000000..229ce4fb73
--- /dev/null
+++ b/packages/svelte/tests/runtime-legacy/samples/select-spread-preserve-selection/main.svelte
@@ -0,0 +1,16 @@
+<script>
+	let show_extra = false;
+	const attributes = { 'aria-label': 'choice' };
+
+	export function toggle() {
+		show_extra = !show_extra;
+	}
+</script>
+
+<select {...attributes}>
+	<option value="">Choose an option</option>
+	<option value="first">First</option>
+	{#if show_extra}
+		<option value="extra">Extra</option>
+	{/if}
+</select>
diff --git a/packages/svelte/tests/runtime-legacy/shared.ts b/packages/svelte/tests/runtime-legacy/shared.ts
index 5c2d0dfe1c..de6749c0e7 100644
--- a/packages/svelte/tests/runtime-legacy/shared.ts
+++ b/packages/svelte/tests/runtime-legacy/shared.ts
@@ -177,11 +177,11 @@ export function runtime_suite(runes: boolean) {
 		['dom', 'hydrate', 'ssr', 'async-ssr'],
 		(variant, config, test_name) => {
 			if (!async_mode && (config.skip_no_async || test_name.startsWith('async-'))) {
-				return true;
+				return 'no-test';
 			}
 
 			if (async_mode && config.skip_async) {
-				return true;
+				return 'no-test';
 			}
 
 			if (variant === 'hydrate') {
@@ -195,9 +195,9 @@ export function runtime_suite(runes: boolean) {
 			) {
 				return 'no-test';
 			}
-
 			if (variant === 'ssr') {
 				if (
+					(test_name.startsWith('async-') && !config.mode?.includes('server')) ||
 					(config.mode && !config.mode.includes('server')) ||
 					(!config.test_ssr &&
 						config.html === undefined &&
diff --git a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/Child.svelte b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/Child.svelte
new file mode 100644
index 0000000000..5a837e5ea4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/Child.svelte
@@ -0,0 +1,20 @@
+<script lang="ts">
+	import { getAbortSignal } from "svelte";
+
+	let { count, aborted = $bindable() } = $props()
+
+	let der = $derived.by(()=>{
+		const signal = getAbortSignal();
+
+		signal.addEventListener("abort", () => {
+			try {
+				aborted++;
+			} catch(e) {
+				console.error(e);
+			}
+		});
+		return count;
+	})
+</script>
+
+{der}
diff --git a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/_config.js b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/_config.js
new file mode 100644
index 0000000000..3c6ec98fe6
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/_config.js
@@ -0,0 +1,14 @@
+import { ok, test } from '../../test';
+import { flushSync } from 'svelte';
+
+export default test({
+	async test({ assert, target, errors }) {
+		const btn = target.querySelector('button');
+
+		flushSync(() => {
+			btn?.click();
+		});
+		assert.htmlEqual(target.innerHTML, '1 <button>increment</button>');
+		assert.deepEqual(errors, []);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/main.svelte b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/main.svelte
new file mode 100644
index 0000000000..57c467a80c
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-destroy/main.svelte
@@ -0,0 +1,14 @@
+<script lang="ts">
+	import Child from './Child.svelte'
+
+	let count = $state(0);
+	let aborted = $state(0)
+</script>
+
+{aborted}
+
+<button onclick={() => count++}>increment</button>
+
+{#if count % 2 === 0}
+	<Child {count} bind:aborted={aborted} />
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-rerun-on-reconnect/_config.js b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-rerun-on-reconnect/_config.js
new file mode 100644
index 0000000000..7caf765e3b
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-rerun-on-reconnect/_config.js
@@ -0,0 +1,32 @@
+import { test } from '../../test';
+import { tick } from 'svelte';
+
+export default test({
+	async test({ assert, target }) {
+		const [increment, toggle, resolve] = target.querySelectorAll('button');
+		const [div] = target.querySelectorAll('div');
+
+		assert.htmlEqual(div.innerHTML, 'loading');
+		resolve.click();
+		await tick();
+		assert.htmlEqual(div.innerHTML, '0');
+
+		increment.click();
+		await tick();
+		assert.htmlEqual(div.innerHTML, 'loading');
+
+		toggle.click();
+		await tick();
+		assert.htmlEqual(div.innerHTML, '');
+
+		toggle.click();
+		await tick();
+		assert.htmlEqual(div.innerHTML, 'loading');
+
+		resolve.click(); // this one's for clearing the obsolete/aborted one from the queue
+		await tick();
+		resolve.click();
+		await tick();
+		assert.htmlEqual(div.innerHTML, '2');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-rerun-on-reconnect/main.svelte b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-rerun-on-reconnect/main.svelte
new file mode 100644
index 0000000000..a047afdd44
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-rerun-on-reconnect/main.svelte
@@ -0,0 +1,32 @@
+<script>
+	import { getAbortSignal } from 'svelte'
+	
+	let show = $state(true)
+	let count = $state(0);
+	let queued = [];
+
+	export function sleep(value, signal) {
+	  return new Promise((resolve, reject) => {
+	    signal.addEventListener('abort', reject, { once: true });
+		queued.push(() => resolve(value));
+	  });
+	}
+
+	const double = $derived(sleep(count * 2, getAbortSignal()));
+</script>
+
+<button onclick={() => count += 1}>clicks: {count}</button>
+<button onclick={() => show = !show}>toggle</button>
+<button onclick={() => queued.shift()?.()}>resolve</button>
+
+<div>
+	{#if show}
+		{#await double}
+			loading
+		{:then value}
+			{value}
+		{:catch}
+			error
+		{/await}
+	{/if}
+</div>
diff --git a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-set-state/_config.js b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-set-state/_config.js
index 2dacf188d7..aa38dd8280 100644
--- a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-set-state/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-set-state/_config.js
@@ -4,9 +4,11 @@ import { flushSync } from 'svelte';
 export default test({
 	async test({ assert, target, errors }) {
 		const btn = target.querySelector('button');
+
 		flushSync(() => {
 			btn?.click();
 		});
+		assert.htmlEqual(target.innerHTML, '1:1 <button></button>');
 		assert.deepEqual(errors, []);
 	}
 });
diff --git a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-set-state/main.svelte b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-set-state/main.svelte
index ebefe38fb2..e76cecbac9 100644
--- a/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-set-state/main.svelte
+++ b/packages/svelte/tests/runtime-runes/samples/abort-signal-derived-set-state/main.svelte
@@ -9,9 +9,9 @@
 		const signal = getAbortSignal();
 
 		signal.addEventListener("abort", () => {
-			try{
+			try {
 				aborted++;
-			}catch(e){
+			} catch(e) {
 				console.error(e);
 			}
 		});
@@ -19,6 +19,6 @@
 	})
 </script>
 
-{der}
+{der}:{aborted}
 
-<button onclick={() => count++}></button>
\ No newline at end of file
+<button onclick={() => count++}></button>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-batch-derived/_config.js b/packages/svelte/tests/runtime-runes/samples/async-batch-derived/_config.js
new file mode 100644
index 0000000000..d5286d9d95
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-batch-derived/_config.js
@@ -0,0 +1,28 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		const [increment, pop] = target.querySelectorAll('button');
+
+		increment.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`<button>increment</button> <button>pop</button> <p>Loading...</p>`
+		);
+		increment.click();
+		await tick();
+		assert.htmlEqual(
+			target.innerHTML,
+			`<button>increment</button> <button>pop</button> <p>Loading...</p>`
+		);
+		pop.click();
+		await tick();
+		assert.htmlEqual(target.innerHTML, `<button>increment</button> <button>pop</button> 2 2 1`);
+
+		pop.click();
+		await tick();
+		assert.htmlEqual(target.innerHTML, `<button>increment</button> <button>pop</button> 2 2 1`);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-batch-derived/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-batch-derived/main.svelte
new file mode 100644
index 0000000000..af7f0f468c
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-batch-derived/main.svelte
@@ -0,0 +1,29 @@
+<script>
+	let count = $state(0);
+	let other = $state(0);
+
+	const queue = [];
+  	let pending = $derived(defaultPending);
+	function push(v) {
+		return new Promise((resolve) => queue.push(() => resolve(v)));
+	}
+</script>
+
+<button onclick={() => {
+	if (count === 0) {
+		other++;
+		count++;
+	} else {
+		count++
+	}
+}}>increment</button>
+<button onclick={() => queue.pop()?.()}>pop</button>
+{#snippet defaultPending()}
+  <p>Loading...</p>
+{/snippet}
+
+{#if count > 0}
+	<svelte:boundary {pending}>
+		{await push(count)} {count} {other}
+	</svelte:boundary> 
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-bind-factory-function-remote/_config.js b/packages/svelte/tests/runtime-runes/samples/async-bind-factory-function-remote/_config.js
index 080e2d278c..60e58b27a1 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-bind-factory-function-remote/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/async-bind-factory-function-remote/_config.js
@@ -3,12 +3,12 @@ import { test } from '../../test';
 
 export default test({
 	mode: ['async-server', 'client', 'hydrate'],
-	ssrHtml: 'true true true true true',
+	ssrHtml: 'true true true true true true',
 
 	async test({ assert, target }) {
 		await new Promise((resolve) => setTimeout(resolve, 10));
 		await tick();
 
-		assert.htmlEqual(target.innerHTML, 'true true true true true');
+		assert.htmlEqual(target.innerHTML, 'true true true true true true');
 	}
 });
diff --git a/packages/svelte/tests/runtime-runes/samples/async-bind-factory-function-remote/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-bind-factory-function-remote/main.svelte
index 5f79a14830..4f8f2f97b8 100644
--- a/packages/svelte/tests/runtime-runes/samples/async-bind-factory-function-remote/main.svelte
+++ b/packages/svelte/tests/runtime-runes/samples/async-bind-factory-function-remote/main.svelte
@@ -21,6 +21,8 @@
 		const indirect = () => checkedFactory()();
 		return indirect;
 	}
+
+	const arrow = () => () => checked;
 </script>
 
 <!-- force into separate effects -->
@@ -39,3 +41,6 @@
 {#if true}
 	{indirectChecked2()()}
 {/if}
+{#if true}
+	{arrow()()}
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-const-closure-read/_config.js b/packages/svelte/tests/runtime-runes/samples/async-const-closure-read/_config.js
new file mode 100644
index 0000000000..be0e3c7f40
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-const-closure-read/_config.js
@@ -0,0 +1,10 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+// #18469 — a @const in a nested snippet reading an async declaration through a closure must block on it
+export default test({
+	async test({ assert, target }) {
+		await tick();
+		assert.htmlEqual(target.innerHTML, '<p>true</p> <p>false</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-const-closure-read/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-const-closure-read/main.svelte
new file mode 100644
index 0000000000..881455ec27
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-const-closure-read/main.svelte
@@ -0,0 +1,12 @@
+<script>
+	async function getValue() {
+		return new Set(['a', 'b', 'c']);
+	}
+
+	const value = await getValue();
+</script>
+
+{#each [['a', 'b'], ['a', 'x']] as keys}
+	{@const all_present = keys.every((k) => value.has(k))}
+	<p>{all_present}</p>
+{/each}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-custom-element-attribute/_config.js b/packages/svelte/tests/runtime-runes/samples/async-custom-element-attribute/_config.js
new file mode 100644
index 0000000000..788573d7cf
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-custom-element-attribute/_config.js
@@ -0,0 +1,11 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ target, assert }) {
+		await tick();
+		const [element] = target.querySelectorAll('async-custom-element');
+
+		assert.htmlEqual(element.innerHTML, `Hello foobar!`);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-custom-element-attribute/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-custom-element-attribute/main.svelte
new file mode 100644
index 0000000000..a047054069
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-custom-element-attribute/main.svelte
@@ -0,0 +1,41 @@
+<script>
+	class MyCustomElement extends HTMLElement {
+		constructor() {
+			super();
+			this._foo = null;
+			this._bar = null;
+		}
+
+		/**
+		 * @param {string} foo
+		 */
+		set foo(foo) {
+			this._foo = foo;
+			this.render();
+		}
+
+		/**
+		 * @param {string} foo
+		 */
+		set bar(bar) {
+			this._bar = bar;
+			this.render();
+		}
+
+		connectedCallback() {
+			this.render();
+		}
+
+		render() {
+			this.innerHTML = "Hello " + this._foo + this._bar + "!";
+		}
+	}
+
+	if (!customElements.get('async-custom-element')) {
+		customElements.define("async-custom-element", MyCustomElement);
+	}
+
+	const foo = $derived(await "foo");
+</script>
+
+<async-custom-element {foo} bar={await 'bar'}></async-custom-element>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-declaration-closure-read/_config.js b/packages/svelte/tests/runtime-runes/samples/async-declaration-closure-read/_config.js
new file mode 100644
index 0000000000..6a10f6928a
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-declaration-closure-read/_config.js
@@ -0,0 +1,11 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+// #18469 — a sync $derived in a nested snippet reading an async declaration through a closure must block on it
+export default test({
+	ssrHtml: '<p>true</p> <p>false</p>',
+	async test({ assert, target }) {
+		await tick();
+		assert.htmlEqual(target.innerHTML, '<p>true</p> <p>false</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-declaration-closure-read/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-declaration-closure-read/main.svelte
new file mode 100644
index 0000000000..ddd9a10b04
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-declaration-closure-read/main.svelte
@@ -0,0 +1,17 @@
+<script>
+	async function getValue() {
+		return new Set(['a', 'b', 'c']);
+	}
+</script>
+
+{#snippet outer()}
+	{const value = $derived(await getValue())}
+	{#snippet inner(keys)}
+		{const all_present = $derived(keys.every((k) => value.has(k)))}
+		<p>{all_present}</p>
+	{/snippet}
+	{@render inner(['a', 'b'])}
+	{@render inner(['a', 'x'])}
+{/snippet}
+
+{@render outer()}
diff --git a/packages/svelte/tests/runtime-runes/samples/async-derived-log-outside-reactivity/_config.js b/packages/svelte/tests/runtime-runes/samples/async-derived-log-outside-reactivity/_config.js
new file mode 100644
index 0000000000..1a7ed0eb92
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-derived-log-outside-reactivity/_config.js
@@ -0,0 +1,42 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	skip: true, // TODO fix
+	async test({ assert, target, logs }) {
+		await tick();
+
+		const [a, b, log, resolve] = target.querySelectorAll('button');
+		const [p] = target.querySelectorAll('p');
+
+		a.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, '0 0 0');
+
+		b.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, '0 0 0');
+
+		log.click();
+		await tick();
+		assert.deepEqual(logs, [0, 2]);
+
+		resolve.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, '1 0 1');
+		assert.deepEqual(logs, [0, 2, 1]);
+
+		log.click();
+		await tick();
+		assert.deepEqual(logs, [0, 2, 1, 2]);
+
+		resolve.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, '1 1 2');
+		assert.deepEqual(logs, [0, 2, 1, 2, 2]);
+
+		log.click();
+		await tick();
+		assert.deepEqual(logs, [0, 2, 1, 2, 2, 2]);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-derived-log-outside-reactivity/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-derived-log-outside-reactivity/main.svelte
new file mode 100644
index 0000000000..bf543ba595
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-derived-log-outside-reactivity/main.svelte
@@ -0,0 +1,23 @@
+<script>
+	let a = $state(0);
+	let b = $state(0);
+
+	let d = $derived(a + b);
+
+	let queued = [];
+	function push(v) {
+		if (!v) return v;
+		return new Promise((resolve) => {
+			queued.push(() => resolve(v));
+		});
+	}
+
+	$effect(() => console.log(d));
+</script>
+
+<button onclick={() => a++}>a++</button>
+<button onclick={() => b++}>b++</button>
+<button onclick={() => console.log(d)}>log d</button>
+<button onclick={() => queued.shift()?.()}>resolve</button>
+
+<p>{await push(a)} {await push(b)} {d}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-derived-not-overfiring/_config.js b/packages/svelte/tests/runtime-runes/samples/async-derived-not-overfiring/_config.js
new file mode 100644
index 0000000000..b959ba5407
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-derived-not-overfiring/_config.js
@@ -0,0 +1,35 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	skip: true, // TODO fix
+	async test({ assert, target, logs }) {
+		await tick();
+
+		const [a, b, log, resolve] = target.querySelectorAll('button');
+		const [div] = target.querySelectorAll('div');
+
+		assert.deepEqual(logs, ['e1 0', 'e2 0']);
+		logs.length = 0;
+
+		a.click();
+		await tick();
+		assert.htmlEqual(div.innerHTML, '<p>0</p> <p>0</p> <p>0</p>');
+
+		b.click();
+		await tick();
+		assert.htmlEqual(div.innerHTML, '<p>0</p> <p>1</p> <p>1</p>');
+
+		log.click();
+		await tick();
+		assert.deepEqual(logs, ['e1 1', 'e2 1', 'runs 2']); // ideally it's only 2 runs, one or two more would also be acceptable but not the 8 that it's today
+		logs.length = 0;
+
+		resolve.click();
+		await tick();
+		log.click();
+		await tick();
+		assert.htmlEqual(div.innerHTML, '<p>1</p> <p>2</p> <p>2</p>');
+		assert.deepEqual(logs, ['e1 2', 'e2 2', 'runs 3']);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-derived-not-overfiring/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-derived-not-overfiring/main.svelte
new file mode 100644
index 0000000000..784932ab5d
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-derived-not-overfiring/main.svelte
@@ -0,0 +1,29 @@
+<script>
+	let a = $state(0);
+	let b = $state(0);
+	let runs = 0;
+
+	let d = $derived((runs++, a + b));
+
+	const queued = [];
+	function push(v) {
+		if (!v) return v;
+		return new Promise((resolve) => {
+			queued.push(() => resolve(v));
+		});
+	}
+
+	$effect(() => console.log('e1 ' + d));
+	$effect(() => console.log('e2 ' + d));
+</script>
+
+<button onclick={() => a++}>a++</button>
+<button onclick={() => b++}>b++</button>
+<button onclick={() => console.log('runs ' + runs)}>log runs</button>
+<button onclick={() => queued.shift()?.()}>resolve</button>
+
+<div>
+	<p>{await push(a)}</p>
+	<p>{d}</p>
+	<p>{d}</p>
+</div>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-derived-not-underfiring/_config.js b/packages/svelte/tests/runtime-runes/samples/async-derived-not-underfiring/_config.js
new file mode 100644
index 0000000000..7d31d30b46
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-derived-not-underfiring/_config.js
@@ -0,0 +1,28 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	skip: true, // TODO fix
+	async test({ assert, target, logs }) {
+		await tick();
+
+		const [a, b, resolve] = target.querySelectorAll('button');
+		const [p] = target.querySelectorAll('p');
+
+		assert.deepEqual(logs, ['b: 0, d: 0']);
+		logs.length = 0;
+
+		a.click();
+		await tick();
+		b.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, '0 1');
+		assert.deepEqual(logs, ['b: 1, d: 0']);
+		logs.length = 0;
+
+		resolve.click();
+		await tick();
+		assert.htmlEqual(p.innerHTML, '2 1');
+		assert.deepEqual(logs, ['b: 1, d: 2']);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-derived-not-underfiring/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-derived-not-underfiring/main.svelte
new file mode 100644
index 0000000000..97d91ae994
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-derived-not-underfiring/main.svelte
@@ -0,0 +1,22 @@
+<script>
+	let a = $state(0);
+	let b = $state(0);
+
+	let d = $derived(a * 2);
+
+	const queued = [];
+	function push(v) {
+		if (!v) return v;
+		return new Promise((resolve) => {
+			queued.push(() => resolve(v));
+		});
+	}
+
+	$effect(() => console.log(`b: ${b}, d: ${d}`));
+</script>
+
+<button onclick={() => a++}>a++</button>
+<button onclick={() => b++}>b++</button>
+<button onclick={() => queued.shift()?.()}>resolve</button>
+
+<p>{await push(d)} {b}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-each-controlled-empty-pending/_config.js b/packages/svelte/tests/runtime-runes/samples/async-each-controlled-empty-pending/_config.js
new file mode 100644
index 0000000000..29d374deec
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-each-controlled-empty-pending/_config.js
@@ -0,0 +1,50 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+// Regression for #18610: emptying a controlled keyed {#each} while another
+// batch is still pending must not take the fast path that clears state.items
+// before destroy_effects walks pending keys.
+export default test({
+	mode: ['client'],
+
+	async test({ assert, target }) {
+		await tick();
+
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+				<button>startA</button>
+				<button>startB</button>
+				<button>settleB</button>
+				<p>A0/B0</p>
+				<div><span>1</span><span>2</span></div>
+			`
+		);
+
+		const [startA, startB, settleB] = target.querySelectorAll('button');
+
+		// Batch A: add key 9, then block forever on gate A.
+		startA.click();
+		await tick();
+
+		// Batch B: empty the collection, then block on gate B.
+		startB.click();
+		await tick();
+
+		// Settle B first so B commits while A is still pending.
+		// Without the fix this throws reading `.e` of undefined and leaves a/b stuck.
+		settleB.click();
+		await tick();
+
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+				<button>startA</button>
+				<button>startB</button>
+				<button>settleB</button>
+				<p>A0/B1</p>
+				<div></div>
+			`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-each-controlled-empty-pending/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-each-controlled-empty-pending/main.svelte
new file mode 100644
index 0000000000..68c3937c25
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-each-controlled-empty-pending/main.svelte
@@ -0,0 +1,54 @@
+<script>
+	let base = $state([1, 2]);
+	let extraKey = $state(/** @type {number | null} */ (null));
+	let tickA = $state(0);
+	let tickB = $state(0);
+
+	// Two independent sources so the batches touch disjoint source sets
+	// and are not merged.
+	const items = $derived(extraKey === null ? base : [...base, extraKey]);
+
+	/** @type {((value: string) => void) | undefined} */
+	let resolveB;
+
+	/**
+	 * @param {string} name
+	 * @param {number} n
+	 */
+	const gate = (name, n) =>
+		n === 0
+			? Promise.resolve(`${name}0`)
+			: new Promise((r) => {
+					if (name === 'B') resolveB = r;
+				});
+
+	const a = $derived(await gate('A', tickA));
+	const b = $derived(await gate('B', tickB));
+
+	function startA() {
+		extraKey = 9;
+		tickA = 1;
+	}
+
+	function startB() {
+		base = [];
+		tickB = 1;
+	}
+
+	function settleB() {
+		resolveB?.('B1');
+	}
+</script>
+
+<button onclick={startA}>startA</button>
+<button onclick={startB}>startB</button>
+<button onclick={settleB}>settleB</button>
+
+<p>{a}/{b}</p>
+
+<!-- Sole child so the each block is controlled and the fast path applies. -->
+<div>
+	{#each items as item (item)}
+		<span>{item}</span>
+	{/each}
+</div>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/Child.svelte b/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/Child.svelte
new file mode 100644
index 0000000000..a49033a8cc
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/Child.svelte
@@ -0,0 +1,7 @@
+<script>
+	const { environment } = $props();
+
+	if (environment === 'client') {
+		throw new Error('oops');
+	}
+</script>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/_config.js b/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/_config.js
new file mode 100644
index 0000000000..29e470e46f
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/_config.js
@@ -0,0 +1,14 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['hydrate'],
+	server_props: { environment: 'server' },
+	props: { environment: 'client' },
+	ssrHtml: 'loading inner loading nested',
+
+	async test({ assert, target }) {
+		await tick();
+		assert.htmlEqual(target.innerHTML, 'inner failed: oops outer failed: oops');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/main.svelte
new file mode 100644
index 0000000000..16a54630d0
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-error-boundary-5/main.svelte
@@ -0,0 +1,24 @@
+<script>
+	import Child from './Child.svelte';
+
+	const { environment } = $props();
+</script>
+
+<svelte:boundary>
+	<Child {environment} />
+	{await new Promise(() => {})}
+
+	{#snippet pending()}loading inner{/snippet}
+	{#snippet failed(error)}inner failed: {error.message}{/snippet}
+</svelte:boundary>
+
+<svelte:boundary>
+	<svelte:boundary>
+		<Child {environment} />
+		{await new Promise(() => {})}
+
+		{#snippet pending()}loading nested{/snippet}
+	</svelte:boundary>
+
+	{#snippet failed(error)}outer failed: {error.message}{/snippet}
+</svelte:boundary>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-save-await-block-pending/_config.js b/packages/svelte/tests/runtime-runes/samples/async-save-await-block-pending/_config.js
new file mode 100644
index 0000000000..9608e294e7
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-save-await-block-pending/_config.js
@@ -0,0 +1,20 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['client'],
+	compileOptions: {
+		dev: true
+	},
+
+	async test({ assert, target, errors }) {
+		await new Promise((resolve) => setTimeout(resolve, 20));
+		await tick();
+
+		assert.deepEqual(
+			errors.filter((error) => error.includes('state_unsafe_mutation')),
+			[]
+		);
+		assert.htmlEqual(target.innerHTML, '<p>pending</p><p>1</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-save-await-block-pending/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-save-await-block-pending/main.svelte
new file mode 100644
index 0000000000..3545c69451
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-save-await-block-pending/main.svelte
@@ -0,0 +1,14 @@
+<script>
+	let foreign = $state(0);
+	const input = Promise.resolve({ pending: new Promise(() => {}) });
+
+	setTimeout(() => {
+		foreign += 1;
+	});
+</script>
+
+{#await (await input).pending}
+	<p>pending</p>
+{/await}
+
+<p>{foreign}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation-prod/_config.js b/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation-prod/_config.js
new file mode 100644
index 0000000000..050ee60e09
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation-prod/_config.js
@@ -0,0 +1,22 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['client'],
+
+	compileOptions: {
+		dev: false
+	},
+
+	async test({ assert, target, errors }) {
+		await tick();
+		await tick();
+		await tick();
+
+		assert.deepEqual(
+			errors.filter((error) => error.includes('state_unsafe_mutation')),
+			[]
+		);
+		assert.htmlEqual(target.innerHTML, '<p>4 1</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation-prod/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation-prod/main.svelte
new file mode 100644
index 0000000000..ef69eb1154
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation-prod/main.svelte
@@ -0,0 +1,20 @@
+<script>
+	let foreign = $state(0);
+
+	const items = Promise.resolve([1, 2, 3]);
+	const one = Promise.resolve(1);
+
+	// lands the write while the derived is suspended on `await one`, after the
+	// context restored for `.length` — in production that await has no dev hook
+	items.then(() => {
+		queueMicrotask(() => {
+			queueMicrotask(() => {
+				foreign += 1;
+			});
+		});
+	});
+
+	const total = $derived((await items).length + (await one));
+</script>
+
+<p>{total} {foreign}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation/_config.js b/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation/_config.js
new file mode 100644
index 0000000000..371cca3ff3
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation/_config.js
@@ -0,0 +1,21 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['client'],
+
+	compileOptions: {
+		dev: true
+	},
+
+	async test({ assert, target, errors }) {
+		await tick();
+		await tick();
+
+		assert.deepEqual(
+			errors.filter((error) => error.includes('state_unsafe_mutation')),
+			[]
+		);
+		assert.htmlEqual(target.innerHTML, '<p>3 1</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation/main.svelte
new file mode 100644
index 0000000000..c85206e7f1
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-save-foreign-microtask-mutation/main.svelte
@@ -0,0 +1,21 @@
+<script>
+	let foreign = $state(0);
+
+	const items = Promise.resolve([1, 2, 3]);
+
+	// registered before the derived, so it runs first when `items` settles.
+	// Two nested microtasks land the write in the window between the compiled
+	// continuation restoring the derived's context and svelte's queued unset
+	items.then(() => {
+		queueMicrotask(() => {
+			queueMicrotask(() => {
+				foreign += 1;
+			});
+		});
+	});
+
+	// `.length` follows the await, so the compiler pickles it via `$.save`
+	const length = $derived((await items).length);
+</script>
+
+<p>{length} {foreign}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-save-throwing-expression/_config.js b/packages/svelte/tests/runtime-runes/samples/async-save-throwing-expression/_config.js
new file mode 100644
index 0000000000..5999daa5d2
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-save-throwing-expression/_config.js
@@ -0,0 +1,20 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['client'],
+	compileOptions: {
+		dev: true
+	},
+
+	async test({ assert, target, errors }) {
+		await tick();
+		await tick();
+
+		assert.deepEqual(
+			errors.filter((error) => error.includes('state_unsafe_mutation')),
+			[]
+		);
+		assert.htmlEqual(target.innerHTML, '<p>failed</p><p>1</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-save-throwing-expression/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-save-throwing-expression/main.svelte
new file mode 100644
index 0000000000..e94bf86568
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-save-throwing-expression/main.svelte
@@ -0,0 +1,26 @@
+<script>
+	let foreign = $state(0);
+	const input = Promise.resolve({
+		get value() {
+			throw new Error('boom');
+		}
+	});
+
+	input.then(() => {
+		queueMicrotask(() => {
+			queueMicrotask(() => {
+				foreign += 1;
+			});
+		});
+	});
+</script>
+
+<svelte:boundary onerror={() => {}}>
+	{#snippet failed()}
+		<p>failed</p>
+	{/snippet}
+
+	<p>{(await input).value}</p>
+</svelte:boundary>
+
+<p>{foreign}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-store-sub-blocker/_config.js b/packages/svelte/tests/runtime-runes/samples/async-store-sub-blocker/_config.js
new file mode 100644
index 0000000000..896385e609
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-store-sub-blocker/_config.js
@@ -0,0 +1,14 @@
+import { tick } from 'svelte';
+import { test } from '../../test';
+
+// Tests that a store subscription only present in the template waits for the
+// promise that assigns the store instead of subscribing to `undefined`,
+// including when the subscription is read through a function.
+export default test({
+	mode: ['client', 'hydrate', 'async-server'],
+	ssrHtml: '<p>hello</p> <p>hello</p>',
+	async test({ assert, target }) {
+		await tick();
+		assert.htmlEqual(target.innerHTML, '<p>hello</p> <p>hello</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-store-sub-blocker/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-store-sub-blocker/main.svelte
new file mode 100644
index 0000000000..04c707c66d
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-store-sub-blocker/main.svelte
@@ -0,0 +1,16 @@
+<script>
+	import { writable } from 'svelte/store';
+
+	async function get_store() {
+		return writable('hello');
+	}
+
+	const store = await get_store();
+
+	function read() {
+		return $store;
+	}
+</script>
+
+<p>{$store}</p>
+<p>{read()}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/_config.js b/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/_config.js
new file mode 100644
index 0000000000..ac60694648
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/_config.js
@@ -0,0 +1,18 @@
+import { test } from '../../test';
+import { counts, reset } from './store.js';
+
+// A blocked store subscription is created after the synchronous part of the
+// render has finished, so the teardown must wait for the async work.
+export default test({
+	mode: ['async-server'],
+
+	before_test() {
+		reset();
+	},
+
+	ssrHtml: '<p>hello</p>',
+
+	test_ssr({ assert }) {
+		assert.deepEqual(counts, { subscribes: 1, unsubscribes: 1 });
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/main.svelte b/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/main.svelte
new file mode 100644
index 0000000000..8d17e701d3
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/main.svelte
@@ -0,0 +1,11 @@
+<script>
+	import { store } from './store.js';
+
+	async function get_store() {
+		return store;
+	}
+
+	const s = await get_store();
+</script>
+
+<p>{$s}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/store.js b/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/store.js
new file mode 100644
index 0000000000..4922c1b027
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/async-store-sub-teardown/store.js
@@ -0,0 +1,23 @@
+import { writable } from 'svelte/store';
+
+export const counts = { subscribes: 0, unsubscribes: 0 };
+
+const inner = writable('hello');
+
+export const store = {
+	/** @param {(value: string) => void} fn */
+	subscribe(fn) {
+		counts.subscribes += 1;
+		const unsubscribe = inner.subscribe(fn);
+
+		return () => {
+			counts.unsubscribes += 1;
+			unsubscribe();
+		};
+	}
+};
+
+export function reset() {
+	counts.subscribes = 0;
+	counts.unsubscribes = 0;
+}
diff --git a/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/Child.svelte b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/Child.svelte
new file mode 100644
index 0000000000..2eb83744c4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/Child.svelte
@@ -0,0 +1,7 @@
+<script>
+	import { items } from './data.js';
+
+	export const myArr = items;
+</script>
+
+<p>child</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/_config.js b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/_config.js
new file mode 100644
index 0000000000..daf97f7da6
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/_config.js
@@ -0,0 +1,15 @@
+import { test } from '../../test';
+import { items } from './data.js';
+
+export default test({
+	compileOptions: {
+		dev: true
+	},
+
+	html: `<p>child</p>`,
+
+	test({ assert, instance }) {
+		// ensure component instance doesn't get proxified (https://github.com/sveltejs/svelte/issues/18416)
+		assert.ok(instance.get_first().myArr === items);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/data.js b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/data.js
new file mode 100644
index 0000000000..06c15d09e4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/data.js
@@ -0,0 +1 @@
+export const items = [{ id: 5, name: 'John' }];
diff --git a/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/main.svelte b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/main.svelte
new file mode 100644
index 0000000000..5f5ecddab2
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state-dev/main.svelte
@@ -0,0 +1,11 @@
+<script>
+	import Child from './Child.svelte';
+
+	const components = $state({});
+
+	export function get_first() {
+		return components.first;
+	}
+</script>
+
+<Child bind:this={components.first} />
diff --git a/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/Child.svelte b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/Child.svelte
new file mode 100644
index 0000000000..2eb83744c4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/Child.svelte
@@ -0,0 +1,7 @@
+<script>
+	import { items } from './data.js';
+
+	export const myArr = items;
+</script>
+
+<p>child</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/_config.js b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/_config.js
new file mode 100644
index 0000000000..e845e6932e
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/_config.js
@@ -0,0 +1,11 @@
+import { test } from '../../test';
+import { items } from './data.js';
+
+export default test({
+	html: `<p>child</p>`,
+
+	test({ assert, instance }) {
+		// ensure component instance doesn't get proxified (https://github.com/sveltejs/svelte/issues/18416)
+		assert.ok(instance.get_first().myArr === items);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/data.js b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/data.js
new file mode 100644
index 0000000000..06c15d09e4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/data.js
@@ -0,0 +1 @@
+export const items = [{ id: 5, name: 'John' }];
diff --git a/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/main.svelte b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/main.svelte
new file mode 100644
index 0000000000..5f5ecddab2
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/bind-this-component-in-state/main.svelte
@@ -0,0 +1,11 @@
+<script>
+	import Child from './Child.svelte';
+
+	const components = $state({});
+
+	export function get_first() {
+		return components.first;
+	}
+</script>
+
+<Child bind:this={components.first} />
diff --git a/packages/svelte/tests/runtime-runes/samples/class-directive-memoize/_config.js b/packages/svelte/tests/runtime-runes/samples/class-directive-memoize/_config.js
new file mode 100644
index 0000000000..964993787f
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/class-directive-memoize/_config.js
@@ -0,0 +1,37 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+// This test counts mutations on hydration
+// set_style() should not mutate style on hydration, except if mismatch
+export default test({
+	mode: ['server', 'hydrate', 'client'],
+
+	ssrHtml: `
+		<button>click</button>
+		<div class="red"></div>
+	`,
+
+	html: `
+		<button>click</button>
+		<div class="red"></div>
+	`,
+
+	test({ target, assert, logs }) {
+		flushSync();
+
+		assert.deepEqual(logs, ['is_red()']);
+
+		const btn = target.querySelector('button');
+		const div = target.querySelector('div');
+
+		assert.equal(div?.className, 'red');
+
+		btn?.click();
+
+		flushSync();
+
+		assert.equal(div?.className, 'red active');
+		// only one call here
+		assert.deepEqual(logs, ['is_red()']);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/class-directive-memoize/main.svelte b/packages/svelte/tests/runtime-runes/samples/class-directive-memoize/main.svelte
new file mode 100644
index 0000000000..3a6d02e626
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/class-directive-memoize/main.svelte
@@ -0,0 +1,10 @@
+<script>
+    function is_red() {
+        console.log("is_red()");
+        return "red";
+    }
+
+    let active = $state(false);
+</script>
+<button onclick={() => active = true}>click</button>
+<div class:red={is_red()} class:active></div>
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/class-private-fields-logical-assignment/_config.js b/packages/svelte/tests/runtime-runes/samples/class-private-fields-logical-assignment/_config.js
new file mode 100644
index 0000000000..d919c18396
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/class-private-fields-logical-assignment/_config.js
@@ -0,0 +1,5 @@
+import { test } from '../../test';
+
+export default test({
+	html: `<p>truthy||value</p>`
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/class-private-fields-logical-assignment/main.svelte b/packages/svelte/tests/runtime-runes/samples/class-private-fields-logical-assignment/main.svelte
new file mode 100644
index 0000000000..cc74150b35
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/class-private-fields-logical-assignment/main.svelte
@@ -0,0 +1,24 @@
+<script>
+	class Values {
+		#or = $state.raw('truthy');
+		#and = $state.raw('');
+		#nullish = $state.raw('value');
+
+		get or() {
+			return (this.#or ||= 'assigned');
+		}
+
+		get and() {
+			return (this.#and &&= 'assigned');
+		}
+
+		get nullish() {
+			return (this.#nullish ??= 'assigned');
+		}
+	}
+
+	const values = new Values();
+	const result = $derived([values.or, values.and, values.nullish]);
+</script>
+
+<p>{result.join('|')}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/class-private-state-increment-other-receiver/_config.js b/packages/svelte/tests/runtime-runes/samples/class-private-state-increment-other-receiver/_config.js
new file mode 100644
index 0000000000..8f023b602a
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/class-private-state-increment-other-receiver/_config.js
@@ -0,0 +1,22 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	html: `<button>1</button><button>drop</button>`,
+
+	test({ assert, target }) {
+		const [bump, drop] = target.querySelectorAll('button');
+
+		bump?.click();
+		flushSync();
+		assert.htmlEqual(target.innerHTML, `<button>2</button><button>drop</button>`);
+
+		bump?.click();
+		flushSync();
+		assert.htmlEqual(target.innerHTML, `<button>3</button><button>drop</button>`);
+
+		drop?.click();
+		flushSync();
+		assert.htmlEqual(target.innerHTML, `<button>2</button><button>drop</button>`);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/class-private-state-increment-other-receiver/main.svelte b/packages/svelte/tests/runtime-runes/samples/class-private-state-increment-other-receiver/main.svelte
new file mode 100644
index 0000000000..67827aceee
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/class-private-state-increment-other-receiver/main.svelte
@@ -0,0 +1,23 @@
+<script>
+	class Counter {
+		#count = $state(1);
+
+		bump(other) {
+			other.#count++;
+		}
+
+		drop(other) {
+			--other.#count;
+		}
+
+		getCount() {
+			return this.#count;
+		}
+	}
+
+	const a = new Counter();
+	const b = new Counter();
+</script>
+
+<button onclick={() => a.bump(b)}>{b.getCount()}</button>
+<button onclick={() => a.drop(b)}>drop</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/Component.svelte b/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/Component.svelte
new file mode 100644
index 0000000000..0fd9beb678
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/Component.svelte
@@ -0,0 +1 @@
+<div>Hello</div>
diff --git a/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/_config.js b/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/_config.js
new file mode 100644
index 0000000000..78b14775e5
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/_config.js
@@ -0,0 +1,12 @@
+import { test } from '../../test';
+
+export default test({
+	ssrHtml: `<svelte-css-wrapper style="display: contents; --zero: 0; --one: 1;"><div>Hello</div></svelte-css-wrapper>`,
+
+	async test({ assert, target }) {
+		assert.htmlEqual(
+			target.innerHTML,
+			`<svelte-css-wrapper style="display: contents; --zero: 0; --one: 1;"><div>Hello</div></svelte-css-wrapper>`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/main.svelte b/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/main.svelte
new file mode 100644
index 0000000000..30c029b547
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/component-css-props-falsy/main.svelte
@@ -0,0 +1,5 @@
+<script>
+	import Component from './Component.svelte';
+</script>
+
+<Component --zero={0} --one={1} --empty={''} --nullish={null} />
diff --git a/packages/svelte/tests/runtime-runes/samples/declaration-tags-each/_config.js b/packages/svelte/tests/runtime-runes/samples/declaration-tags-each/_config.js
new file mode 100644
index 0000000000..d5cdd103b5
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/declaration-tags-each/_config.js
@@ -0,0 +1,10 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ target, assert }) {
+		const [btn1, btn2] = target.querySelectorAll('button');
+		flushSync(() => btn2.click());
+		assert.equal(btn1.textContent, '1');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/declaration-tags-each/main.svelte b/packages/svelte/tests/runtime-runes/samples/declaration-tags-each/main.svelte
new file mode 100644
index 0000000000..04d55913b4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/declaration-tags-each/main.svelte
@@ -0,0 +1,6 @@
+{#each Array(1)}
+	{let ref = $state()}
+	{let count = $state(0)}
+	<button onclick={()=>count++} bind:this={ref}>{count}</button>
+	<button onclick={()=>ref.click()}></button>
+{/each}
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/derived-destructured-from-derived/_config.js b/packages/svelte/tests/runtime-runes/samples/derived-destructured-from-derived/_config.js
new file mode 100644
index 0000000000..a36c2adf7d
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/derived-destructured-from-derived/_config.js
@@ -0,0 +1,5 @@
+import { test } from '../../test';
+
+export default test({
+	html: `<button>3</button>`
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/derived-destructured-from-derived/main.svelte b/packages/svelte/tests/runtime-runes/samples/derived-destructured-from-derived/main.svelte
new file mode 100644
index 0000000000..b1882243f4
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/derived-destructured-from-derived/main.svelte
@@ -0,0 +1,8 @@
+<script>
+	let name = $state('foo');
+	const foo = $derived(name);
+	const { length } = $derived(foo);
+</script>
+
+<!-- only needed to prevent constant folding, never run -->
+<button onclick={() => (name = 'longer')}>{length}</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/derived-leading-comments/_config.js b/packages/svelte/tests/runtime-runes/samples/derived-leading-comments/_config.js
new file mode 100644
index 0000000000..2048fbadf7
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/derived-leading-comments/_config.js
@@ -0,0 +1,6 @@
+import { test } from '../../test';
+
+export default test({
+	ssrHtml: '<p>y:y</p> <p>LATER</p> <input value="LATER">',
+	html: '<p>y:y</p> <p>LATER</p> <input>'
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/derived-leading-comments/main.svelte b/packages/svelte/tests/runtime-runes/samples/derived-leading-comments/main.svelte
new file mode 100644
index 0000000000..0424d3fb15
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/derived-leading-comments/main.svelte
@@ -0,0 +1,24 @@
+<script>
+	function write(value) {
+		return foo = value;
+	}
+
+	// a leading comment on the declaration
+	// that spans more than one line
+	let foo = $derived('x');
+	let bar = write('y');
+
+	const ctx = {
+		get later() {
+			return later;
+		}
+	};
+
+	// a leading comment on the declaration
+	// that spans more than one line
+	let later = $derived.by(() => 'LATER');
+</script>
+
+<p>{foo}:{bar}</p>
+<p>{ctx.later}</p>
+<input bind:value={later} />
diff --git a/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/Child.svelte b/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/Child.svelte
new file mode 100644
index 0000000000..35544d0a55
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/Child.svelte
@@ -0,0 +1,7 @@
+<script>
+	let { labelKey, valueKey, options } = $props();
+</script>
+
+{#each options as { [labelKey]: label, [valueKey]: value } (value)}
+	<p>{label}: {value}</p>
+{/each}
diff --git a/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/_config.js b/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/_config.js
new file mode 100644
index 0000000000..8a8789d712
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/_config.js
@@ -0,0 +1,29 @@
+import { flushSync } from 'svelte';
+import { ok, test } from '../../test';
+
+// https://github.com/sveltejs/svelte/issues/18519
+export default test({
+	html: `
+		<button>reverse</button>
+		<p>1: a1</p>
+		<p>2: a2</p>
+		<p>3: a3</p>
+	`,
+
+	test({ assert, target }) {
+		const btn = target.querySelector('button');
+		ok(btn);
+
+		flushSync(() => btn.click());
+
+		assert.htmlEqual(
+			target.innerHTML,
+			`
+				<button>reverse</button>
+				<p>3: a3</p>
+				<p>2: a2</p>
+				<p>1: a1</p>
+			`
+		);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/main.svelte b/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/main.svelte
new file mode 100644
index 0000000000..6885a6918e
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/each-keyed-computed-destructuring-key/main.svelte
@@ -0,0 +1,12 @@
+<script>
+	import Child from './Child.svelte';
+
+	let options = $state([
+		{ a: 1, v: 'a1' },
+		{ a: 2, v: 'a2' },
+		{ a: 3, v: 'a3' }
+	]);
+</script>
+
+<button onclick={() => options.reverse()}>reverse</button>
+<Child {options} labelKey="a" valueKey="v" />
diff --git a/packages/svelte/tests/runtime-runes/samples/effect-teardown-multiple-writes/_config.js b/packages/svelte/tests/runtime-runes/samples/effect-teardown-multiple-writes/_config.js
new file mode 100644
index 0000000000..7db4966106
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/effect-teardown-multiple-writes/_config.js
@@ -0,0 +1,17 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target, logs }) {
+		const button = target.querySelector('button');
+
+		flushSync(() => button?.click());
+
+		assert.deepEqual(logs, [
+			'register: one',
+			'unregister: one',
+			'leftover: none',
+			'register: three'
+		]);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/effect-teardown-multiple-writes/main.svelte b/packages/svelte/tests/runtime-runes/samples/effect-teardown-multiple-writes/main.svelte
new file mode 100644
index 0000000000..a3932aaa22
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/effect-teardown-multiple-writes/main.svelte
@@ -0,0 +1,21 @@
+<script>
+	let value = $state('one');
+
+	const registry = new Set();
+
+	$effect(() => {
+		registry.add(value);
+		console.log(`register: ${value}`);
+
+		return () => {
+			registry.delete(value);
+			console.log(`unregister: ${value}`);
+			console.log(`leftover: ${[...registry].join(', ') || 'none'}`);
+		};
+	});
+</script>
+
+<button onclick={() => {
+	value = 'two';
+	value = 'three';
+}}>go</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-28/Trigger.svelte b/packages/svelte/tests/runtime-runes/samples/error-boundary-28/Trigger.svelte
new file mode 100644
index 0000000000..46b4bd1c30
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-28/Trigger.svelte
@@ -0,0 +1,12 @@
+<script>
+	let { getValue } = $props();
+
+	// Reads reactive state during teardown
+	$effect(() => {
+		return () => {
+			getValue();
+		};
+	});
+</script>
+
+<span>trigger</span>
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-28/_config.js b/packages/svelte/tests/runtime-runes/samples/error-boundary-28/_config.js
new file mode 100644
index 0000000000..4802089124
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-28/_config.js
@@ -0,0 +1,23 @@
+import { flushSync, tick } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	// Regression test for https://github.com/sveltejs/svelte/issues/18485.
+	// A $derived that re-executes and throws during teardown should route the
+	// error to a live ancestor boundary.
+	mode: ['client'],
+	async test({ assert, target }) {
+		const [break_it, unmount] = target.querySelectorAll('button');
+
+		break_it.click();
+		flushSync();
+
+		assert.doesNotThrow(() => {
+			unmount.click();
+			flushSync();
+		});
+
+		await tick();
+		assert.htmlEqual(target.innerHTML, '<p>caught</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-28/main.svelte b/packages/svelte/tests/runtime-runes/samples/error-boundary-28/main.svelte
new file mode 100644
index 0000000000..e100be2169
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-28/main.svelte
@@ -0,0 +1,24 @@
+<script>
+	import Trigger from './Trigger.svelte';
+
+	let mounted = $state(true);
+	let broken = $state(false);
+
+	// Throwing derived — nothing in the live template reads `appContext`, so
+	// invalidating it does NOT throw immediately (becomes dirty-and-unread).
+	let data = $derived(broken ? null : { value: 'ok' });
+	let appContext = $derived(data.value);
+</script>
+
+<svelte:boundary>
+	<button onclick={() => (broken = true)}>break</button>
+	<button onclick={() => (mounted = false)}>unmount</button>
+
+	{#if mounted}
+		<Trigger getValue={() => appContext} />
+	{/if}
+
+	{#snippet failed()}
+		<p>caught</p>
+	{/snippet}
+</svelte:boundary>
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/_config.js b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/_config.js
new file mode 100644
index 0000000000..f0aef7e92f
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/_config.js
@@ -0,0 +1,19 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['hydrate'],
+	ssrHtml: '<p>failed: error</p> <button>reset</button>',
+	transformError: () => 'error',
+
+	test({ assert, target, logs }) {
+		// `onerror` is called upon hydration with the deserialized error
+		assert.deepEqual(logs, ['onerror: error']);
+
+		const btn = target.querySelector('button');
+		btn?.click();
+		flushSync();
+
+		assert.htmlEqual(target.innerHTML, '<p>recovered</p> <button>reset</button>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/child.svelte b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/child.svelte
new file mode 100644
index 0000000000..e93c7bb0fa
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/child.svelte
@@ -0,0 +1,3 @@
+<script>
+	throw new Error('unlucky');
+</script>
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/main.svelte b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/main.svelte
new file mode 100644
index 0000000000..e84198473b
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-1/main.svelte
@@ -0,0 +1,29 @@
+<script>
+	import Child from './child.svelte';
+
+	let recovered = $state(false);
+	let reset_fn = $state();
+</script>
+
+<svelte:boundary
+	onerror={(error, reset) => {
+		console.log(`onerror: ${error}`);
+		reset_fn = reset;
+	}}
+>
+	{#if recovered}
+		<p>recovered</p>
+	{:else}
+		<Child />
+	{/if}
+
+	{#snippet failed(error)}
+		<p>failed: {error}</p>
+	{/snippet}
+</svelte:boundary>
+
+<button
+	onclick={() => {
+		recovered = true;
+		reset_fn();
+	}}>reset</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/_config.js b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/_config.js
new file mode 100644
index 0000000000..e5c52eb19c
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/_config.js
@@ -0,0 +1,16 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['hydrate'],
+	ssrHtml: '<p>failed: error</p> <button>reset</button>',
+	transformError: () => 'error',
+
+	test({ assert, target }) {
+		const btn = target.querySelector('button');
+		btn?.click();
+		flushSync();
+
+		assert.htmlEqual(target.innerHTML, '<p>recovered</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/child.svelte b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/child.svelte
new file mode 100644
index 0000000000..e93c7bb0fa
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/child.svelte
@@ -0,0 +1,3 @@
+<script>
+	throw new Error('unlucky');
+</script>
diff --git a/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/main.svelte b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/main.svelte
new file mode 100644
index 0000000000..1642a94e7a
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/error-boundary-hydrate-2/main.svelte
@@ -0,0 +1,22 @@
+<script>
+	import Child from './child.svelte';
+
+	let recovered = $state(false);
+</script>
+
+<svelte:boundary>
+	{#if recovered}
+		<p>recovered</p>
+	{:else}
+		<Child />
+	{/if}
+
+	{#snippet failed(error, reset)}
+		<p>failed: {error}</p>
+		<button
+			onclick={() => {
+				recovered = true;
+				reset();
+			}}>reset</button>
+	{/snippet}
+</svelte:boundary>
diff --git a/packages/svelte/tests/runtime-runes/samples/event-attribute-spread-update/_config.js b/packages/svelte/tests/runtime-runes/samples/event-attribute-spread-update/_config.js
index af03eed4c9..5fbd37c768 100644
--- a/packages/svelte/tests/runtime-runes/samples/event-attribute-spread-update/_config.js
+++ b/packages/svelte/tests/runtime-runes/samples/event-attribute-spread-update/_config.js
@@ -3,16 +3,31 @@ import { test } from '../../test';
 
 export default test({
 	test({ assert, target }) {
-		const [change, increment] = target.querySelectorAll('button');
+		const [change, remove, increment] = target.querySelectorAll('button');
 
 		increment.click();
 		flushSync();
-		assert.htmlEqual(target.innerHTML, '<button>change handlers</button><button>1 / 1</button>');
+		assert.htmlEqual(
+			target.innerHTML,
+			'<button>change handlers</button><button>remove capture handler</button><button>1 / 1</button>'
+		);
 
 		change.click();
 		flushSync();
 		increment.click();
 		flushSync();
-		assert.htmlEqual(target.innerHTML, '<button>change handlers</button><button>3 / 3</button>');
+		assert.htmlEqual(
+			target.innerHTML,
+			'<button>change handlers</button><button>remove capture handler</button><button>3 / 3</button>'
+		);
+
+		remove.click();
+		flushSync();
+		increment.click();
+		flushSync();
+		assert.htmlEqual(
+			target.innerHTML,
+			'<button>change handlers</button><button>remove capture handler</button><button>5 / 3</button>'
+		);
 	}
 });
diff --git a/packages/svelte/tests/runtime-runes/samples/event-attribute-spread-update/main.svelte b/packages/svelte/tests/runtime-runes/samples/event-attribute-spread-update/main.svelte
index 32d4b242cc..ee049e469c 100644
--- a/packages/svelte/tests/runtime-runes/samples/event-attribute-spread-update/main.svelte
+++ b/packages/svelte/tests/runtime-runes/samples/event-attribute-spread-update/main.svelte
@@ -24,4 +24,7 @@
 >
 	change handlers
 </button>
+<button onclick={() => (attrs = { onclick: attrs.onclick, onclickcapture: undefined })}>
+	remove capture handler
+</button>
 <button {...attrs}>{delegated} / {non_delegated}</button>
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-checked-radio-spread/_config.js b/packages/svelte/tests/runtime-runes/samples/form-default-checked-radio-spread/_config.js
new file mode 100644
index 0000000000..3f3134ee7a
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-checked-radio-spread/_config.js
@@ -0,0 +1,23 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+export default test({
+	mode: ['hydrate'],
+
+	async test({ assert, target }) {
+		const [a, b, reset] = target.querySelectorAll('input');
+
+		// let the deferred hydration cleanup run
+		await Promise.resolve();
+		flushSync();
+
+		b.checked = true;
+		reset.click();
+		await Promise.resolve();
+		flushSync();
+
+		assert.equal(a.defaultChecked, true);
+		assert.equal(a.checked, true);
+		assert.equal(b.checked, false);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-checked-radio-spread/main.svelte b/packages/svelte/tests/runtime-runes/samples/form-default-checked-radio-spread/main.svelte
new file mode 100644
index 0000000000..cb7ff0abd3
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-checked-radio-spread/main.svelte
@@ -0,0 +1,9 @@
+<script>
+	let spread = { defaultChecked: true, checked: true };
+</script>
+
+<form>
+	<input type="radio" name="option" value="a" {...spread} />
+	<input type="radio" name="option" value="b" />
+	<input type="reset" value="Reset" />
+</form>
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-value-select/_config.js b/packages/svelte/tests/runtime-runes/samples/form-default-value-select/_config.js
new file mode 100644
index 0000000000..5d0c964969
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-value-select/_config.js
@@ -0,0 +1,96 @@
+import { test } from '../../test';
+import { flushSync } from 'svelte';
+
+export default test({
+	async test({ assert, target }) {
+		/** @param {HTMLSelectElement} select @param {boolean[]} expected */
+		function check(select, expected) {
+			assert.deepEqual(
+				[...select.options].map((option) => option.selected),
+				expected
+			);
+		}
+
+		/** @param {HTMLSelectElement} select @param {number[]} indexes */
+		function select(select, indexes) {
+			for (let i = 0; i < select.options.length; i++) {
+				select.options[i].selected = indexes.includes(i);
+			}
+			select.dispatchEvent(new Event('change', { bubbles: true }));
+		}
+
+		const selects = target.querySelectorAll('select');
+		const reset = /** @type {HTMLInputElement} */ (target.querySelector('input[type=reset]'));
+		/** @param {string} name */
+		const button = (name) => /** @type {HTMLButtonElement} */ (target.querySelector(`.${name}`));
+
+		check(selects[0], [false, true, false]);
+		check(selects[1], [false, false, true]);
+		check(selects[2], [false, true, false]);
+		check(selects[3], [true]);
+		check(selects[4], [false, true]);
+		check(selects[5], [false, true, false]);
+		check(selects[6], [true, false]);
+		check(selects[7], [true, false, true]);
+		check(selects[8], [false, false, true]);
+
+		select(selects[0], [2]);
+		select(selects[1], [0]);
+		select(selects[5], [2]);
+		select(selects[7], [1]);
+		flushSync();
+
+		reset.click();
+		await Promise.resolve();
+		flushSync();
+		check(selects[0], [false, true, false]);
+		check(selects[1], [false, true, false]);
+		check(selects[5], [false, true, false]);
+		check(selects[7], [true, false, true]);
+
+		select(selects[2], [2]);
+		select(selects[5], [2]);
+		button('update').click();
+		flushSync();
+		check(selects[2], [false, false, true]);
+		check(selects[5], [false, false, true]);
+		assert.deepEqual(
+			[...selects[5].options].map((option) => option.defaultSelected),
+			[true, false, false]
+		);
+
+		button('add').click();
+		flushSync();
+		await Promise.resolve();
+		check(selects[3], [true, false]);
+		assert.equal(selects[3].options[1].defaultSelected, true);
+
+		reset.click();
+		await Promise.resolve();
+		flushSync();
+		check(selects[0], [true, false, false]);
+		check(selects[2], [true, false, false]);
+		check(selects[3], [false, true]);
+		check(selects[5], [true, false, false]);
+
+		select(selects[5], [2]);
+		select(selects[7], [1]);
+		button('remove').click();
+		button('clear').click();
+		flushSync();
+		assert.equal(
+			[...selects[5].options].some((option) => option.defaultSelected),
+			false
+		);
+		assert.equal(
+			[...selects[7].options].some((option) => option.defaultSelected),
+			false
+		);
+
+		reset.click();
+		await Promise.resolve();
+		flushSync();
+		check(selects[5], [true, false, false]);
+		check(selects[7], [false, false, false]);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/form-default-value-select/main.svelte b/packages/svelte/tests/runtime-runes/samples/form-default-value-select/main.svelte
new file mode 100644
index 0000000000..daa1f9ceee
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/form-default-value-select/main.svelte
@@ -0,0 +1,79 @@
+<script>
+	let selected1 = $state();
+	let selected2 = $state('c');
+	let selected3 = $state();
+	let selected4 = $state(['c']);
+	let defaultValue = $state('b');
+	let multipleDefault = $state(/** @type {string[] | undefined} */ (['a', 'c']));
+	let options = $state(['a']);
+	let props = $state({ defaultValue: 'b' });
+</script>
+
+<form>
+	<select {defaultValue} bind:value={selected1}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<select {defaultValue} bind:value={selected2}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<select {defaultValue}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<select defaultValue="b">
+		{#each options as option}
+			<option value={option}>{option}</option>
+		{/each}
+	</select>
+
+	<select defaultvalue="b">
+		<option value="a">A</option>
+		<option value="b">B</option>
+	</select>
+
+	<select {...props} bind:value={selected3}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<select {...{ defaultValue: 'b' }} defaultValue="a">
+		<option value="a">A</option>
+		<option value="b">B</option>
+	</select>
+
+	<select multiple defaultValue={multipleDefault}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<select multiple defaultValue={multipleDefault} bind:value={selected4}>
+		<option value="a">A</option>
+		<option value="b">B</option>
+		<option value="c">C</option>
+	</select>
+
+	<input type="reset" value="Reset" />
+	<button
+		type="button"
+		class="update"
+		onclick={() => {
+			defaultValue = 'a';
+			props.defaultValue = 'a';
+		}}>Update defaults</button
+	>
+	<button type="button" class="add" onclick={() => options.push('b')}>Add option</button>
+	<button type="button" class="remove" onclick={() => delete props.defaultValue}>Remove default</button>
+	<button type="button" class="clear" onclick={() => (multipleDefault = undefined)}>Clear defaults</button>
+</form>
+
+<p>{selected1} {selected2} {selected3} {selected4.join(',')}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/Component.svelte b/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/Component.svelte
new file mode 100644
index 0000000000..85b608c739
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/Component.svelte
@@ -0,0 +1,5 @@
+<script>
+	const { text } = $props();
+</script>
+
+<span id="prop">{text}</span>
diff --git a/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/_config.js b/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/_config.js
new file mode 100644
index 0000000000..f6befd7703
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/_config.js
@@ -0,0 +1,15 @@
+import { test } from '../../test';
+
+export default test({
+	async test({ assert, target }) {
+		// a line feed entity in an attribute value stays a line feed...
+		assert.equal(target.querySelector('#attr')?.getAttribute('title'), 'A\nB');
+		assert.equal(target.querySelector('#attr-decimal')?.getAttribute('title'), 'A\nB');
+
+		// ...including when the attribute is a prop passed to a component
+		assert.equal(target.querySelector('#prop')?.textContent, 'A\nB');
+
+		// other entities in attribute values still decode
+		assert.equal(target.querySelector('#attr-other-entity')?.getAttribute('title'), '©');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/main.svelte b/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/main.svelte
new file mode 100644
index 0000000000..d7f5684351
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/html-entity-line-feed/main.svelte
@@ -0,0 +1,9 @@
+<script>
+	import Component from './Component.svelte';
+</script>
+
+<span id="attr" title="A&#x0A;B"></span>
+<span id="attr-decimal" title="A&#10;B"></span>
+<span id="attr-other-entity" title="&copy;"></span>
+
+<Component text="A&#x0A;B" />
diff --git a/packages/svelte/tests/runtime-runes/samples/labeled-statement-derived/_config.js b/packages/svelte/tests/runtime-runes/samples/labeled-statement-derived/_config.js
new file mode 100644
index 0000000000..3507fb4707
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/labeled-statement-derived/_config.js
@@ -0,0 +1,5 @@
+import { test } from '../../test';
+
+export default test({
+	html: '<p>correct</p>'
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/labeled-statement-derived/main.svelte b/packages/svelte/tests/runtime-runes/samples/labeled-statement-derived/main.svelte
new file mode 100644
index 0000000000..87cf8483f1
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/labeled-statement-derived/main.svelte
@@ -0,0 +1,8 @@
+<script>
+	let value = $derived(false);
+	let result = 'correct';
+
+	label: if (value) result = 'wrong';
+</script>
+
+<p>{result}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/Item.svelte b/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/Item.svelte
new file mode 100644
index 0000000000..7beabf6124
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/Item.svelte
@@ -0,0 +1,6 @@
+<script>
+	let { item } = $props();
+</script>
+
+<!-- svelte-ignore ownership_invalid_mutation -->
+<input bind:value={item.heading} />
diff --git a/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/_config.js b/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/_config.js
new file mode 100644
index 0000000000..11229fd13e
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/_config.js
@@ -0,0 +1,22 @@
+import { flushSync } from 'svelte';
+import { ok, test } from '../../test';
+
+export default test({
+	mode: ['client'],
+	compileOptions: {
+		dev: true
+	},
+	test({ assert, target, warnings }) {
+		const input = target.querySelector('input');
+		const output = target.querySelector('p');
+		ok(input);
+		ok(output);
+
+		input.value = 'renamed';
+		input.dispatchEvent(new Event('input', { bubbles: true }));
+		flushSync();
+
+		assert.equal(output.textContent, 'renamed');
+		assert.deepEqual(warnings, []);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/main.svelte b/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/main.svelte
new file mode 100644
index 0000000000..e5b926cb9c
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/ownership-invalid-mutation-binding-ignore/main.svelte
@@ -0,0 +1,8 @@
+<script>
+	import Item from './Item.svelte';
+
+	let item = $state({ heading: 'initial' });
+</script>
+
+<Item {item} />
+<p>{item.heading}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/select-function-binding-derived/_config.js b/packages/svelte/tests/runtime-runes/samples/select-function-binding-derived/_config.js
new file mode 100644
index 0000000000..13b7302cee
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/select-function-binding-derived/_config.js
@@ -0,0 +1,9 @@
+import { test } from '../../test';
+
+export default test({
+	ssrHtml: '<select><option value="a">a</option><option value="b" selected="">b</option></select>',
+	test({ assert, target }) {
+		const select = /** @type {HTMLSelectElement} */ (target.querySelector('select'));
+		assert.equal(select.value, 'b');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/select-function-binding-derived/main.svelte b/packages/svelte/tests/runtime-runes/samples/select-function-binding-derived/main.svelte
new file mode 100644
index 0000000000..2c14566193
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/select-function-binding-derived/main.svelte
@@ -0,0 +1,9 @@
+<script>
+	let source = $state('b');
+	let value = $derived(source);
+</script>
+
+<select bind:value={() => value, (next) => (value = next)}>
+	<option value="a">a</option>
+	<option value="b">b</option>
+</select>
diff --git a/packages/svelte/tests/runtime-runes/samples/state-snapshot-svelte-date/_config.js b/packages/svelte/tests/runtime-runes/samples/state-snapshot-svelte-date/_config.js
new file mode 100644
index 0000000000..53d8e1d4ff
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/state-snapshot-svelte-date/_config.js
@@ -0,0 +1,13 @@
+import { test } from '../../test';
+import { tick } from 'svelte';
+
+export default test({
+	async test({ assert, target }) {
+		assert.htmlEqual(target.innerHTML, '<button>update</button><p>1970-01-01T00:00:00.000Z</p>');
+
+		target.querySelector('button')?.click();
+		await tick();
+
+		assert.htmlEqual(target.innerHTML, '<button>update</button><p>1970-01-02T00:00:00.000Z</p>');
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/state-snapshot-svelte-date/main.svelte b/packages/svelte/tests/runtime-runes/samples/state-snapshot-svelte-date/main.svelte
new file mode 100644
index 0000000000..634a7ee3e8
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/state-snapshot-svelte-date/main.svelte
@@ -0,0 +1,9 @@
+<script>
+	import { SvelteDate } from 'svelte/reactivity';
+
+	const date = new SvelteDate(0);
+	const snapshot = $derived($state.snapshot(date));
+</script>
+
+<button onclick={() => date.setTime(86400000)}>update</button>
+<p>{snapshot.toISOString()}</p>
diff --git a/packages/svelte/tests/runtime-runes/samples/style-directive-memoize/_config.js b/packages/svelte/tests/runtime-runes/samples/style-directive-memoize/_config.js
new file mode 100644
index 0000000000..5638a8ee13
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/style-directive-memoize/_config.js
@@ -0,0 +1,42 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+// This test counts mutations on hydration
+// set_style() should not mutate style on hydration, except if mismatch
+export default test({
+	mode: ['server', 'hydrate', 'client'],
+
+	ssrHtml: `
+		<button>click</button>
+		<div style="background-color: red; font-size: 1em;"></div>
+	`,
+
+	html: `
+		<button>click</button>
+		<div style="background-color: red; font-size: 1em;"></div>
+	`,
+
+	test({ target, assert, logs }) {
+		flushSync();
+
+		assert.deepEqual(logs, ['makeColor()']);
+
+		const btn = target.querySelector('button');
+		const div = target.querySelector('div');
+
+		// Note : we cannot compare HTML because set_style() use dom.style.cssText
+		// which can alter the format of the attribute...
+
+		assert.equal(div?.style.backgroundColor, 'red');
+		assert.equal(div?.style.fontSize, '1em');
+
+		btn?.click();
+
+		flushSync();
+
+		assert.equal(div?.style.backgroundColor, 'red');
+		assert.equal(div?.style.fontSize, '2em');
+		// only one call here
+		assert.deepEqual(logs, ['makeColor()']);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/style-directive-memoize/main.svelte b/packages/svelte/tests/runtime-runes/samples/style-directive-memoize/main.svelte
new file mode 100644
index 0000000000..444d686745
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/style-directive-memoize/main.svelte
@@ -0,0 +1,10 @@
+<script>
+    function makeColor() {
+        console.log("makeColor()");
+        return "red";
+    }
+
+    let size = $state('1em');
+</script>
+<button onclick={() => size = '2em'}>click</button>
+<div style:background-color={makeColor()} style:font-size={size}></div>
\ No newline at end of file
diff --git a/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/Head.svelte b/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/Head.svelte
new file mode 100644
index 0000000000..fa5ae4a349
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/Head.svelte
@@ -0,0 +1,3 @@
+<svelte:head>
+	<meta name="test" content="value" />
+</svelte:head>
diff --git a/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/_config.js b/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/_config.js
new file mode 100644
index 0000000000..57ef735497
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/_config.js
@@ -0,0 +1,19 @@
+import { flushSync } from 'svelte';
+import { ok, test } from '../../test';
+
+export default test({
+	mode: ['client', 'hydrate'],
+
+	test({ assert, target, window }) {
+		const initial = window.document.head.childNodes.length;
+		const button = target.querySelector('button');
+		ok(button);
+
+		for (let i = 0; i < 3; i++) {
+			flushSync(() => button.click());
+			flushSync(() => button.click());
+		}
+
+		assert.equal(window.document.head.childNodes.length, initial);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/main.svelte b/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/main.svelte
new file mode 100644
index 0000000000..f4cfefbadf
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/svelte-head-anchor-cleanup/main.svelte
@@ -0,0 +1,11 @@
+<script>
+	import Head from './Head.svelte';
+
+	let show = $state(false);
+</script>
+
+<button onclick={() => (show = !show)}>toggle</button>
+
+{#if show}
+	<Head />
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-each/_config.js b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-each/_config.js
new file mode 100644
index 0000000000..7ccfd72f00
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-each/_config.js
@@ -0,0 +1,23 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+// #15604 — a removed each item mid-outro must not be resurrected by an ancestor pause/resume
+export default test({
+	test({ assert, target, raf }) {
+		const [remove, fetch] = target.querySelectorAll('button');
+
+		raf.tick(200);
+		assert.equal(target.querySelectorAll('.item').length, 3);
+
+		flushSync(() => remove.click());
+
+		flushSync(() => fetch.click());
+		raf.tick(30);
+
+		flushSync(() => fetch.click());
+		raf.tick(2000);
+
+		const items = [...target.querySelectorAll('.item')].map((el) => el.textContent);
+		assert.deepEqual(items, ['a', 'c']);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-each/main.svelte b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-each/main.svelte
new file mode 100644
index 0000000000..36e685e3c8
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-each/main.svelte
@@ -0,0 +1,19 @@
+<script>
+	import { fade } from 'svelte/transition';
+
+	let fetching = $state(false);
+	let items = $state(['a', 'b', 'c']);
+</script>
+
+<button onclick={() => (items = items.filter((i) => i !== 'b'))}>remove</button>
+<button onclick={() => (fetching = !fetching)}>fetch</button>
+
+{#if fetching}
+	<p>loading</p>
+{:else}
+	<div transition:fade={{ duration: 100 }}>
+		{#each items as item (item)}
+			<div class="item" transition:fade|global={{ duration: 100 }}>{item}</div>
+		{/each}
+	</div>
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-flipback/_config.js b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-flipback/_config.js
new file mode 100644
index 0000000000..a8e5e99bbf
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-flipback/_config.js
@@ -0,0 +1,24 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+// #15604 companion — flipping the condition back while the ancestor is paused must still revive the element
+export default test({
+	test({ assert, target, raf }) {
+		const [toggle, fetch] = target.querySelectorAll('button');
+
+		raf.tick(200);
+		assert.ok(target.querySelector('.red'));
+
+		flushSync(() => toggle.click());
+
+		flushSync(() => fetch.click());
+		raf.tick(30);
+
+		flushSync(() => toggle.click());
+
+		flushSync(() => fetch.click());
+		raf.tick(2000);
+
+		assert.ok(target.querySelector('.red'));
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-flipback/main.svelte b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-flipback/main.svelte
new file mode 100644
index 0000000000..71a3ea2090
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume-flipback/main.svelte
@@ -0,0 +1,19 @@
+<script>
+	import { fade } from 'svelte/transition';
+
+	let fetching = $state(false);
+	let shown = $state(true);
+</script>
+
+<button onclick={() => (shown = !shown)}>toggle</button>
+<button onclick={() => (fetching = !fetching)}>fetch</button>
+
+{#if fetching}
+	<p>loading</p>
+{:else}
+	<div transition:fade={{ duration: 100 }}>
+		{#if shown}
+			<div class="red" transition:fade|global={{ duration: 100 }}>red</div>
+		{/if}
+	</div>
+{/if}
diff --git a/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume/_config.js b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume/_config.js
new file mode 100644
index 0000000000..4009eea204
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume/_config.js
@@ -0,0 +1,29 @@
+import { flushSync } from 'svelte';
+import { test } from '../../test';
+
+// #15604 — an element mid-outro must not be resurrected when an ancestor
+// block is paused and resumed while the element's own condition is still false.
+// The outer `transition:fade` matters: it keeps the outer branch alive (pending
+// its own outro) so that toggling back takes the resume path
+export default test({
+	test({ assert, target, raf }) {
+		const [hide, fetch] = target.querySelectorAll('button');
+
+		// let the mount intro (dom variant) finish
+		raf.tick(200);
+		assert.ok(target.querySelector('.red'));
+
+		// start the outro of the inner block
+		flushSync(() => hide.click());
+
+		// pause the outer block while the outro is in flight...
+		flushSync(() => fetch.click());
+		raf.tick(250);
+
+		// ...then resume it before either outro completes
+		flushSync(() => fetch.click());
+		raf.tick(2000);
+
+		assert.equal(target.querySelector('.red'), null);
+	}
+});
diff --git a/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume/main.svelte b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume/main.svelte
new file mode 100644
index 0000000000..0060401b8e
--- /dev/null
+++ b/packages/svelte/tests/runtime-runes/samples/transition-global-nested-resume/main.svelte
@@ -0,0 +1,19 @@
+<script>
+	import { fade } from 'svelte/transition';
+
+	let fetching = $state(false);
+	let shown = $state(true);
+</script>
+
+<button onclick={() => (shown = false)}>hide</button>
+<button onclick={() => (fetching = !fetching)}>fetch</button>
+
+{#if fetching}
+	<p>loading</p>
+{:else}
+	<div transition:fade={{ duration: 100 }}>
+		{#if shown}
+			<div class="red" transition:fade|global={{ duration: 100 }}>red</div>
+		{/if}
+	</div>
+{/if}
diff --git a/packages/svelte/tests/server-side-rendering/samples/boundary-duplicate-failed-snippets/_expected.html b/packages/svelte/tests/server-side-rendering/samples/boundary-duplicate-failed-snippets/_expected.html
new file mode 100644
index 0000000000..7c89b545c5
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/boundary-duplicate-failed-snippets/_expected.html
@@ -0,0 +1 @@
+<div></div>
diff --git a/packages/svelte/tests/server-side-rendering/samples/boundary-duplicate-failed-snippets/main.svelte b/packages/svelte/tests/server-side-rendering/samples/boundary-duplicate-failed-snippets/main.svelte
new file mode 100644
index 0000000000..126c9ea304
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/boundary-duplicate-failed-snippets/main.svelte
@@ -0,0 +1,11 @@
+<div>
+	{const x = 0}
+
+	<svelte:boundary>
+		{#snippet failed()}{/snippet}
+	</svelte:boundary>
+
+	<svelte:boundary>
+		{#snippet failed()}{/snippet}
+	</svelte:boundary>
+</div>
diff --git a/packages/svelte/tests/server-side-rendering/samples/declaration-tags-transform/_expected.html b/packages/svelte/tests/server-side-rendering/samples/declaration-tags-transform/_expected.html
new file mode 100644
index 0000000000..5665318328
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/declaration-tags-transform/_expected.html
@@ -0,0 +1 @@
+<!--[--><div>number</div><!--]-->
\ No newline at end of file
diff --git a/packages/svelte/tests/server-side-rendering/samples/declaration-tags-transform/main.svelte b/packages/svelte/tests/server-side-rendering/samples/declaration-tags-transform/main.svelte
new file mode 100644
index 0000000000..d969f907a5
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/declaration-tags-transform/main.svelte
@@ -0,0 +1,4 @@
+<div>
+	{let dt = $derived(Date.parse("2026-10-01T00:00:00Z"))}
+	{typeof dt}
+</div>
\ No newline at end of file
diff --git a/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/Foo.svelte b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/Foo.svelte
new file mode 100644
index 0000000000..b991cdf968
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/Foo.svelte
@@ -0,0 +1,3 @@
+<script>
+	let { bar = $bindable() } = $props();
+</script>
diff --git a/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/Wrapper.svelte b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/Wrapper.svelte
new file mode 100644
index 0000000000..d48c90fe59
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/Wrapper.svelte
@@ -0,0 +1,6 @@
+<script>
+	import Foo from './Foo.svelte';
+	let bar = $state();
+</script>
+
+<Foo bind:bar />
diff --git a/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/_expected.html b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/_expected.html
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/_expected_head.html b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/_expected_head.html
new file mode 100644
index 0000000000..904fa1d9eb
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/_expected_head.html
@@ -0,0 +1,4 @@
+<!--ssr:0-->
+<link rel="canonical" href="/test">
+<meta name="description" content="test">
+<!--ssr:0-->
\ No newline at end of file
diff --git a/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/main.svelte b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/main.svelte
new file mode 100644
index 0000000000..b68ccd07fe
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/head-with-multiple-binding-components/main.svelte
@@ -0,0 +1,12 @@
+<script>
+	import Wrapper from './Wrapper.svelte';
+</script>
+
+<svelte:head>
+	<link rel="canonical" href="/test" />
+	<meta name="description" content="test" />
+</svelte:head>
+
+<Wrapper />
+<Wrapper />
+<Wrapper />
diff --git a/packages/svelte/tests/server-side-rendering/samples/select-default-value/_expected.html b/packages/svelte/tests/server-side-rendering/samples/select-default-value/_expected.html
new file mode 100644
index 0000000000..482f4a9d4c
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/select-default-value/_expected.html
@@ -0,0 +1,25 @@
+<select>
+	<option value="a">A</option>
+	<option selected="" value="b">B</option>
+</select>
+<select>
+	<option value="a">A</option>
+	<option selected="" value="b">B</option>
+</select>
+<select>
+	<option selected="" value="a">A</option>
+	<option value="b">B</option>
+</select>
+<select multiple="">
+	<option selected="" value="a">A</option>
+	<option value="b">B</option>
+	<option selected="" value="c">C</option>
+</select>
+<select>
+	<option value="a">A</option>
+	<option selected="" value="b">B</option>
+</select>
+<select>
+	<option selected="" value="a">A</option>
+	<option value="b">B</option>
+</select>
diff --git a/packages/svelte/tests/server-side-rendering/samples/select-default-value/main.svelte b/packages/svelte/tests/server-side-rendering/samples/select-default-value/main.svelte
new file mode 100644
index 0000000000..fe5a858dd0
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/select-default-value/main.svelte
@@ -0,0 +1,34 @@
+<script>
+	const props = { defaultValue: 'b' };
+</script>
+
+<select defaultValue="b">
+	<option value="a">A</option>
+	<option value="b">B</option>
+</select>
+
+<select {...props}>
+	<option value="a">A</option>
+	<option value="b">B</option>
+</select>
+
+<select defaultValue="b" value="a">
+	<option value="a">A</option>
+	<option value="b">B</option>
+</select>
+
+<select multiple="" defaultValue={['a', 'c']}>
+	<option value="a">A</option>
+	<option value="b">B</option>
+	<option value="c">C</option>
+</select>
+
+<select defaultvalue="b">
+	<option value="a">A</option>
+	<option value="b">B</option>
+</select>
+
+<select {...{ defaultValue: 'b' }} defaultValue="a">
+	<option value="a">A</option>
+	<option value="b">B</option>
+</select>
diff --git a/packages/svelte/tests/server-side-rendering/samples/state-eager/_expected.html b/packages/svelte/tests/server-side-rendering/samples/state-eager/_expected.html
new file mode 100644
index 0000000000..9d3ea2f5b4
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/state-eager/_expected.html
@@ -0,0 +1,2 @@
+<div>value=0</div>
+<div>eager=0</div>
\ No newline at end of file
diff --git a/packages/svelte/tests/server-side-rendering/samples/state-eager/main.svelte b/packages/svelte/tests/server-side-rendering/samples/state-eager/main.svelte
new file mode 100644
index 0000000000..d144914f72
--- /dev/null
+++ b/packages/svelte/tests/server-side-rendering/samples/state-eager/main.svelte
@@ -0,0 +1,7 @@
+<script>
+	let props = $props();
+	const value = $derived(props.number ?? 0);
+</script>
+
+<div>value={value}</div>
+<div>eager={$state.eager(value)}</div>
diff --git a/packages/svelte/tests/server-side-rendering/test.ts b/packages/svelte/tests/server-side-rendering/test.ts
index 2dcaa85708..16f7c422b8 100644
--- a/packages/svelte/tests/server-side-rendering/test.ts
+++ b/packages/svelte/tests/server-side-rendering/test.ts
@@ -6,13 +6,12 @@
 
 import * as fs from 'node:fs';
 import { assert } from 'vitest';
-import { render } from 'svelte/server';
+import { render, type SyncRenderOutput } from 'svelte/server';
 import { compile_directory, should_update_expected, try_read_file } from '../helpers.js';
 import { assert_html_equal_with_options } from '../html_equal.js';
 import { suite_with_variants, type BaseTest } from '../suite.js';
 import type { CompileOptions } from '#compiler';
 import { seen } from '../../src/internal/server/dev.js';
-import type { SyncRenderOutput } from '#server';
 
 interface SSRTest extends BaseTest {
 	mode?: ('sync' | 'async')[];
diff --git a/packages/svelte/tests/signals/test.ts b/packages/svelte/tests/signals/test.ts
index 927ce2e665..c1ebc3ec75 100644
--- a/packages/svelte/tests/signals/test.ts
+++ b/packages/svelte/tests/signals/test.ts
@@ -1503,4 +1503,92 @@ describe('signals', () => {
 			assert.deepEqual(log, ['inner destroyed', 'inner destroyed']);
 		};
 	});
+
+	test('derived read in an untracked context should not leak in deps reactions', () => {
+		return () => {
+			let s = state('hello');
+			let a = derived(() => $.get(s));
+			let b = derived(() => $.get(a));
+
+			let destroy = effect_root(() => {
+				$.get(b);
+			});
+
+			destroy();
+
+			// a was spuriously added to s.reactions via is_updating_effect
+			// even though the entire derived chain was read in an untracked context
+			assert.equal(s.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);
+		const pane = derived(() => $.get(src));
+		const base = derived(() => $.get(pane) + ':base');
+		const extra = derived(() => $.get(pane) + ':extra');
+		const flag = state(false);
+
+		const destroy = effect_root(() => {
+			render_effect(() => {
+				if ($.get(flag)) {
+					$.get(extra);
+					throw new Error('render boom');
+				} else {
+					$.get(base);
+				}
+			});
+		});
+
+		return () => {
+			try {
+				flushSync(() => set(flag, true));
+			} catch {}
+
+			destroy();
+
+			assert.equal(src.reactions, null);
+		};
+	});
+
+	test('a derived that throws on its first run re-runs when its dependencies change', () => {
+		const s = state(0);
+		const fn = () => {
+			if ($.get(s) === 0) throw new Error('boom');
+			return $.get(s);
+		};
+		const owned = derived(fn);
+		const previous_effect = $.active_effect;
+		$.set_active_effect(null);
+		const unowned = derived(fn);
+		$.set_active_effect(previous_effect);
+		const log: any[] = [];
+
+		const destroy = effect_root(() => {
+			render_effect(() => {
+				for (const d of [owned, unowned]) {
+					try {
+						log.push($.get(d));
+					} catch {
+						log.push('error');
+					}
+				}
+			});
+		});
+
+		return () => {
+			assert.notEqual(owned.parent, null);
+			assert.equal(unowned.parent, null);
+
+			flushSync();
+			assert.deepEqual(log, ['error', 'error']);
+
+			flushSync(() => set(s, 1));
+			assert.deepEqual(log, ['error', 'error', 1, 1]);
+
+			destroy();
+			assert.equal(s.reactions, null);
+		};
+	});
 });
diff --git a/packages/svelte/tests/snapshot/samples/async-const/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/async-const/_expected/client/index.svelte.js
index 5c1d27ae54..41ab26212c 100644
--- a/packages/svelte/tests/snapshot/samples/async-const/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/async-const/_expected/client/index.svelte.js
@@ -14,14 +14,25 @@ export default function Async_const($$anchor) {
 			let b;
 
 			var promises = $.run([
-				async () => a = (await $.save($.async_derived(async () => (await $.save(1))())))(),
+				async () => {
+					try {
+						return a = (await $.save($.async_derived(async () => {
+							try {
+								return (await $.save(1))();
+							} finally {
+								$.unsave();
+							}
+						})))();
+					} finally {
+						$.unsave();
+					}
+				},
 				() => b = $.derived(() => $.get(a) + 1)
 			]);
 
 			var p = root();
-			var text = $.child(p, true);
+			var text = $.only_child(p, true);
 
-			$.reset(p);
 			$.template_effect(() => $.set_text(text, $.get(b)), void 0, void 0, [promises[1]]);
 			$.append($$anchor, p);
 		};
diff --git a/packages/svelte/tests/snapshot/samples/async-each-fallback-hoisting/_expected/server/index.svelte.js b/packages/svelte/tests/snapshot/samples/async-each-fallback-hoisting/_expected/server/index.svelte.js
index b331875d04..71ccba4d59 100644
--- a/packages/svelte/tests/snapshot/samples/async-each-fallback-hoisting/_expected/server/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/async-each-fallback-hoisting/_expected/server/index.svelte.js
@@ -15,8 +15,7 @@ export default function Async_each_fallback_hoisting($$renderer) {
 				$$renderer.push(async () => $.escape(await Promise.reject('This should never be reached')));
 			}
 		} else {
-			$$renderer.push('<!--[!-->');
-			$$renderer.push(`<!---->`);
+			$$renderer.push(`<!--[!--><!---->`);
 			$$renderer.push(async () => $.escape(await Promise.resolve(4)));
 		}
 	});
diff --git a/packages/svelte/tests/snapshot/samples/async-if-chain/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/async-if-chain/_expected/client/index.svelte.js
index 8d21c2ceef..ca99d1c0c5 100644
--- a/packages/svelte/tests/snapshot/samples/async-if-chain/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/async-if-chain/_expected/client/index.svelte.js
@@ -90,52 +90,78 @@ export default function Async_if_chain($$anchor) {
 
 	var node_3 = $.sibling(node_1, 2);
 
-	$.async(node_3, [$$promises[0]], [async () => (await $.save(foo))() > 10], (node_3, $$condition) => {
-		var consequent_5 = ($$anchor) => {
-			var text_7 = $.text('foo');
-
-			$.append($$anchor, text_7);
-		};
-
-		var consequent_6 = ($$anchor) => {
-			var text_8 = $.text('bar');
-
-			$.append($$anchor, text_8);
-		};
-
-		var alternate_4 = ($$anchor) => {
-			var fragment_2 = $.comment();
-			var node_4 = $.first_child(fragment_2);
-
-			$.async(node_4, [$$promises[0]], [async () => (await $.save(foo))() > 5], (node_4, $$condition) => {
-				var consequent_7 = ($$anchor) => {
-					var text_9 = $.text('baz');
-
-					$.append($$anchor, text_9);
-				};
-
-				var alternate_3 = ($$anchor) => {
-					var text_10 = $.text('else');
-
-					$.append($$anchor, text_10);
-				};
-
-				$.if(
+	$.async(
+		node_3,
+		[$$promises[0]],
+		[
+			async () => {
+				try {
+					return (await $.save(foo))() > 10;
+				} finally {
+					$.unsave();
+				}
+			}
+		],
+		(node_3, $$condition) => {
+			var consequent_5 = ($$anchor) => {
+				var text_7 = $.text('foo');
+
+				$.append($$anchor, text_7);
+			};
+
+			var consequent_6 = ($$anchor) => {
+				var text_8 = $.text('bar');
+
+				$.append($$anchor, text_8);
+			};
+
+			var alternate_4 = ($$anchor) => {
+				var fragment_2 = $.comment();
+				var node_4 = $.first_child(fragment_2);
+
+				$.async(
 					node_4,
-					($$render) => {
-						if ($.get($$condition)) $$render(consequent_7); else $$render(alternate_3, -1);
-					},
-					true
+					[$$promises[0]],
+					[
+						async () => {
+							try {
+								return (await $.save(foo))() > 5;
+							} finally {
+								$.unsave();
+							}
+						}
+					],
+					(node_4, $$condition) => {
+						var consequent_7 = ($$anchor) => {
+							var text_9 = $.text('baz');
+
+							$.append($$anchor, text_9);
+						};
+
+						var alternate_3 = ($$anchor) => {
+							var text_10 = $.text('else');
+
+							$.append($$anchor, text_10);
+						};
+
+						$.if(
+							node_4,
+							($$render) => {
+								if ($.get($$condition)) $$render(consequent_7); else $$render(alternate_3, -1);
+							},
+							true
+						);
+					}
 				);
-			});
 
-			$.append($$anchor, fragment_2);
-		};
+				$.append($$anchor, fragment_2);
+			};
 
-		$.if(node_3, ($$render) => {
-			if ($.get($$condition)) $$render(consequent_5); else if (bar) $$render(consequent_6, 1); else $$render(alternate_4, -1);
-		});
-	});
+			$.if(node_3, ($$render) => {
+				if ($.get($$condition)) $$render(consequent_5); else if (bar) $$render(consequent_6, 1); else $$render(alternate_4, -1);
+			});
+		}
+	);
 
 	var node_5 = $.sibling(node_3, 2);
 
diff --git a/packages/svelte/tests/snapshot/samples/async-if-chain/_expected/server/index.svelte.js b/packages/svelte/tests/snapshot/samples/async-if-chain/_expected/server/index.svelte.js
index 3fc25288ad..466683b868 100644
--- a/packages/svelte/tests/snapshot/samples/async-if-chain/_expected/server/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/async-if-chain/_expected/server/index.svelte.js
@@ -12,14 +12,11 @@ export default function Async_if_chain($$renderer) {
 
 	$$renderer.async_block([$$promises[0]], ($$renderer) => {
 		if (foo) {
-			$$renderer.push('<!--[0-->');
-			$$renderer.push(`foo`);
+			$$renderer.push(`<!--[0-->foo`);
 		} else if (bar) {
-			$$renderer.push('<!--[1-->');
-			$$renderer.push(`bar`);
+			$$renderer.push(`<!--[1-->bar`);
 		} else {
-			$$renderer.push('<!--[-1-->');
-			$$renderer.push(`else`);
+			$$renderer.push(`<!--[-1-->else`);
 		}
 	});
 
@@ -27,21 +24,17 @@ export default function Async_if_chain($$renderer) {
 
 	$$renderer.async_block([$$promises[0]], async ($$renderer) => {
 		if ((await $.save(foo))()) {
-			$$renderer.push('<!--[0-->');
-			$$renderer.push(`foo`);
+			$$renderer.push(`<!--[0-->foo`);
 		} else if (bar) {
-			$$renderer.push('<!--[1-->');
-			$$renderer.push(`bar`);
+			$$renderer.push(`<!--[1-->bar`);
 		} else {
 			$$renderer.push('<!--[-1-->');
 
 			$$renderer.child_block(async ($$renderer) => {
 				if ((await $.save(baz))()) {
-					$$renderer.push('<!--[0-->');
-					$$renderer.push(`baz`);
+					$$renderer.push(`<!--[0-->baz`);
 				} else {
-					$$renderer.push('<!--[-1-->');
-					$$renderer.push(`else`);
+					$$renderer.push(`<!--[-1-->else`);
 				}
 			});
 
@@ -53,21 +46,17 @@ export default function Async_if_chain($$renderer) {
 
 	$$renderer.async_block([$$promises[0]], async ($$renderer) => {
 		if ((await $.save(foo))() > 10) {
-			$$renderer.push('<!--[0-->');
-			$$renderer.push(`foo`);
+			$$renderer.push(`<!--[0-->foo`);
 		} else if (bar) {
-			$$renderer.push('<!--[1-->');
-			$$renderer.push(`bar`);
+			$$renderer.push(`<!--[1-->bar`);
 		} else {
 			$$renderer.push('<!--[-1-->');
 
 			$$renderer.async_block([$$promises[0]], async ($$renderer) => {
 				if ((await $.save(foo))() > 5) {
-					$$renderer.push('<!--[0-->');
-					$$renderer.push(`baz`);
+					$$renderer.push(`<!--[0-->baz`);
 				} else {
-					$$renderer.push('<!--[-1-->');
-					$$renderer.push(`else`);
+					$$renderer.push(`<!--[-1-->else`);
 				}
 			});
 
@@ -78,31 +67,24 @@ export default function Async_if_chain($$renderer) {
 	$$renderer.push(`<!--]--> `);
 
 	if (simple1) {
-		$$renderer.push('<!--[0-->');
-		$$renderer.push(`foo`);
+		$$renderer.push(`<!--[0-->foo`);
 	} else if (simple2 > 10) {
-		$$renderer.push('<!--[1-->');
-		$$renderer.push(`bar`);
+		$$renderer.push(`<!--[1-->bar`);
 	} else if (complex1() * complex2 > 100) {
-		$$renderer.push('<!--[2-->');
-		$$renderer.push(`baz`);
+		$$renderer.push(`<!--[2-->baz`);
 	} else {
-		$$renderer.push('<!--[-1-->');
-		$$renderer.push(`else`);
+		$$renderer.push(`<!--[-1-->else`);
 	}
 
 	$$renderer.push(`<!--]--> `);
 
 	$$renderer.async_block([$$promises[0]], ($$renderer) => {
 		if (blocking() > 10) {
-			$$renderer.push('<!--[0-->');
-			$$renderer.push(`foo`);
+			$$renderer.push(`<!--[0-->foo`);
 		} else if (blocking() > 5) {
-			$$renderer.push('<!--[1-->');
-			$$renderer.push(`bar`);
+			$$renderer.push(`<!--[1-->bar`);
 		} else {
-			$$renderer.push('<!--[-1-->');
-			$$renderer.push(`else`);
+			$$renderer.push(`<!--[-1-->else`);
 		}
 	});
 
diff --git a/packages/svelte/tests/snapshot/samples/async-in-derived/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/async-in-derived/_expected/client/index.svelte.js
index 79b8ad0040..327dc4918c 100644
--- a/packages/svelte/tests/snapshot/samples/async-in-derived/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/async-in-derived/_expected/client/index.svelte.js
@@ -34,8 +34,34 @@ export default function Async_in_derived($$anchor, $$props) {
 			let no2;
 
 			var promises = $.run([
-				async () => yes1 = (await $.save($.async_derived(async () => (await $.save(1))())))(),
-				async () => yes2 = (await $.save($.async_derived(async () => foo((await $.save(1))()))))(),
+				async () => {
+					try {
+						return yes1 = (await $.save($.async_derived(async () => {
+							try {
+								return (await $.save(1))();
+							} finally {
+								$.unsave();
+							}
+						})))();
+					} finally {
+						$.unsave();
+					}
+				},
+
+				async () => {
+					try {
+						return yes2 = (await $.save($.async_derived(async () => {
+							try {
+								return foo((await $.save(1))());
+							} finally {
+								$.unsave();
+							}
+						})))();
+					} finally {
+						$.unsave();
+					}
+				},
+
 				() => no1 = $.derived(() => (async () => {
 					return await 1;
 				})()),
diff --git a/packages/svelte/tests/snapshot/samples/async-top-level-inspect-server/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/async-top-level-inspect-server/_expected/client/index.svelte.js
index 668c936e4e..c5b700ffec 100644
--- a/packages/svelte/tests/snapshot/samples/async-top-level-inspect-server/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/async-top-level-inspect-server/_expected/client/index.svelte.js
@@ -8,9 +8,8 @@ export default function Async_top_level_inspect_server($$anchor) {
 	var data;
 	var $$promises = $.run([async () => data = await Promise.resolve(42), () => void 0]);
 	var p = root();
-	var text = $.child(p, true);
+	var text = $.only_child(p, true);
 
-	$.reset(p);
 	$.template_effect(() => $.set_text(text, data), void 0, void 0, [$$promises[1]]);
 	$.append($$anchor, p);
 }
\ No newline at end of file
diff --git a/packages/svelte/tests/snapshot/samples/await-block-scope/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/await-block-scope/_expected/client/index.svelte.js
index e1b87d6280..7097ec24d9 100644
--- a/packages/svelte/tests/snapshot/samples/await-block-scope/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/await-block-scope/_expected/client/index.svelte.js
@@ -13,10 +13,7 @@ export default function Await_block_scope($$anchor) {
 
 	var fragment = root();
 	var button = $.first_child(fragment);
-	var text = $.child(button);
-
-	$.reset(button);
-
+	var text = $.only_child(button);
 	var node = $.sibling(button, 2);
 
 	$.await(node, () => $.get(promise), null, ($$anchor, counter) => {});
diff --git a/packages/svelte/tests/snapshot/samples/dedupe-templates/_expected/server/index.svelte.js b/packages/svelte/tests/snapshot/samples/dedupe-templates/_expected/server/index.svelte.js
index 1f4a56779e..be305165cb 100644
--- a/packages/svelte/tests/snapshot/samples/dedupe-templates/_expected/server/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/dedupe-templates/_expected/server/index.svelte.js
@@ -4,18 +4,15 @@ export default function Dedupe_templates($$renderer, $$props) {
 	let { a, b } = $$props;
 
 	if (a) {
-		$$renderer.push('<!--[0-->');
-		$$renderer.push(`<p class="x">hello</p>`);
+		$$renderer.push(`<!--[0--><p class="x">hello</p>`);
 	} else {
-		$$renderer.push('<!--[-1-->');
-		$$renderer.push(`<p class="x">hello</p>`);
+		$$renderer.push(`<!--[-1--><p class="x">hello</p>`);
 	}
 
 	$$renderer.push(`<!--]--> `);
 
 	if (b) {
-		$$renderer.push('<!--[0-->');
-		$$renderer.push(`<p class="x">hello</p>`);
+		$$renderer.push(`<!--[0--><p class="x">hello</p>`);
 	} else {
 		$$renderer.push('<!--[-1-->');
 	}
diff --git a/packages/svelte/tests/snapshot/samples/dynamic-attributes-casing/_expected/client/main.svelte.js b/packages/svelte/tests/snapshot/samples/dynamic-attributes-casing/_expected/client/main.svelte.js
index eafadfc2ea..799c9f2139 100644
--- a/packages/svelte/tests/snapshot/samples/dynamic-attributes-casing/_expected/client/main.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/dynamic-attributes-casing/_expected/client/main.svelte.js
@@ -25,7 +25,7 @@ export default function Main($$anchor) {
 	var svg_1 = $.sibling(div_1, 2);
 	var custom_element_1 = $.sibling(svg_1, 2);
 
-	$.template_effect(() => $.set_custom_element_data(custom_element_1, 'fooBar', y()));
+	$.template_effect(($0) => $.set_custom_element_data(custom_element_1, 'fooBar', $0), [() => y()]);
 
 	$.template_effect(
 		($0, $1) => {
diff --git a/packages/svelte/tests/snapshot/samples/nullish-coallescence-omittance/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/nullish-coallescence-omittance/_expected/client/index.svelte.js
index 837a7cd65a..8fe9663290 100644
--- a/packages/svelte/tests/snapshot/samples/nullish-coallescence-omittance/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/nullish-coallescence-omittance/_expected/client/index.svelte.js
@@ -16,10 +16,7 @@ export default function Nullish_coallescence_omittance($$anchor, $$props) {
 	b.textContent = '123';
 
 	var button = $.sibling(b, 2);
-	var text = $.child(button);
-
-	$.reset(button);
-
+	var text = $.only_child(button);
 	var h1_1 = $.sibling(button, 2);
 
 	h1_1.textContent = 'Hello, world';
diff --git a/packages/svelte/tests/snapshot/samples/select-with-rich-content/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/select-with-rich-content/_expected/client/index.svelte.js
index c8354fe67e..36b774340b 100644
--- a/packages/svelte/tests/snapshot/samples/select-with-rich-content/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/select-with-rich-content/_expected/client/index.svelte.js
@@ -35,7 +35,6 @@ var option_content = $.from_html(`<span>Rich</span>`, 1);
 var root_4 = $.from_html(`<option> </option>`);
 var root_5 = $.from_html(`<option>Visible</option>`);
 var root_6 = $.from_html(`<option>Keyed</option>`);
-var select_content = $.from_html(`<!>`, 1);
 var option_content_1 = $.from_html(`<strong>Bold</strong>`, 1);
 var option_content_2 = $.from_html(`<em>Italic</em> text`, 1);
 var option_content_3 = $.from_html(`<span> </span>`, 1);
@@ -65,17 +64,14 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.each(select_1, 5, () => items, $.index, ($$anchor, item) => {
 		var option_5 = root_4();
-		var text = $.child(option_5, true);
-
-		$.reset(option_5);
-
+		var text = $.only_child(option_5, true);
 		var option_5_value = {};
 
 		$.template_effect(() => {
 			$.set_text(text, $.get(item));
 
 			if (option_5_value !== (option_5_value = $.get(item))) {
-				option_5.__value = $.get(item);
+				option_5.__value = option_5_value;
 			}
 		});
 
@@ -116,7 +112,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(select_4, () => {
 		var anchor_1 = $.child(select_4);
-		var fragment_2 = select_content();
+		var fragment_2 = $.comment();
 		var node_2 = $.first_child(fragment_2);
 
 		opt(node_2);
@@ -128,17 +124,14 @@ export default function Select_with_rich_content($$anchor) {
 	$.each(select_5, 5, () => items, $.index, ($$anchor, item) => {
 		const x = $.derived_safe_equal(() => $.get(item) * 2);
 		var option_8 = root_4();
-		var text_1 = $.child(option_8, true);
-
-		$.reset(option_8);
-
+		var text_1 = $.only_child(option_8, true);
 		var option_8_value = {};
 
 		$.template_effect(() => {
 			$.set_text(text_1, $.get(x));
 
 			if (option_8_value !== (option_8_value = $.get(x))) {
-				option_8.__value = $.get(x);
+				option_8.__value = option_8_value;
 			}
 		});
 
@@ -166,17 +159,14 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.each(optgroup_1, 5, () => items, $.index, ($$anchor, item) => {
 		var option_10 = root_4();
-		var text_2 = $.child(option_10, true);
-
-		$.reset(option_10);
-
+		var text_2 = $.only_child(option_10, true);
 		var option_10_value = {};
 
 		$.template_effect(() => {
 			$.set_text(text_2, $.get(item));
 
 			if (option_10_value !== (option_10_value = $.get(item))) {
-				option_10.__value = $.get(item);
+				option_10.__value = option_10_value;
 			}
 		});
 
@@ -209,9 +199,8 @@ export default function Select_with_rich_content($$anchor) {
 			var anchor_4 = $.child(option_12);
 			var fragment_5 = option_content_3();
 			var span = $.first_child(fragment_5);
-			var text_3 = $.child(span, true);
+			var text_3 = $.only_child(span, true);
 
-			$.reset(span);
 			$.template_effect(() => $.set_text(text_3, $.get(item)));
 			$.append(anchor_4, fragment_5);
 		});
@@ -231,17 +220,14 @@ export default function Select_with_rich_content($$anchor) {
 
 			$.each(node_4, 1, () => items, $.index, ($$anchor, item) => {
 				var option_13 = root_4();
-				var text_4 = $.child(option_13, true);
-
-				$.reset(option_13);
-
+				var text_4 = $.only_child(option_13, true);
 				var option_13_value = {};
 
 				$.template_effect(() => {
 					$.set_text(text_4, $.get(item));
 
 					if (option_13_value !== (option_13_value = $.get(item))) {
-						option_13.__value = $.get(item);
+						option_13.__value = option_13_value;
 					}
 				});
 
@@ -291,7 +277,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(select_13, () => {
 		var anchor_6 = $.child(select_13);
-		var fragment_8 = select_content();
+		var fragment_8 = $.comment();
 		var node_7 = $.first_child(fragment_8);
 
 		Option(node_7, {});
@@ -302,7 +288,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(select_14, () => {
 		var anchor_7 = $.child(select_14);
-		var fragment_9 = select_content();
+		var fragment_9 = $.comment();
 		var node_8 = $.first_child(fragment_9);
 
 		option_snippet(node_8);
@@ -313,7 +299,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(select_15, () => {
 		var anchor_8 = $.child(select_15);
-		var fragment_10 = select_content();
+		var fragment_10 = $.comment();
 		var node_9 = $.first_child(fragment_10);
 
 		$.html(node_9, () => html);
@@ -325,7 +311,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(optgroup_2, () => {
 		var anchor_9 = $.child(optgroup_2);
-		var fragment_11 = select_content();
+		var fragment_11 = $.comment();
 		var node_10 = $.first_child(fragment_11);
 
 		Option(node_10, {});
@@ -339,7 +325,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(optgroup_3, () => {
 		var anchor_10 = $.child(optgroup_3);
-		var fragment_12 = select_content();
+		var fragment_12 = $.comment();
 		var node_11 = $.first_child(fragment_12);
 
 		option_snippet2(node_11);
@@ -353,7 +339,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(option_16, () => {
 		var anchor_11 = $.child(option_16);
-		var fragment_13 = select_content();
+		var fragment_13 = $.comment();
 		var node_12 = $.first_child(fragment_13);
 
 		$.html(node_12, () => '<strong>Bold HTML</strong>');
@@ -366,7 +352,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(select_19, () => {
 		var anchor_12 = $.child(select_19);
-		var fragment_14 = select_content();
+		var fragment_14 = $.comment();
 		var node_13 = $.first_child(fragment_14);
 
 		$.each(node_13, 1, () => items, $.index, ($$anchor, item) => {
@@ -380,7 +366,7 @@ export default function Select_with_rich_content($$anchor) {
 
 	$.customizable_select(select_20, () => {
 		var anchor_13 = $.child(select_20);
-		var fragment_16 = select_content();
+		var fragment_16 = $.comment();
 		var node_14 = $.first_child(fragment_16);
 
 		{
diff --git a/packages/svelte/tests/snapshot/samples/select-with-rich-content/_expected/server/index.svelte.js b/packages/svelte/tests/snapshot/samples/select-with-rich-content/_expected/server/index.svelte.js
index bc346b4b0a..de22dc2f96 100644
--- a/packages/svelte/tests/snapshot/samples/select-with-rich-content/_expected/server/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/select-with-rich-content/_expected/server/index.svelte.js
@@ -148,8 +148,7 @@ export default function Select_with_rich_content($$renderer) {
 	$$renderer.push(`<!--]--></select> <select>`);
 
 	if (show) {
-		$$renderer.push('<!--[0-->');
-		$$renderer.push(`<!--[-->`);
+		$$renderer.push(`<!--[0--><!--[-->`);
 
 		const each_array_4 = $.ensure_array_like(items);
 
diff --git a/packages/svelte/tests/snapshot/samples/skip-static-subtree/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/skip-static-subtree/_expected/client/index.svelte.js
index 78147659ff..30976b40e6 100644
--- a/packages/svelte/tests/snapshot/samples/skip-static-subtree/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/skip-static-subtree/_expected/client/index.svelte.js
@@ -7,10 +7,7 @@ export default function Skip_static_subtree($$anchor, $$props) {
 	var fragment = root();
 	var main = $.sibling($.first_child(fragment), 2);
 	var h1 = $.child(main);
-	var text = $.child(h1, true);
-
-	$.reset(h1);
-
+	var text = $.only_child(h1, true);
 	var node = $.sibling(h1, 10);
 
 	$.html(node, () => $$props.content);
@@ -40,10 +37,7 @@ export default function Skip_static_subtree($$anchor, $$props) {
 
 	option.value = option.__value = 'a';
 	$.reset(select);
-
-	var img = $.sibling(select, 2);
-
-	$.next(2);
+	$.next(4);
 	$.template_effect(() => $.set_text(text, $$props.title));
 	$.append($$anchor, fragment);
 }
\ No newline at end of file
diff --git a/packages/svelte/tests/snapshot/samples/text-nodes-deriveds/_expected/client/index.svelte.js b/packages/svelte/tests/snapshot/samples/text-nodes-deriveds/_expected/client/index.svelte.js
index 4148a546c8..a6a38f475c 100644
--- a/packages/svelte/tests/snapshot/samples/text-nodes-deriveds/_expected/client/index.svelte.js
+++ b/packages/svelte/tests/snapshot/samples/text-nodes-deriveds/_expected/client/index.svelte.js
@@ -16,9 +16,8 @@ export default function Text_nodes_deriveds($$anchor) {
 	}
 
 	var p = root();
-	var text = $.child(p);
+	var text = $.only_child(p);
 
-	$.reset(p);
 	$.template_effect(($0, $1) => $.set_text(text, `${$0 ?? ''}${$1 ?? ''}`), [() => text1(), () => text2()]);
 	$.append($$anchor, p);
 }
\ No newline at end of file
diff --git a/packages/svelte/tests/sourcemaps/samples/sourcemap-empty-source/_config.js b/packages/svelte/tests/sourcemaps/samples/sourcemap-empty-source/_config.js
new file mode 100644
index 0000000000..43a2a4c16a
--- /dev/null
+++ b/packages/svelte/tests/sourcemaps/samples/sourcemap-empty-source/_config.js
@@ -0,0 +1,29 @@
+import * as fs from 'node:fs';
+import MagicString from 'magic-string';
+import { test } from '../../test';
+
+// Simulates a bundler plugin (e.g. a Vite plugin using `magic-string`) that transforms
+// the Svelte source *before* it reaches `compile()`, and hands its own sourcemap to
+// `compileOptions.sourcemap` — the documented way to let svelte chain an upstream map
+// into its own output map. Crucially, the upstream map is generated *without* a `source`
+// option, exactly like `new MagicString(code).generateMap()` — this yields a sourcemap
+// whose `sources` is `['']`, which previously broke the chain entirely (see #18491)
+// instead of being treated as "this file", causing every mapping through it to resolve
+// to `{ source: null, line: null, column: null }`.
+const input = fs.readFileSync(new URL('./input.svelte', import.meta.url), 'utf-8');
+const src = new MagicString(input);
+src.overwrite(
+	src.original.indexOf('count * 2'),
+	src.original.indexOf('count * 2') + 'count * 2'.length,
+	'count * 2',
+	{
+		storeName: false
+	}
+);
+
+export default test({
+	compileOptions: {
+		sourcemap: src.generateMap({ hires: true })
+	},
+	client: [{ str: 'let doubled' }]
+});
diff --git a/packages/svelte/tests/sourcemaps/samples/sourcemap-empty-source/input.svelte b/packages/svelte/tests/sourcemaps/samples/sourcemap-empty-source/input.svelte
new file mode 100644
index 0000000000..b4e0b50bdb
--- /dev/null
+++ b/packages/svelte/tests/sourcemaps/samples/sourcemap-empty-source/input.svelte
@@ -0,0 +1,6 @@
+<script>
+	let count = 0;
+	let doubled = count * 2;
+</script>
+
+<button>clicks: {count}</button>
diff --git a/packages/svelte/tests/validator/samples/a11y-mouse-events-have-key-events/input.svelte b/packages/svelte/tests/validator/samples/a11y-mouse-events-have-key-events/input.svelte
index f9fe4f15c1..85e9384c98 100644
--- a/packages/svelte/tests/validator/samples/a11y-mouse-events-have-key-events/input.svelte
+++ b/packages/svelte/tests/validator/samples/a11y-mouse-events-have-key-events/input.svelte
@@ -17,3 +17,7 @@
 <div onmouseout={() => {}} onblur={() => {}}></div>
 <!-- svelte-ignore a11y_no_static_element_interactions -->
 <div onmouseout={() => {}} {...otherProps}></div>
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div onmouseover={() => {}} onfocusin={() => {}}></div>
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div onmouseout={() => {}} onfocusout={() => {}}></div>
diff --git a/packages/svelte/tests/validator/samples/declaration-tag-state-referenced-locally/input.svelte b/packages/svelte/tests/validator/samples/declaration-tag-state-referenced-locally/input.svelte
index 90cc208e72..f422be9622 100644
--- a/packages/svelte/tests/validator/samples/declaration-tag-state-referenced-locally/input.svelte
+++ b/packages/svelte/tests/validator/samples/declaration-tag-state-referenced-locally/input.svelte
@@ -7,3 +7,7 @@
 {let e = $state(0), f = e}
 
 {a}{b}{c}{d}{e}{f}
+
+<button onclick={() => {
+	console.log(a);
+}}>a</button>
\ No newline at end of file
diff --git a/packages/svelte/tests/validator/samples/global-event-reference-special-elements/_config.js b/packages/svelte/tests/validator/samples/global-event-reference-special-elements/_config.js
new file mode 100644
index 0000000000..f47bee71df
--- /dev/null
+++ b/packages/svelte/tests/validator/samples/global-event-reference-special-elements/_config.js
@@ -0,0 +1,3 @@
+import { test } from '../../test';
+
+export default test({});
diff --git a/packages/svelte/tests/validator/samples/global-event-reference-special-elements/input.svelte b/packages/svelte/tests/validator/samples/global-event-reference-special-elements/input.svelte
new file mode 100644
index 0000000000..3ea7674419
--- /dev/null
+++ b/packages/svelte/tests/validator/samples/global-event-reference-special-elements/input.svelte
@@ -0,0 +1,7 @@
+<script>
+	let onkeydown;
+</script>
+
+<svelte:window {onkeydown} {onresize} />
+<svelte:document {onvisibilitychange} />
+<svelte:body {onfocus} />
diff --git a/packages/svelte/tests/validator/samples/global-event-reference-special-elements/warnings.json b/packages/svelte/tests/validator/samples/global-event-reference-special-elements/warnings.json
new file mode 100644
index 0000000000..e69a45ab3e
--- /dev/null
+++ b/packages/svelte/tests/validator/samples/global-event-reference-special-elements/warnings.json
@@ -0,0 +1,38 @@
+[
+	{
+		"code": "attribute_global_event_reference",
+		"message": "You are referencing `globalThis.onresize`. Did you forget to declare a variable with that name?",
+		"start": {
+			"column": 27,
+			"line": 5
+		},
+		"end": {
+			"column": 37,
+			"line": 5
+		}
+	},
+	{
+		"code": "attribute_global_event_reference",
+		"message": "You are referencing `globalThis.onvisibilitychange`. Did you forget to declare a variable with that name?",
+		"start": {
+			"column": 17,
+			"line": 6
+		},
+		"end": {
+			"column": 37,
+			"line": 6
+		}
+	},
+	{
+		"code": "attribute_global_event_reference",
+		"message": "You are referencing `globalThis.onfocus`. Did you forget to declare a variable with that name?",
+		"start": {
+			"column": 13,
+			"line": 7
+		},
+		"end": {
+			"column": 22,
+			"line": 7
+		}
+	}
+]
diff --git a/packages/svelte/types/index.d.ts b/packages/svelte/types/index.d.ts
index f25c52a11d..a3667c28df 100644
--- a/packages/svelte/types/index.d.ts
+++ b/packages/svelte/types/index.d.ts
@@ -494,13 +494,16 @@ declare module 'svelte' {
 	/**
 	 * Returns a `[get, set]` pair of functions for working with context in a type-safe way.
 	 *
-	 * `get` will throw an error if no parent component called `set`.
+	 * `get` will throw an error if `set` has not yet been called in the current component or any of
+	 * its ancestors.
 	 *
 	 * @since 5.40.0
 	 */
 	export function createContext<T>(): [() => T, (context: T) => T];
 	/**
-	 * Retrieves the context that belongs to the closest parent component with the specified `key`.
+	 * Retrieves the context set with the specified `key` in the current component or any of its
+	 * ancestors. If multiple components set the same key, the value from the closest one is returned.
+	 * A `setContext` call in the current component is only visible to `getContext` calls that run after it.
 	 * Must be called during component initialisation.
 	 *
 	 * [`createContext`](https://svelte.dev/docs/svelte/svelte#createContext) is a type-safe alternative.
@@ -509,8 +512,8 @@ declare module 'svelte' {
 	export function getContext<T>(key: any): T;
 	/**
 	 * Associates an arbitrary `context` object with the current component and the specified `key`
-	 * and returns that object. The context is then available to children of the component
-	 * (including slotted content) with `getContext`.
+	 * and returns that object. The context is then available to the component itself and all of its
+	 * descendants (including slotted content) with `getContext`.
 	 *
 	 * Like lifecycle functions, this must be called during component initialisation.
 	 *
@@ -519,15 +522,15 @@ declare module 'svelte' {
 	 * */
 	export function setContext<T>(key: any, context: T): T;
 	/**
-	 * Checks whether a given `key` has been set in the context of a parent component.
-	 * Must be called during component initialisation.
+	 * Checks whether a given `key` has been set in the context of the current component or any of
+	 * its ancestors. Must be called during component initialisation.
 	 *
 	 * */
 	export function hasContext(key: any): boolean;
 	/**
-	 * Retrieves the whole context map that belongs to the closest parent component.
-	 * Must be called during component initialisation. Useful, for example, if you
-	 * programmatically create a component and want to pass the existing context to it.
+	 * Retrieves the whole context map that belongs to the current component, including entries
+	 * inherited from its ancestors. Must be called during component initialisation. Useful, for
+	 * example, if you programmatically create a component and want to pass the existing context to it.
 	 *
 	 * */
 	export function getAllContexts<T extends Map<any, any> = Map<any, any>>(): T;
@@ -1708,6 +1711,15 @@ declare module 'svelte/compiler' {
 
 		export interface StyleSheetBase extends BaseNode {
 			children: Array<Atrule | Rule>;
+			/** CSS comments in source order */
+			comments: CSSComment[];
+		}
+
+		export interface CSSComment extends BaseNode {
+			type: 'CSSComment';
+			value: string;
+			/** Character offset in a containing declaration value or at-rule prelude */
+			position?: number;
 		}
 
 		export interface StyleSheetFile extends StyleSheetBase {
@@ -1779,6 +1791,7 @@ declare module 'svelte/compiler' {
 		export interface TypeSelector extends BaseNode {
 			type: 'TypeSelector';
 			name: string;
+			namespace?: string;
 		}
 
 		export interface IdSelector extends BaseNode {
@@ -1802,6 +1815,7 @@ declare module 'svelte/compiler' {
 		export interface PseudoElementSelector extends BaseNode {
 			type: 'PseudoElementSelector';
 			name: string;
+			args?: SelectorList;
 		}
 
 		export interface PseudoClassSelector extends BaseNode {
@@ -1868,72 +1882,167 @@ declare module 'svelte/compiler' {
 	type Options = {
 		getLeadingComments?: NonNullable<Parameters<typeof ts>[0]>['getLeadingComments'] | undefined;
 		getTrailingComments?: NonNullable<Parameters<typeof ts>[0]>['getTrailingComments'] | undefined;
+		indent?: string; // default tab
 	};
 
 	export {};
 }
 
 declare module 'svelte/easing' {
+	/**
+	 * Returns value as is.
+	 *
+	 * */
 	export function linear(t: number): number;
-
+	/**
+	 * Rebound effect on start and end of value range.
+	 *
+	 * */
 	export function backInOut(t: number): number;
-
+	/**
+	 * Rebound effect on start.
+	 *
+	 * */
 	export function backIn(t: number): number;
-
+	/**
+	 * Rebound effect on end.
+	 *
+	 * */
 	export function backOut(t: number): number;
-
+	/**
+	 * Bounce effect on end.
+	 *
+	 * */
 	export function bounceOut(t: number): number;
-
+	/**
+	 * Bounce effect on start and end.
+	 *
+	 * */
 	export function bounceInOut(t: number): number;
-
+	/**
+	 * Bounce effect on start.
+	 *
+	 * */
 	export function bounceIn(t: number): number;
-
+	/**
+	 * Circular effect, accelerate on start, decelerate towards end.
+	 *
+	 * */
 	export function circInOut(t: number): number;
-
+	/**
+	 * Circular effect, accelerate on start.
+	 *
+	 * */
 	export function circIn(t: number): number;
-
+	/**
+	 * Circular effect, decelerate towards end.
+	 *
+	 * */
 	export function circOut(t: number): number;
-
+	/**
+	 * Cubic scaling, accelerate on start, decelerate towards end.
+	 *
+	 * */
 	export function cubicInOut(t: number): number;
-
+	/**
+	 * Cubic scaling, accelerate on start
+	 *
+	 * */
 	export function cubicIn(t: number): number;
-
+	/**
+	 * Cubic scaling, decelerate towards end.
+	 *
+	 * */
 	export function cubicOut(t: number): number;
-
+	/**
+	 * Elastic effect on start and end.
+	 *
+	 * */
 	export function elasticInOut(t: number): number;
-
+	/**
+	 * Elastic effect on start.
+	 *
+	 * */
 	export function elasticIn(t: number): number;
-
+	/**
+	 * Elastic effect on end.
+	 *
+	 * */
 	export function elasticOut(t: number): number;
-
+	/**
+	 * Exponential effect on start and end.
+	 *
+	 * */
 	export function expoInOut(t: number): number;
-
+	/**
+	 * Exponential effect on start.
+	 *
+	 * */
 	export function expoIn(t: number): number;
-
+	/**
+	 * Exponential effect on end.
+	 *
+	 * */
 	export function expoOut(t: number): number;
-
+	/**
+	 * Quadratic scaling, accelerate on start, decelerate towards end.
+	 *
+	 * */
 	export function quadInOut(t: number): number;
-
+	/**
+	 * Quadratic scaling, accelerate on start.
+	 *
+	 * */
 	export function quadIn(t: number): number;
-
+	/**
+	 * Quadratic scaling, decelerate towards end.
+	 *
+	 * */
 	export function quadOut(t: number): number;
-
+	/**
+	 * Quartic scaling, accelerate on start, decelerate towards end.
+	 *
+	 * */
 	export function quartInOut(t: number): number;
-
+	/**
+	 * Quartic scaling, accelerate on start.
+	 *
+	 * */
 	export function quartIn(t: number): number;
-
+	/**
+	 * Quartic scaling, decelerate towards end.
+	 *
+	 * */
 	export function quartOut(t: number): number;
-
+	/**
+	 * Quintic scaling, accelerate on start, decelerate towards end.
+	 *
+	 * */
 	export function quintInOut(t: number): number;
-
+	/**
+	 * Quintic scaling, accelerate on start.
+	 *
+	 * */
 	export function quintIn(t: number): number;
-
+	/**
+	 * Quintic scaling, decelerate towards end.
+	 *
+	 * */
 	export function quintOut(t: number): number;
-
+	/**
+	 * Sinusoidal effect, accelerate on start, decelerate towards end.
+	 *
+	 * */
 	export function sineInOut(t: number): number;
-
+	/**
+	 * Sinusoidal effect, accelerate on start.
+	 *
+	 * */
 	export function sineIn(t: number): number;
-
+	/**
+	 * Sinusoidal effect, decelerate towards end.
+	 *
+	 * */
 	export function sineOut(t: number): number;
 
 	export {};
@@ -2615,11 +2724,11 @@ declare module 'svelte/server' {
 					}
 				]
 	): RenderOutput;
-	type Csp = { nonce?: string; hash?: boolean };
+	export type Csp = { nonce?: string; hash?: boolean };
 
-	type Sha256Source = `sha256-${string}`;
+	export type Sha256Source = `sha256-${string}`;
 
-	interface SyncRenderOutput {
+	export interface SyncRenderOutput {
 		/** HTML that goes into the `<head>` */
 		head: string;
 		/** @deprecated use `body` instead */
@@ -2631,7 +2740,7 @@ declare module 'svelte/server' {
 		};
 	}
 
-	type RenderOutput = SyncRenderOutput & PromiseLike<SyncRenderOutput>;
+	export type RenderOutput = SyncRenderOutput & PromiseLike<SyncRenderOutput>;
 
 	export {};
 }
@@ -3480,7 +3589,7 @@ declare function $effect(fn: () => void | (() => void)): void;
 declare namespace $effect {
 	/**
 	 * Runs code right before a component is mounted to the DOM, and then whenever its dependencies change, i.e. `$state` or `$derived` values.
-	 * The timing of the execution is right before the DOM is updated.
+	 * The timing of the execution is right before the DOM that comes after it is updated; parent DOM may already have been updated by the time it runs.
 	 *
 	 * Example:
 	 * ```ts
diff --git a/playgrounds/sandbox/package.json b/playgrounds/sandbox/package.json
index 12676777cb..bb7f5f0c81 100644
--- a/playgrounds/sandbox/package.json
+++ b/playgrounds/sandbox/package.json
@@ -21,7 +21,7 @@
     "polka": "^1.0.0-next.25",
     "svelte": "workspace:*",
     "tinyglobby": "^0.2.12",
-    "vite": "^7.3.2",
+    "vite": "^7.3.5",
     "vite-plugin-devtools-json": "^1.0.0",
     "vite-plugin-inspect": "^11.3.3"
   }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6331fd0789..70dcf70e5b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,6 +8,9 @@ importers:
 
   .:
     devDependencies:
+      '@changesets/changelog-github':
+        specifier: 1.0.0-next.6
+        version: 1.0.0-next.6
       '@changesets/cli':
         specifier: ^2.29.8
         version: 2.29.8(@types/node@20.19.17)
@@ -17,9 +20,6 @@ importers:
       '@sveltejs/eslint-config':
         specifier: ^9.0.0
         version: 9.0.0(@eslint/js@10.0.1(eslint@10.0.0))(@stylistic/eslint-plugin-js@1.8.0(eslint@10.0.0))(eslint-config-prettier@9.1.0(eslint@10.0.0))(eslint-plugin-n@17.24.0(eslint@10.0.0)(typescript@5.5.4))(eslint-plugin-svelte@3.15.0(eslint@10.0.0)(svelte@packages+svelte))(eslint@10.0.0)(typescript-eslint@8.56.0(eslint@10.0.0)(typescript@5.5.4))(typescript@5.5.4)
-      '@svitejs/changesets-changelog-github-compact':
-        specifier: ^1.1.0
-        version: 1.1.0
       '@types/node':
         specifier: ^20.11.5
         version: 20.19.17
@@ -64,7 +64,7 @@ importers:
         version: 1.2.5
       vitest:
         specifier: ^4.1.7
-        version: 4.1.7(@types/node@20.19.17)(@vitest/coverage-v8@4.1.7)(jsdom@25.0.1)(vite@7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+        version: 4.1.7(@types/node@20.19.17)(@vitest/coverage-v8@4.1.7)(jsdom@25.0.1)(vite@7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
 
   packages/svelte:
     dependencies:
@@ -164,7 +164,7 @@ importers:
         version: 5.5.4
       vitest:
         specifier: ^4.1.7
-        version: 4.1.7(@types/node@20.19.17)(@vitest/coverage-v8@4.1.7)(jsdom@25.0.1)(vite@7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+        version: 4.1.7(@types/node@20.19.17)(@vitest/coverage-v8@4.1.7)(jsdom@25.0.1)(vite@7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
       web-features:
         specifier: ^3.29.0
         version: 3.29.0
@@ -173,7 +173,7 @@ importers:
     devDependencies:
       '@sveltejs/vite-plugin-svelte':
         specifier: ^6.2.0
-        version: 6.2.0(svelte@packages+svelte)(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+        version: 6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
       '@types/node':
         specifier: ^24.5.2
         version: 24.5.2
@@ -187,14 +187,14 @@ importers:
         specifier: ^0.2.12
         version: 0.2.15
       vite:
-        specifier: ^7.3.2
-        version: 7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+        specifier: ^7.3.5
+        version: 7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
       vite-plugin-devtools-json:
         specifier: ^1.0.0
-        version: 1.0.0(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+        version: 1.0.0(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
       vite-plugin-inspect:
         specifier: ^11.3.3
-        version: 11.3.3(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+        version: 11.3.3(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
 
 packages:
 
@@ -236,6 +236,10 @@ packages:
   '@changesets/changelog-git@0.2.1':
     resolution: {integrity: sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q==}
 
+  '@changesets/changelog-github@1.0.0-next.6':
+    resolution: {integrity: sha512-0ShCWgNt50xP0mryAYT8wtSkMUinG8uhxXgCgwHZ4UvJnR2f4ns8OsGAxYu8FIds7kHFdLOz7qX4YQ6AX4tVUA==}
+    engines: {node: ^22.11 || ^24 || >=26}
+
   '@changesets/cli@2.29.8':
     resolution: {integrity: sha512-1weuGZpP63YWUYjay/E84qqwcnt5yJMM0tep10Up7Q5cS/DGe2IZ0Uj3HNMxGhCINZuR7aO9WBMdKnPit5ZDPA==}
     hasBin: true
@@ -249,8 +253,9 @@ packages:
   '@changesets/get-dependents-graph@2.1.3':
     resolution: {integrity: sha512-gphr+v0mv2I3Oxt19VdWRRUxq3sseyUpX9DaHpTUmLj92Y10AGy+XOtV+kbM6L/fDcpx7/ISDFK6T8A/P3lOdQ==}
 
-  '@changesets/get-github-info@0.5.2':
-    resolution: {integrity: sha512-JppheLu7S114aEs157fOZDjFqUDpm7eHdq5E8SSR0gUBTEK0cNSHsrSR5a66xs0z3RWuo46QvA3vawp8BxDHvg==}
+  '@changesets/get-github-info@1.0.0-next.4':
+    resolution: {integrity: sha512-Bosh+XOoFvLMzAj301tg6phbrEggBtvEccrnceEvYsKSM7PjcIa32Fy22SU5g+501HZywkdwcAlybdWF+e/zzw==}
+    engines: {node: ^22.11 || ^24 || >=26}
 
   '@changesets/get-release-plan@4.0.14':
     resolution: {integrity: sha512-yjZMHpUHgl4Xl5gRlolVuxDkm4HgSJqT93Ri1Uz8kGrQb+5iJ8dkXJ20M2j/Y4iV5QzS2c5SeTxVSKX+2eMI0g==}
@@ -282,6 +287,10 @@ packages:
   '@changesets/types@6.1.0':
     resolution: {integrity: sha512-rKQcJ+o1nKNgeoYRHKOS07tAMNd3YSN0uHaJOZYjBAgxfV7TUE7JE+z4BzZdQwb5hKaYbayKN5KrYV7ODb2rAA==}
 
+  '@changesets/types@7.0.0-next.7':
+    resolution: {integrity: sha512-1XyshLw+lRCg2DWxi1Qt3hbezjBostHzXvGXVgSzAeZ+fL+r2ikcMbpaQ98D9ivwKhYFf1FBbKbEc+XsBZsIJQ==}
+    engines: {node: ^22.11 || ^24 || >=26}
+
   '@changesets/write@0.4.0':
     resolution: {integrity: sha512-CdTLvIOPiCNuH71pyDu3rA+Q0n65cmAbXnwWH84rKGiFumFzkmHNT8KHTMEchcxN+Kl8I54xGUhJ7l3E7X396Q==}
 
@@ -772,126 +781,251 @@ packages:
     cpu: [arm]
     os: [android]
 
+  '@rollup/rollup-android-arm-eabi@4.62.2':
+    resolution: {integrity: sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==}
+    cpu: [arm]
+    os: [android]
+
   '@rollup/rollup-android-arm64@4.60.1':
     resolution: {integrity: sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==}
     cpu: [arm64]
     os: [android]
 
+  '@rollup/rollup-android-arm64@4.62.2':
+    resolution: {integrity: sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==}
+    cpu: [arm64]
+    os: [android]
+
   '@rollup/rollup-darwin-arm64@4.60.1':
     resolution: {integrity: sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==}
     cpu: [arm64]
     os: [darwin]
 
+  '@rollup/rollup-darwin-arm64@4.62.2':
+    resolution: {integrity: sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==}
+    cpu: [arm64]
+    os: [darwin]
+
   '@rollup/rollup-darwin-x64@4.60.1':
     resolution: {integrity: sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==}
     cpu: [x64]
     os: [darwin]
 
+  '@rollup/rollup-darwin-x64@4.62.2':
+    resolution: {integrity: sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==}
+    cpu: [x64]
+    os: [darwin]
+
   '@rollup/rollup-freebsd-arm64@4.60.1':
     resolution: {integrity: sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==}
     cpu: [arm64]
     os: [freebsd]
 
+  '@rollup/rollup-freebsd-arm64@4.62.2':
+    resolution: {integrity: sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==}
+    cpu: [arm64]
+    os: [freebsd]
+
   '@rollup/rollup-freebsd-x64@4.60.1':
     resolution: {integrity: sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==}
     cpu: [x64]
     os: [freebsd]
 
+  '@rollup/rollup-freebsd-x64@4.62.2':
+    resolution: {integrity: sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==}
+    cpu: [x64]
+    os: [freebsd]
+
   '@rollup/rollup-linux-arm-gnueabihf@4.60.1':
     resolution: {integrity: sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==}
     cpu: [arm]
     os: [linux]
 
+  '@rollup/rollup-linux-arm-gnueabihf@4.62.2':
+    resolution: {integrity: sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==}
+    cpu: [arm]
+    os: [linux]
+
   '@rollup/rollup-linux-arm-musleabihf@4.60.1':
     resolution: {integrity: sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==}
     cpu: [arm]
     os: [linux]
 
+  '@rollup/rollup-linux-arm-musleabihf@4.62.2':
+    resolution: {integrity: sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==}
+    cpu: [arm]
+    os: [linux]
+
   '@rollup/rollup-linux-arm64-gnu@4.60.1':
     resolution: {integrity: sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==}
     cpu: [arm64]
     os: [linux]
 
+  '@rollup/rollup-linux-arm64-gnu@4.62.2':
+    resolution: {integrity: sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==}
+    cpu: [arm64]
+    os: [linux]
+
   '@rollup/rollup-linux-arm64-musl@4.60.1':
     resolution: {integrity: sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==}
     cpu: [arm64]
     os: [linux]
 
+  '@rollup/rollup-linux-arm64-musl@4.62.2':
+    resolution: {integrity: sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==}
+    cpu: [arm64]
+    os: [linux]
+
   '@rollup/rollup-linux-loong64-gnu@4.60.1':
     resolution: {integrity: sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==}
     cpu: [loong64]
     os: [linux]
 
+  '@rollup/rollup-linux-loong64-gnu@4.62.2':
+    resolution: {integrity: sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==}
+    cpu: [loong64]
+    os: [linux]
+
   '@rollup/rollup-linux-loong64-musl@4.60.1':
     resolution: {integrity: sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==}
     cpu: [loong64]
     os: [linux]
 
+  '@rollup/rollup-linux-loong64-musl@4.62.2':
+    resolution: {integrity: sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==}
+    cpu: [loong64]
+    os: [linux]
+
   '@rollup/rollup-linux-ppc64-gnu@4.60.1':
     resolution: {integrity: sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==}
     cpu: [ppc64]
     os: [linux]
 
+  '@rollup/rollup-linux-ppc64-gnu@4.62.2':
+    resolution: {integrity: sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==}
+    cpu: [ppc64]
+    os: [linux]
+
   '@rollup/rollup-linux-ppc64-musl@4.60.1':
     resolution: {integrity: sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==}
     cpu: [ppc64]
     os: [linux]
 
+  '@rollup/rollup-linux-ppc64-musl@4.62.2':
+    resolution: {integrity: sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==}
+    cpu: [ppc64]
+    os: [linux]
+
   '@rollup/rollup-linux-riscv64-gnu@4.60.1':
     resolution: {integrity: sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==}
     cpu: [riscv64]
     os: [linux]
 
+  '@rollup/rollup-linux-riscv64-gnu@4.62.2':
+    resolution: {integrity: sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==}
+    cpu: [riscv64]
+    os: [linux]
+
   '@rollup/rollup-linux-riscv64-musl@4.60.1':
     resolution: {integrity: sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==}
     cpu: [riscv64]
     os: [linux]
 
+  '@rollup/rollup-linux-riscv64-musl@4.62.2':
+    resolution: {integrity: sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==}
+    cpu: [riscv64]
+    os: [linux]
+
   '@rollup/rollup-linux-s390x-gnu@4.60.1':
     resolution: {integrity: sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==}
     cpu: [s390x]
     os: [linux]
 
+  '@rollup/rollup-linux-s390x-gnu@4.62.2':
+    resolution: {integrity: sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==}
+    cpu: [s390x]
+    os: [linux]
+
   '@rollup/rollup-linux-x64-gnu@4.60.1':
     resolution: {integrity: sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==}
     cpu: [x64]
     os: [linux]
 
+  '@rollup/rollup-linux-x64-gnu@4.62.2':
+    resolution: {integrity: sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==}
+    cpu: [x64]
+    os: [linux]
+
   '@rollup/rollup-linux-x64-musl@4.60.1':
     resolution: {integrity: sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==}
     cpu: [x64]
     os: [linux]
 
+  '@rollup/rollup-linux-x64-musl@4.62.2':
+    resolution: {integrity: sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==}
+    cpu: [x64]
+    os: [linux]
+
   '@rollup/rollup-openbsd-x64@4.60.1':
     resolution: {integrity: sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==}
     cpu: [x64]
     os: [openbsd]
 
+  '@rollup/rollup-openbsd-x64@4.62.2':
+    resolution: {integrity: sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==}
+    cpu: [x64]
+    os: [openbsd]
+
   '@rollup/rollup-openharmony-arm64@4.60.1':
     resolution: {integrity: sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==}
     cpu: [arm64]
     os: [openharmony]
 
+  '@rollup/rollup-openharmony-arm64@4.62.2':
+    resolution: {integrity: sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==}
+    cpu: [arm64]
+    os: [openharmony]
+
   '@rollup/rollup-win32-arm64-msvc@4.60.1':
     resolution: {integrity: sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==}
     cpu: [arm64]
     os: [win32]
 
+  '@rollup/rollup-win32-arm64-msvc@4.62.2':
+    resolution: {integrity: sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==}
+    cpu: [arm64]
+    os: [win32]
+
   '@rollup/rollup-win32-ia32-msvc@4.60.1':
     resolution: {integrity: sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==}
     cpu: [ia32]
     os: [win32]
 
+  '@rollup/rollup-win32-ia32-msvc@4.62.2':
+    resolution: {integrity: sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==}
+    cpu: [ia32]
+    os: [win32]
+
   '@rollup/rollup-win32-x64-gnu@4.60.1':
     resolution: {integrity: sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==}
     cpu: [x64]
     os: [win32]
 
+  '@rollup/rollup-win32-x64-gnu@4.62.2':
+    resolution: {integrity: sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==}
+    cpu: [x64]
+    os: [win32]
+
   '@rollup/rollup-win32-x64-msvc@4.60.1':
     resolution: {integrity: sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==}
     cpu: [x64]
     os: [win32]
 
+  '@rollup/rollup-win32-x64-msvc@4.62.2':
+    resolution: {integrity: sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==}
+    cpu: [x64]
+    os: [win32]
+
   '@standard-schema/spec@1.1.0':
     resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
 
@@ -933,11 +1067,6 @@ packages:
       svelte: ^5.0.0
       vite: ^6.3.0 || ^7.0.0
 
-  '@svitejs/changesets-changelog-github-compact@1.1.0':
-    resolution: {integrity: sha512-qhUGGDHcpbY2zpjW3SwqchuW8J/5EzlPFud7xNntHKA7f3a/mx5+g+ruJKFHSAiVZYo30PALt+AyhmPUNKH/Og==}
-    engines: {node: ^14.13.1 || ^16.0.0 || >=18}
-    deprecated: unmaintained
-
   '@types/aria-query@5.0.4':
     resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==}
 
@@ -1229,8 +1358,8 @@ packages:
     resolution: {integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==}
     engines: {node: '>=18'}
 
-  dataloader@1.4.0:
-    resolution: {integrity: sha512-68s5jYdlvasItOJnCuI2Q9s4q98g0pCyL3HrcKJu8KNugUl8ahgmZYg38ysLTgQjjXX3H8CJLkAvWrclWfcalw==}
+  dataloader@2.2.3:
+    resolution: {integrity: sha512-y2krtASINtPFS1rSDjacrFgn1dcUuoREVabwlOGOe4SdxenREqwjwjElAdwvbGM7kgZz9a3KVicWR7vcz8rnzA==}
 
   debug@4.4.3:
     resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
@@ -1283,10 +1412,6 @@ packages:
     resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
     engines: {node: '>=8'}
 
-  dotenv@16.3.2:
-    resolution: {integrity: sha512-HTlk5nmhkm8F6JcdXvHIzaorzCoziNQT9mGxLPVXW8wJF1TiGSL60ZGB4gHWabHOaMmWmhvk2/lPHfnBiT78AQ==}
-    engines: {node: '>=12'}
-
   dts-buddy@0.5.5:
     resolution: {integrity: sha512-Mu5PJuP7C+EqZIwDtW/bG1tVli1UFhRIyW/dERBVBYk28OviTkribu9S2LpDQ0HF2MbkqnjQIkbbE6HnepdNTQ==}
     hasBin: true
@@ -1850,18 +1975,14 @@ packages:
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
+  nanoid@3.3.13:
+    resolution: {integrity: sha512-sPdqC6ByMVVGvF1ynvvMo0/o+oD1VX7DaHhijt1bFgjvBkHBib4t49GoNDhf2NDta4oeUNlaGbSt5K7qjZ955Q==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
   natural-compare@1.4.0:
     resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
 
-  node-fetch@2.7.0:
-    resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
-    engines: {node: 4.x || >=6.0.0}
-    peerDependencies:
-      encoding: ^0.1.0
-    peerDependenciesMeta:
-      encoding:
-        optional: true
-
   normalize-path@3.0.0:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
     engines: {node: '>=0.10.0'}
@@ -1998,6 +2119,10 @@ packages:
     resolution: {integrity: sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==}
     engines: {node: '>=4'}
 
+  postcss@8.5.15:
+    resolution: {integrity: sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==}
+    engines: {node: ^10 || ^12 || >=14}
+
   postcss@8.5.9:
     resolution: {integrity: sha512-7a70Nsot+EMX9fFU3064K/kdHWZqGVY+BADLyXc8Dfv+mTLLVl6JzJpPaCZ2kQL9gIJvKXSLMHhqdRRjwQeFtw==}
     engines: {node: ^10 || ^12 || >=14}
@@ -2067,6 +2192,11 @@ packages:
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
     hasBin: true
 
+  rollup@4.62.2:
+    resolution: {integrity: sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
   rrweb-cssom@0.7.1:
     resolution: {integrity: sha512-TrEMa7JGdVm0UThDJSx7ddw5nVm3UJS9o9CCIZ72B1vSyEZoziDqBYP3XIoi/12lKrJR8rE3jeFHMok2F/Mnsg==}
 
@@ -2101,8 +2231,8 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
-  semver@7.8.4:
-    resolution: {integrity: sha512-rUCObTnP32Q08R2uuIrt7r9PlEonuTmtuXYcW6s5kjdlj3xbnwe+21yXptAUYcMAABLkYYTtnmzb3w3EDZfueA==}
+  semver@7.8.5:
+    resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==}
     engines: {node: '>=10'}
     hasBin: true
 
@@ -2214,6 +2344,10 @@ packages:
     resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
     engines: {node: '>=12.0.0'}
 
+  tinyglobby@0.2.17:
+    resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
+    engines: {node: '>=12.0.0'}
+
   tinyrainbow@3.1.0:
     resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
     engines: {node: '>=14.0.0'}
@@ -2237,9 +2371,6 @@ packages:
     resolution: {integrity: sha512-FRKsF7cz96xIIeMZ82ehjC3xW2E+O2+v11udrDYewUbszngYhsGa8z6YUMMzO9QJZzzyd0nGGXnML/TReX6W8Q==}
     engines: {node: '>=16'}
 
-  tr46@0.0.3:
-    resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
-
   tr46@5.0.0:
     resolution: {integrity: sha512-tk2G5R2KRwBd+ZN0zaEXpmzdKyOYksXwywulIX95MBODjSzMIuQnQ3m8JxgbhnL1LeVo7lqQKsYa1O3Htl7K5g==}
     engines: {node: '>=18'}
@@ -2334,8 +2465,8 @@ packages:
       '@nuxt/kit':
         optional: true
 
-  vite@7.3.2:
-    resolution: {integrity: sha512-Bby3NOsna2jsjfLVOHKes8sGwgl4TT0E6vvpYgnAYDIF/tie7MRaFthmKuHx1NSXjiTueXH3do80FMQgvEktRg==}
+  vite@7.3.5:
+    resolution: {integrity: sha512-KuOaNhcnGFN2zIPGA7wRmzF+lJA1sea7rHq17aiJ++9lzY1WWG6Jpwqwe1KNbRVPIqHmr8GLYx7jbrQcN/7/ww==}
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
     peerDependencies:
@@ -2430,9 +2561,6 @@ packages:
   web-features@3.29.0:
     resolution: {integrity: sha512-r8m0Xj77/PSHXEbv2U3UuLhw5gE4U+YAPek5hCor5DMsS9Qnwtxl5FSfam3dXQo7Gl0gxK9BRrcQLlOBZZZXpw==}
 
-  webidl-conversions@3.0.1:
-    resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
-
   webidl-conversions@7.0.0:
     resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
     engines: {node: '>=12'}
@@ -2450,9 +2578,6 @@ packages:
     resolution: {integrity: sha512-1lfMEm2IEr7RIV+f4lUNPOqfFL+pO+Xw3fJSqmjX9AbXcXcYOkCe1P6+9VBZB6n94af16NfZf+sSk0JCBZC9aw==}
     engines: {node: '>=18'}
 
-  whatwg-url@5.0.0:
-    resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
-
   which@2.0.2:
     resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
     engines: {node: '>= 8'}
@@ -2547,6 +2672,11 @@ snapshots:
     dependencies:
       '@changesets/types': 6.1.0
 
+  '@changesets/changelog-github@1.0.0-next.6':
+    dependencies:
+      '@changesets/get-github-info': 1.0.0-next.4
+      '@changesets/types': 7.0.0-next.7
+
   '@changesets/cli@2.29.8(@types/node@20.19.17)':
     dependencies:
       '@changesets/apply-release-plan': 7.0.14
@@ -2601,12 +2731,9 @@ snapshots:
       picocolors: 1.1.1
       semver: 7.7.4
 
-  '@changesets/get-github-info@0.5.2':
+  '@changesets/get-github-info@1.0.0-next.4':
     dependencies:
-      dataloader: 1.4.0
-      node-fetch: 2.7.0
-    transitivePeerDependencies:
-      - encoding
+      dataloader: 2.2.3
 
   '@changesets/get-release-plan@4.0.14':
     dependencies:
@@ -2662,6 +2789,8 @@ snapshots:
 
   '@changesets/types@6.1.0': {}
 
+  '@changesets/types@7.0.0-next.7': {}
+
   '@changesets/write@0.4.0':
     dependencies:
       '@changesets/types': 6.1.0
@@ -2991,78 +3120,153 @@ snapshots:
   '@rollup/rollup-android-arm-eabi@4.60.1':
     optional: true
 
+  '@rollup/rollup-android-arm-eabi@4.62.2':
+    optional: true
+
   '@rollup/rollup-android-arm64@4.60.1':
     optional: true
 
+  '@rollup/rollup-android-arm64@4.62.2':
+    optional: true
+
   '@rollup/rollup-darwin-arm64@4.60.1':
     optional: true
 
+  '@rollup/rollup-darwin-arm64@4.62.2':
+    optional: true
+
   '@rollup/rollup-darwin-x64@4.60.1':
     optional: true
 
+  '@rollup/rollup-darwin-x64@4.62.2':
+    optional: true
+
   '@rollup/rollup-freebsd-arm64@4.60.1':
     optional: true
 
+  '@rollup/rollup-freebsd-arm64@4.62.2':
+    optional: true
+
   '@rollup/rollup-freebsd-x64@4.60.1':
     optional: true
 
+  '@rollup/rollup-freebsd-x64@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-arm-gnueabihf@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-arm-gnueabihf@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-arm-musleabihf@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-arm-musleabihf@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-arm64-gnu@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-arm64-gnu@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-arm64-musl@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-arm64-musl@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-loong64-gnu@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-loong64-gnu@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-loong64-musl@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-loong64-musl@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-ppc64-gnu@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-ppc64-gnu@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-ppc64-musl@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-ppc64-musl@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-riscv64-gnu@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-riscv64-gnu@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-riscv64-musl@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-riscv64-musl@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-s390x-gnu@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-s390x-gnu@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-x64-gnu@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-x64-gnu@4.62.2':
+    optional: true
+
   '@rollup/rollup-linux-x64-musl@4.60.1':
     optional: true
 
+  '@rollup/rollup-linux-x64-musl@4.62.2':
+    optional: true
+
   '@rollup/rollup-openbsd-x64@4.60.1':
     optional: true
 
+  '@rollup/rollup-openbsd-x64@4.62.2':
+    optional: true
+
   '@rollup/rollup-openharmony-arm64@4.60.1':
     optional: true
 
+  '@rollup/rollup-openharmony-arm64@4.62.2':
+    optional: true
+
   '@rollup/rollup-win32-arm64-msvc@4.60.1':
     optional: true
 
+  '@rollup/rollup-win32-arm64-msvc@4.62.2':
+    optional: true
+
   '@rollup/rollup-win32-ia32-msvc@4.60.1':
     optional: true
 
+  '@rollup/rollup-win32-ia32-msvc@4.62.2':
+    optional: true
+
   '@rollup/rollup-win32-x64-gnu@4.60.1':
     optional: true
 
+  '@rollup/rollup-win32-x64-gnu@4.62.2':
+    optional: true
+
   '@rollup/rollup-win32-x64-msvc@4.60.1':
     optional: true
 
+  '@rollup/rollup-win32-x64-msvc@4.62.2':
+    optional: true
+
   '@standard-schema/spec@1.1.0': {}
 
   '@stylistic/eslint-plugin-js@1.8.0(eslint@10.0.0)':
@@ -3090,34 +3294,27 @@ snapshots:
       typescript: 5.5.4
       typescript-eslint: 8.56.0(eslint@10.0.0)(typescript@5.5.4)
 
-  '@sveltejs/vite-plugin-svelte-inspector@5.0.1(@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)))(svelte@packages+svelte)(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
+  '@sveltejs/vite-plugin-svelte-inspector@5.0.1(@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)))(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
     dependencies:
-      '@sveltejs/vite-plugin-svelte': 6.2.0(svelte@packages+svelte)(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+      '@sveltejs/vite-plugin-svelte': 6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
       debug: 4.4.3
       svelte: link:packages/svelte
-      vite: 7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vite: 7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
     transitivePeerDependencies:
       - supports-color
 
-  '@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
+  '@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
     dependencies:
-      '@sveltejs/vite-plugin-svelte-inspector': 5.0.1(@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)))(svelte@packages+svelte)(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+      '@sveltejs/vite-plugin-svelte-inspector': 5.0.1(@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)))(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
       debug: 4.4.3
       deepmerge: 4.3.1
       magic-string: 0.30.17
       svelte: link:packages/svelte
-      vite: 7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
-      vitefu: 1.1.1(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+      vite: 7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vitefu: 1.1.1(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
     transitivePeerDependencies:
       - supports-color
 
-  '@svitejs/changesets-changelog-github-compact@1.1.0':
-    dependencies:
-      '@changesets/get-github-info': 0.5.2
-      dotenv: 16.3.2
-    transitivePeerDependencies:
-      - encoding
-
   '@types/aria-query@5.0.4': {}
 
   '@types/chai@5.2.3':
@@ -3228,7 +3425,7 @@ snapshots:
       debug: 4.4.3
       minimatch: 9.0.5
       semver: 7.7.4
-      tinyglobby: 0.2.15
+      tinyglobby: 0.2.17
       ts-api-utils: 2.4.0(typescript@5.5.4)
       typescript: 5.5.4
     transitivePeerDependencies:
@@ -3262,7 +3459,7 @@ snapshots:
       obug: 2.1.1
       std-env: 4.1.0
       tinyrainbow: 3.1.0
-      vitest: 4.1.7(@types/node@20.19.17)(@vitest/coverage-v8@4.1.7)(jsdom@25.0.1)(vite@7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+      vitest: 4.1.7(@types/node@20.19.17)(@vitest/coverage-v8@4.1.7)(jsdom@25.0.1)(vite@7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
 
   '@vitest/expect@4.1.7':
     dependencies:
@@ -3273,13 +3470,13 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.1.0
 
-  '@vitest/mocker@4.1.7(vite@7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
+  '@vitest/mocker@4.1.7(vite@7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
     dependencies:
       '@vitest/spy': 4.1.7
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vite: 7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
 
   '@vitest/pretty-format@4.1.7':
     dependencies:
@@ -3439,7 +3636,7 @@ snapshots:
       whatwg-mimetype: 4.0.0
       whatwg-url: 14.0.0
 
-  dataloader@1.4.0: {}
+  dataloader@2.2.3: {}
 
   debug@4.4.3:
     dependencies:
@@ -3473,8 +3670,6 @@ snapshots:
     dependencies:
       path-type: 4.0.0
 
-  dotenv@16.3.2: {}
-
   dts-buddy@0.5.5(typescript@5.5.4):
     dependencies:
       '@jridgewell/source-map': 0.3.6
@@ -3566,7 +3761,7 @@ snapshots:
   eslint-compat-utils@0.5.1(eslint@10.0.0):
     dependencies:
       eslint: 10.0.0
-      semver: 7.8.4
+      semver: 7.8.5
 
   eslint-config-prettier@9.1.0(eslint@10.0.0):
     dependencies:
@@ -3593,7 +3788,7 @@ snapshots:
       globals: 15.15.0
       globrex: 0.1.2
       ignore: 5.3.2
-      semver: 7.8.4
+      semver: 7.8.5
       ts-declaration-location: 1.0.7(typescript@5.5.4)
     transitivePeerDependencies:
       - typescript
@@ -4093,11 +4288,9 @@ snapshots:
 
   nanoid@3.3.11: {}
 
-  natural-compare@1.4.0: {}
+  nanoid@3.3.13: {}
 
-  node-fetch@2.7.0:
-    dependencies:
-      whatwg-url: 5.0.0
+  natural-compare@1.4.0: {}
 
   normalize-path@3.0.0:
     optional: true
@@ -4202,15 +4395,21 @@ snapshots:
     dependencies:
       postcss: 8.5.9
 
-  postcss-scss@4.0.9(postcss@8.5.9):
+  postcss-scss@4.0.9(postcss@8.5.15):
     dependencies:
-      postcss: 8.5.9
+      postcss: 8.5.15
 
   postcss-selector-parser@7.1.0:
     dependencies:
       cssesc: 3.0.0
       util-deprecate: 1.0.2
 
+  postcss@8.5.15:
+    dependencies:
+      nanoid: 3.3.13
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
   postcss@8.5.9:
     dependencies:
       nanoid: 3.3.11
@@ -4295,6 +4494,37 @@ snapshots:
       '@rollup/rollup-win32-x64-msvc': 4.60.1
       fsevents: 2.3.3
 
+  rollup@4.62.2:
+    dependencies:
+      '@types/estree': 1.0.9
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.62.2
+      '@rollup/rollup-android-arm64': 4.62.2
+      '@rollup/rollup-darwin-arm64': 4.62.2
+      '@rollup/rollup-darwin-x64': 4.62.2
+      '@rollup/rollup-freebsd-arm64': 4.62.2
+      '@rollup/rollup-freebsd-x64': 4.62.2
+      '@rollup/rollup-linux-arm-gnueabihf': 4.62.2
+      '@rollup/rollup-linux-arm-musleabihf': 4.62.2
+      '@rollup/rollup-linux-arm64-gnu': 4.62.2
+      '@rollup/rollup-linux-arm64-musl': 4.62.2
+      '@rollup/rollup-linux-loong64-gnu': 4.62.2
+      '@rollup/rollup-linux-loong64-musl': 4.62.2
+      '@rollup/rollup-linux-ppc64-gnu': 4.62.2
+      '@rollup/rollup-linux-ppc64-musl': 4.62.2
+      '@rollup/rollup-linux-riscv64-gnu': 4.62.2
+      '@rollup/rollup-linux-riscv64-musl': 4.62.2
+      '@rollup/rollup-linux-s390x-gnu': 4.62.2
+      '@rollup/rollup-linux-x64-gnu': 4.62.2
+      '@rollup/rollup-linux-x64-musl': 4.62.2
+      '@rollup/rollup-openbsd-x64': 4.62.2
+      '@rollup/rollup-openharmony-arm64': 4.62.2
+      '@rollup/rollup-win32-arm64-msvc': 4.62.2
+      '@rollup/rollup-win32-ia32-msvc': 4.62.2
+      '@rollup/rollup-win32-x64-gnu': 4.62.2
+      '@rollup/rollup-win32-x64-msvc': 4.62.2
+      fsevents: 2.3.3
+
   rrweb-cssom@0.7.1: {}
 
   run-applescript@7.0.0: {}
@@ -4324,7 +4554,7 @@ snapshots:
 
   semver@7.7.4: {}
 
-  semver@7.8.4: {}
+  semver@7.8.5: {}
 
   serialize-javascript@6.0.2:
     dependencies:
@@ -4389,8 +4619,8 @@ snapshots:
       eslint-scope: 8.4.0
       eslint-visitor-keys: 4.2.1
       espree: 10.1.0
-      postcss: 8.5.9
-      postcss-scss: 4.0.9(postcss@8.5.9)
+      postcss: 8.5.15
+      postcss-scss: 4.0.9(postcss@8.5.15)
       postcss-selector-parser: 7.1.0
     optionalDependencies:
       svelte: link:packages/svelte
@@ -4417,6 +4647,11 @@ snapshots:
       fdir: 6.5.0(picomatch@4.0.4)
       picomatch: 4.0.4
 
+  tinyglobby@0.2.17:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.4)
+      picomatch: 4.0.4
+
   tinyrainbow@3.1.0: {}
 
   tldts-core@6.1.64: {}
@@ -4435,8 +4670,6 @@ snapshots:
     dependencies:
       tldts: 6.1.64
 
-  tr46@0.0.3: {}
-
   tr46@5.0.0:
     dependencies:
       punycode: 2.3.1
@@ -4496,22 +4729,22 @@ snapshots:
 
   v8-natives@1.2.5: {}
 
-  vite-dev-rpc@1.1.0(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
+  vite-dev-rpc@1.1.0(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
     dependencies:
       birpc: 2.5.0
-      vite: 7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
-      vite-hot-client: 2.1.0(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+      vite: 7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vite-hot-client: 2.1.0(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
 
-  vite-hot-client@2.1.0(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
+  vite-hot-client@2.1.0(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
     dependencies:
-      vite: 7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vite: 7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
 
-  vite-plugin-devtools-json@1.0.0(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
+  vite-plugin-devtools-json@1.0.0(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
     dependencies:
       uuid: 11.1.0
-      vite: 7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vite: 7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
 
-  vite-plugin-inspect@11.3.3(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
+  vite-plugin-inspect@11.3.3(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
     dependencies:
       ansis: 4.1.0
       debug: 4.4.3
@@ -4521,19 +4754,19 @@ snapshots:
       perfect-debounce: 2.0.0
       sirv: 3.0.2
       unplugin-utils: 0.3.0
-      vite: 7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
-      vite-dev-rpc: 1.1.0(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+      vite: 7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vite-dev-rpc: 1.1.0(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
     transitivePeerDependencies:
       - supports-color
 
-  vite@7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0):
+  vite@7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0):
     dependencies:
       esbuild: 0.27.7
       fdir: 6.5.0(picomatch@4.0.4)
       picomatch: 4.0.4
-      postcss: 8.5.9
-      rollup: 4.60.1
-      tinyglobby: 0.2.15
+      postcss: 8.5.15
+      rollup: 4.62.2
+      tinyglobby: 0.2.17
     optionalDependencies:
       '@types/node': 20.19.17
       fsevents: 2.3.3
@@ -4541,14 +4774,14 @@ snapshots:
       sass: 1.70.0
       terser: 5.27.0
 
-  vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0):
+  vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0):
     dependencies:
       esbuild: 0.27.7
       fdir: 6.5.0(picomatch@4.0.4)
       picomatch: 4.0.4
-      postcss: 8.5.9
-      rollup: 4.60.1
-      tinyglobby: 0.2.15
+      postcss: 8.5.15
+      rollup: 4.62.2
+      tinyglobby: 0.2.17
     optionalDependencies:
       '@types/node': 24.5.2
       fsevents: 2.3.3
@@ -4556,14 +4789,14 @@ snapshots:
       sass: 1.70.0
       terser: 5.27.0
 
-  vitefu@1.1.1(vite@7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
+  vitefu@1.1.1(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
     optionalDependencies:
-      vite: 7.3.2(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vite: 7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
 
-  vitest@4.1.7(@types/node@20.19.17)(@vitest/coverage-v8@4.1.7)(jsdom@25.0.1)(vite@7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
+  vitest@4.1.7(@types/node@20.19.17)(@vitest/coverage-v8@4.1.7)(jsdom@25.0.1)(vite@7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)):
     dependencies:
       '@vitest/expect': 4.1.7
-      '@vitest/mocker': 4.1.7(vite@7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
+      '@vitest/mocker': 4.1.7(vite@7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))
       '@vitest/pretty-format': 4.1.7
       '@vitest/runner': 4.1.7
       '@vitest/snapshot': 4.1.7
@@ -4580,7 +4813,7 @@ snapshots:
       tinyexec: 1.1.2
       tinyglobby: 0.2.15
       tinyrainbow: 3.1.0
-      vite: 7.3.2(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
+      vite: 7.3.5(@types/node@20.19.17)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 20.19.17
@@ -4595,8 +4828,6 @@ snapshots:
 
   web-features@3.29.0: {}
 
-  webidl-conversions@3.0.1: {}
-
   webidl-conversions@7.0.0: {}
 
   whatwg-encoding@3.1.1:
@@ -4610,11 +4841,6 @@ snapshots:
       tr46: 5.0.0
       webidl-conversions: 7.0.0
 
-  whatwg-url@5.0.0:
-    dependencies:
-      tr46: 0.0.3
-      webidl-conversions: 3.0.1
-
   which@2.0.2:
     dependencies:
       isexe: 2.0.0
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index f94dac7cc7..8c81497078 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,3 +1,15 @@
+minimumReleaseAge: 2880
+minimumReleaseAgeExclude:
+  - '@sveltejs/*'
+  - svelte
+  - esrap
+  - devalue
+  - zimmerframe
+  - prettier-plugin-svelte
+  - svelte-check
+  - esm-env
+blockExoticSubdeps: true
+
 packages:
   - 'packages/*'
   - 'playgrounds/*'