2504 Commits (stale-batch)

Author	SHA1	Message	Date
Rich Harris	98e8b635fa	fix: discard batches made obsolete by commit (#17934) ... Batches that are made stale (because of a `STALE_REACTION`) can end up sticking around indefinitely, forcing every subsequent batch into time-traveling mode and causing incorrect `previous` values to be rendered. This partially fixes it, by discarding any older batches that are subsets of a batch currently being committed. It's not a complete fix, though — if an earlier batch is stale but is _not_ a subset of the committed batch, it becomes a zombie, and its changes will never be applied. Haven't quite figured out how to think about that yet. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	5 months ago
github-actions[bot]	8b86bdd82d	Version Packages (#17919) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.12 ### Patch Changes - fix: update `select.__value` on `change` ([#17745](https://github.com/sveltejs/svelte/pull/17745)) - chore: add `invariant` helper for debugging ([#17929](https://github.com/sveltejs/svelte/pull/17929)) - fix: ensure deriveds values are correct across batches ([#17917](https://github.com/sveltejs/svelte/pull/17917)) - fix: handle async RHS in `assignment_value_stale` ([#17925](https://github.com/sveltejs/svelte/pull/17925)) - fix: avoid traversing clean roots ([#17928](https://github.com/sveltejs/svelte/pull/17928)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	5 months ago
Simon H	1ebed68322	fix: avoid traversing clean roots (#17928) ... Before #17805, all batches drew from the same `queued_root_effects` and did reset them to the empty array when starting a flush. After the refactoring roots are scheduled per batch. This introduces a possible race condition where the same root is scheduled multiple times. It was possible because of the rebase logic in `#commit` not clearing the array of roots, so if you somehow flush that same batch later, you will end up traversing a clean root. (it is possible a bug like this always existed with rebasing it was just impossible hard to trigger it before because everyone drew from the same root effects array) The fix is a bit more complicated than just checking if new roots where added, we gotta check if we actually created async work before traversing. Fixes #17918 --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	5 months ago
Conduitry	965f2a0ac8	fix: handle async RHS in assignment_value_stale (#17925) ... Fixes #17924. This also DRYs stuff a bit by making `operator` an argument to the runtime helper function, which means we only need two variants of it: regular and async. It also makes it so that `=` assignments don't use the getter, because they don't need to be done lazily. I've added `skip_no_async` to the new test, but I'm not entirely clear on why it was failing the TestNoAsync run to begin with. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint` --------- Co-authored-by: Simon Holthausen <simon.holthausen@vercel.com>	5 months ago
Rich Harris	a513da0445	chore: add invariant utility (#17929) ... With this, we can add invariants to the codebase so we can identify problems like 'this batch already has roots scheduled', which indicate a bug somewhere, without a) needing tests for scenarios that are inherently hard to anticipate, or b) cluttering people's prod bundles	5 months ago
Apoorv Darshan	3dbd95075c	fix: keep select.__value current when effect is deferred (#17745) ... ## Summary Fixes #17148 When a `<select>` is focused inside an async boundary, the `bind_select_value` effect gets deferred by the batch system, leaving `select.__value` stale. If options then change dynamically (e.g. via `{#each}`), the `MutationObserver` in `init_select` uses the stale `__value`, snapping the select to the wrong option. - Update `__value` in the change handler so it's always current, even when the effect is deferred - Update `__value` in the effect's early-return path (defensive fix for when the effect runs but skips the DOM update) ## Test plan - Added `select-dynamic-options-while-focused` test that renders a `<select>` with dynamic `{#each}` options inside an async boundary, selects a non-initial option while focused, adds another option, and verifies the select retains the user's choice - Verified existing `async-binding-update-while-focused-3` test still passes - All 7151 tests pass (`pnpm test`) --------- Co-authored-by: Tee Ming <chewteeming01@gmail.com> Co-authored-by: Rich Harris <rich.harris@vercel.com> Co-authored-by: Rich Harris <hello@rich-harris.dev>	5 months ago
Simon H	44c4f213e9	fix: ensure deriveds values are correct across batches (#17917) ... capture derived updates aswell so they become part of current/previous so that `batch_values` computation is correct when e.g. using `$state.eager` with a derived. Fixes #17849	5 months ago
github-actions[bot]	bd433c5ceb	Version Packages (#17901) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.11 ### Patch Changes - fix: remove `untrack` circular dependency ([#17910](https://github.com/sveltejs/svelte/pull/17910)) - fix: recover from errors that leave a corrupted effect tree ([#17888](https://github.com/sveltejs/svelte/pull/17888)) - fix: properly lazily evaluate RHS when checking for `assignment_value_stale` ([#17906](https://github.com/sveltejs/svelte/pull/17906)) - fix: resolve boundary in correct batch when hydrating ([#17914](https://github.com/sveltejs/svelte/pull/17914)) - chore: rebase batches after process, not during ([#17900](https://github.com/sveltejs/svelte/pull/17900)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	5 months ago
Rich Harris	7c9ff8fc69	fix: resolve boundary in correct batch when hydrating (#17914) ... Fixes #17907. When hydrating, we were resolving the boundary in the hydration batch rather than the batch created inside the `queue_micro_task` inside `#hydrate_pending_content`. This meant that effects got scheduled inside a batch that was already resolved. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	5 months ago
Rich Harris	667896a753	fix: recover from errors that leave a corrupted effect tree (#17888) ... https://github.com/sveltejs/svelte/pull/17680#issuecomment-3888440736. Errors that occur during traversal (not inside a template effect etc) can leave dirty effects inside the effect tree, but with clean parents. This means that a) subsequent changes to their dependencies won't schedule them to re-run b) subsequent batch flushes won't 'reach' them unless a sibling effect happens to be made dirty The easiest way to fix this is to just repair the tree if traversal fails. If you had a truly ginormous tree this could conceivably take a noticeable amount of time, but that's probably better than the app just being broken. Note that this doesn't apply to errors that occur inside an error boundary, because in that case the offending subtree gets destroyed. This is just for errors that bubble all the way to the root. Closes #17680, closes #17679.	5 months ago
Paolo Ricciuti	e4e089310d	fix: remove `untrack` circular dependency (#17910) ... Closes #17899 by importing `untrack` from the actual file instead of the `index-client.js`. Verified by packing the library and launching a build with it.	5 months ago
Conduitry	58f161dee2	fix: properly lazily evaluate RHS when checking for assignment_value_stale (#17906) ... Fixes #17904 by wrapping the RHS in a `() =>`. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	5 months ago
Rich Harris	0e8f49b25f	chore: rebase batches after process, not during (#17900) ... This is part of me trying to figure out #17162. It feels less confusing to rebase other branches after the current batch has been processed, rather than sort of doing it in the middle (which is an artifact of historical constraints that no longer apply). No test because it doesn't change any user-observable behaviour (but I added a changeset just in case) ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [ ] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	5 months ago
github-actions[bot]	72cd247c33	Version Packages (#17896) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.10 ### Patch Changes - fix: re-process batch if new root effects were scheduled ([#17895](https://github.com/sveltejs/svelte/pull/17895)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	5 months ago
Simon H	342d8568f1	fix: re-process batch if new root effects were scheduled (#17895) ... In some cases a new branch might create effects which via reading/writing reschedule an effect, causing `this.#roots` to become populated again. In this case we need to re-process the batch. Most of the time this will just result in a cleanup of the dirtied branches since other work is already handled via running the effects etc. - it's still crucial, else the reactive graph becomes frozen since no new root effects are scheduled. Fixes #17891 --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	5 months ago
github-actions[bot]	d54361b97f	Version Packages (#17886) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.9 ### Patch Changes - fix: better `bind:this` cleanup timing ([#17885](https://github.com/sveltejs/svelte/pull/17885)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	5 months ago
Simon H	be36c934c4	fix: better `bind:this` cleanup timing (#17885) ... This removes the `queue_micro_task`-workaround we employed in `bind:this` in favor of a search for the nearest component effect / effect that is still getting destroyed, whichever comes first. We used `queue_micro_task` mainly due to timing issues with components wanting to access the bound property on teardown still, and when nulling it out on cleanup of the bind-this-effect itself, that was too early. The microtask is too late though in some cases, when accessing properties of objects that are no longer there. The targeted upwards-walk solves this while keeping the binding around as long as needed. For that I had to add a new `DESTROYING` flag. We _could_ have done it without one and by deleting code in `props.js` where we don't do `get(d)` when the prop derived is destroyed, but I wanted to keep that because you could still run into an access error if you e.g. access the property in a timeout. Alternative to #17862	5 months ago
github-actions[bot]	d2b347042c	Version Packages (#17854) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.8 ### Patch Changes - fix: `{@html}` no longer duplicates content inside `contenteditable` elements ([#17853](https://github.com/sveltejs/svelte/pull/17853)) - fix: don't access inert block effects ([#17882](https://github.com/sveltejs/svelte/pull/17882)) - fix: handle asnyc updates within pending boundary ([#17873](https://github.com/sveltejs/svelte/pull/17873)) - perf: avoid re-traversing the effect tree after `$:` assignments ([#17848](https://github.com/sveltejs/svelte/pull/17848)) - chore: simplify scheduling logic ([#17805](https://github.com/sveltejs/svelte/pull/17805)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	5 months ago
Simon H	1892988074	fix: don't access inert block effects (#17882) ... In #17837 we added logic to not schedule another batch during resumption. The logic in there turns out to be flawed - it's dangerous to keep accessing inert block effects, because if they're nested they could access properties that no longer exist (because the outer if makes the inner if obsolete). So this PR basically reverts #17837 and instead schedules another batch again under the assumption that this will only happen during the commit phase, and all that's gonna happen is that it will schedule another batch, which is safe. Fixes #17866 Fixes #17878 This reverts commit 2f12b60701. Co-authored-by: Rich Harris <rich.harris@vercel.com>	5 months ago
Rich Harris	6fb7b4d265	chore: refactor scheduling (#17805) ... This simplifies the scheduling logic and will likely improve performance in some cases. Previously, there was a global `queued_root_effects` array, and we would cycle through the batch flushing logic as long as it was non-empty. This was a very loosey-goosey approach that was appropriate in the pre-async world, but has gradually become a source of confusion. Now, effects are scheduled within the context of a specific batch. The lifecycle is more rigorous and debuggable. This opens the door to explorations of alternative approaches, such as only scheduling effects when we call `batch.flush()`, which _may_ be better than the eager status quo. The layout of the `Batch` class is extremely chaotic — public/private/static fields/methods are all jumbled up together — and I would like to get a grip of it. In the interests of minimising diff noise that ought to be a follow-up rather than part of this PR. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [ ] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint` --------- Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>	5 months ago
Simon H	2deebdea8f	fix: handle asnyc updates within pending boundary (#17873) ... When an async value is updated inside the boundary while the pending snippet is shown, we previously didn't notice that update and instead showed an outdated value once it resolved. This fixes that by rejecting all deferreds inside an async_derived while the pending snippet is shown. --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	5 months ago
dev-miro26	0206a2019e	fix: clean up externally-added DOM nodes in {@html} on re-render (#17853) ... Fixes `{@html}` content duplication when used inside a contenteditable element. When `{@html content}` is inside a contenteditable element and the user types, the browser inserts DOM nodes directly into the {@html} managed region. On re-render (e.g. triggered by a blur handler setting `content = e.currentTarget.innerText`, the `{@html} `block only removed nodes it previously created via` effect.nodes`, leaving browser-inserted nodes in place. This caused content to appear twice — once as leftover text nodes and once as the new `{@html}` output. The fix tracks the boundary node (`previousSibling `of the anchor at init) and removes all nodes between the boundary and the anchor on re-render, ensuring externally-added nodes are also cleaned up. Closes: #16993 --------- Co-authored-by: 7nik <kfiiranet@gmail.com> Co-authored-by: vercel[bot] <35613825+vercel[bot]@users.noreply.github.com>	5 months ago
Rich Harris	2a1f5ada13	perf: avoid re-traversing the effect tree after `$:` assignments (#17848) ... If an assignment happens in a `$:` statement, any affected effects are rescheduled while the traversal is ongoing. But this is wasteful — it results in the `flush_effects` loop running another time, even though the affected effects are guaranteed to be visited _later_ in the traversal (unless the thing being updated is a store). This PR fixes it: inside a `legacy_pre_effect`, we temporarily pretend that the branch _containing_ the component with the `$:` statement is the `active_effect`, such that Svelte understands that any marked effects are about to be visited and thus don't need to be scheduled. We deal with the store case by temporarily pretending that there _is_ no `active_effect`. I will be delighted when we can rip all this legacy stuff out of the codebase. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [ ] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	5 months ago
Rich Harris	7dc864d941	Revert "fix: skip derived re-evaluation inside inert effect blocks" (#17869) ... Reverts sveltejs/svelte#17852, because it isn't a real fix https://github.com/sveltejs/svelte/pull/17868	5 months ago
Rich Harris	e3f06f9fc7	fix: skip derived re-evaluation inside inert effect blocks (#17852) ... this is #17850 with changes (for whatever reason I wasn't able to push direct to the fork) — same test but simplified, and a simpler fix that doesn't undo the recent (necessary!) changes to the scheduling logic --------- Co-authored-by: Mattias Granlund <mtsgrd@gmail.com>	5 months ago
github-actions[bot]	25a1c5368b	Version Packages (#17842) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.7 ### Patch Changes - fix: correctly add \_\_svelte_meta after else-if chains ([#17830](https://github.com/sveltejs/svelte/pull/17830)) - perf: cache element interactivity and source line splitting in compiler ([#17839](https://github.com/sveltejs/svelte/pull/17839)) - chore: avoid rescheduling effects during branch commit ([#17837](https://github.com/sveltejs/svelte/pull/17837)) - perf: optimize CSS selector pruning ([#17846](https://github.com/sveltejs/svelte/pull/17846)) - fix: preserve original boundary errors when keyed each rows are removed during async updates ([#17843](https://github.com/sveltejs/svelte/pull/17843)) - perf: avoid O(n²) name scanning in scope `generate` and `unique` ([#17844](https://github.com/sveltejs/svelte/pull/17844)) - fix: preserve each items that are needed by pending batches ([#17819](https://github.com/sveltejs/svelte/pull/17819)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	5 months ago
Philip Breuer	b7bc1309aa	fix: preserve original boundary errors when keyed each rows are removed during async updates (#17843) ... Fixes a runtime edge case where keyed #each reconciliation can hit a missing item during deferred async updates, causing an internal crash and masking the original boundary error. Fixes #17841 ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [] Run the tests with `pnpm test` and lint the project with `pnpm lint` --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	5 months ago
Mathias Picker	0965028d3b	perf: optimize CSS selector pruning (#17846) ... ## Summary Reduces CSS selector pruning overhead by eliminating unnecessary allocations and redundant work in the hot path. **Changes:** - Replace `.slice()` + `.shift()`/`.pop()` in `apply_selector` with index-based `from`/`to` params — avoids O(n) array copies per recursive call - Merge `has_selectors`/`other_selectors` split in `relative_selector_might_apply_to_node` into a single pass — eliminates 2 temporary array allocations per call - Hoist `name.toLowerCase()` out of the inner loop in `attribute_matches` - Replace `value.split(/\s/).includes()` with `indexOf` + boundary checks in `test_attribute` for `~=` — avoids array allocation on every class match - Skip `name.replace()` regex when selector name has no backslash ## Benchmark Interleaved benchmark (5 rounds, alternating baseline/optimized): ``` --- Round 1 --- Baseline: min=59.58ms median=64.63ms Optimized: min=47.20ms median=54.35ms --- Round 2 --- Baseline: min=59.11ms median=64.90ms Optimized: min=48.36ms median=54.74ms --- Round 3 --- Baseline: min=58.38ms median=64.06ms Optimized: min=48.38ms median=53.83ms --- Round 4 --- Baseline: min=58.49ms median=63.99ms Optimized: min=48.45ms median=53.82ms --- Round 5 --- Baseline: min=58.40ms median=64.07ms Optimized: min=48.97ms median=54.64ms Best min: Before=58.38ms After=47.20ms Improvement=19.1% Best median: Before=63.99ms After=53.82ms Improvement=15.9% ``` CPU profile before → after: | Function | Before | After | |---|---|---| | `relative_selector_might_apply_to_node` | 14.3% | 5.2% | | `attribute_matches` | 4.0% | 3.3% | | `test_attribute` | 3.2% | <0.9% | ## Test plan - [x] All 196 CSS tests pass (180 samples + 16 parse) - [x] All 31 snapshot tests pass - [x] All 2380 runtime-runes tests pass - [x] All 3291 runtime-legacy tests pass - [x] All 145 compiler-errors tests pass - [x] All 326 validator tests pass - [x] Added `css-prune-edge-cases` test covering: `~=` word matching (substring vs whole word), deep combinator chains (4+ levels), `:has()` combined with class selectors, escaped selectors, `:is()`/`:where()`/`:not()` with combinators - [x] Edge case test passes on both baseline and optimized code 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com> Co-authored-by: Rich Harris <rich.harris@vercel.com>	5 months ago
Mathias Picker	32111f9e84	perf: avoid O(n²) name scanning in scope generate/unique (#17844) ... ## Summary `Scope.generate()` and `ScopeRoot.unique()` search for available names by iterating from suffix `_1` upward. When the same preferred name is generated many times (e.g. `text` is generated 482 times in a large component), the Nth call re-scans all N-1 already-taken names — O(n²) total work. This adds a `#name_counters` Map to `ScopeRoot` that tracks the next suffix to try per name, so each call resumes from where the last one left off. Generated names are identical to before. ## Benchmark (interleaved, best-of-3 rounds) | Component | Min | Median | |---|---|---| | Realistic (~80 lines) | ~1% | ~7% | | Medium (316 lines) | ~1% | ~5% | | Large (642 lines) | ~7% | ~2% | | XLarge (1302 lines) | **~11%** | **~10%** | ## Test plan - [x] All snapshot tests pass (name generation unchanged) - [x] All validator, compiler-error, runtime-runes, runtime-legacy tests pass 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	5 months ago
Rich Harris	2f12b60701	chore: avoid reschedule during branch commit (#17837) ... If a dirty effect is resumed — for example `condition` becomes `false` then `count` changes then `condition` becomes `true` again... ```svelte {#if condition} <div transition:fade> {count} </div> {/if} ``` ...then the effect is rescheduled. This happens when branches are committed (after the effect tree is traversed, before effects are flushed). That's undesirable, because it causes another turn of the `flush_effects` loop. It's better if we can handle everything in a single pass, which is what happens in this PR. The trade-off is that we have to traverse the entire effect tree, instead of skipping inert subtrees, which is a trade-off that I think makes sense. The real agenda here is that I'm trying to eliminate all `schedule_effect` calls that happen at inconvenient times, because I have a hunch that if we do that we can return to #17805, which I'm increasingly convinced will be important. (You might have to trust me on this; a full explanation would look a bit charlie-day-meme.jpg. Call it a hunch.) ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [ ] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint` --------- Co-authored-by: Vercel <vercel[bot]@users.noreply.github.com>	5 months ago
Rich Harris	86ec210866	fix: correctly add `__svelte_meta` after else-if chains (#17830) ... While looking into something else I spotted the fact that we use `false` to indicate 'else' in an `{#if ...}` block (whether there's an `else` block to render or not). If we instead use `-1`, and use `<!--[0-->` to indicate that the first block in an if-elseif chain was rendered... - instead of `<!--[-->`, we do `<!--[0-->` - instead of `<!--[!-->`, we do `<!--[-1-->` - all others stay the same ...we can simplify things a bit — the `key` argument to `update_branch` is always a number (which probably has some microscopic benefits in terms of making it monomorphic when `else` is defined, and less polymorphic when it isn't), and the hydration mismatch code only needs to consider one type of hydration marker. In the process, I discovered a bug — the dev-time `add_locations` function fails on hydration markers like `<!--[1-->`. This PR fixes it.	5 months ago
Rich Harris	7717ba01b4	fix: preserve each items that are needed by pending batches (#17819) ... This fixes a longstanding TODO with each blocks: currently, if any effects aren't used in the current batch at the moment of reconciliation, they are destroyed. Subsequent batches therefore end up recreating them. This is wasteful at the best of times, but if the effect contains any async work, that work has to be restarted. This PR fixes it by preserving any effects that correspond to the keys of pending batches. It _does_ mean that we need to iterate over each `keys` map for each pending batch in which an each block re-ran, but that is a rare scenario. This feels preferable to the alternative approaches.	5 months ago
Mathias Picker	791d5e332c	perf: cache element interactivity and source line splitting (#17839) ... ## Summary Two small compiler optimizations that reduce redundant work: - **Cache `element_interactivity` per element in a11y checks**: `check_element` was calling `element_interactivity()` up to 10 times per element (via `is_interactive_element`, `is_non_interactive_element`, `is_static_element` wrappers), each time re-iterating schema arrays. Now computed once after building the attribute map and reused. The now-unused wrapper functions are removed. - **Split source lines once in `state.set_source`**: Every compiler warning called `get_code_frame` which split the entire source string with `source.split('\n')`. Now the split happens once in `set_source()` and is exported as `state.source_lines`, naturally cleared by `reset()`. ## Benchmark Synthetic component (80 state vars, 30 each blocks, ~1300 lines): ``` Min Best3 Median Before 66.55ms 67.03ms 73.44ms After 61.14ms 61.90ms 70.63ms Improvement 8.1% 7.7% 3.8% ``` Realistic component (~80 lines, ~25 elements, few warnings): **~1-4%** improvement. The a11y cache scales with element count, the source.split saving scales with warning count. ## Test plan - [x] All 326 validator tests pass (includes all a11y tests) - [x] All 5671 runtime tests pass - [x] 145 compiler-error tests pass 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	5 months ago
github-actions[bot]	d4c78292ed	Version Packages (#17812) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.6 ### Patch Changes - perf: optimize parser hot paths for faster compilation ([#17811](https://github.com/sveltejs/svelte/pull/17811)) - fix: `SvelteMap` incorrectly handles keys with `undefined` values ([#17826](https://github.com/sveltejs/svelte/pull/17826)) - fix: SvelteURL `search` setter now returns the normalized value, matching native URL behavior ([#17828](https://github.com/sveltejs/svelte/pull/17828)) - fix: visit synthetic value node during ssr ([#17824](https://github.com/sveltejs/svelte/pull/17824)) - fix: always case insensitive event handlers during ssr ([#17822](https://github.com/sveltejs/svelte/pull/17822)) - chore: more efficient effect scheduling ([#17808](https://github.com/sveltejs/svelte/pull/17808)) - perf: optimize compiler analysis phase ([#17823](https://github.com/sveltejs/svelte/pull/17823)) - fix: skip redundant batch.apply ([#17816](https://github.com/sveltejs/svelte/pull/17816)) - chore: null out current_batch before committing branches ([#17809](https://github.com/sveltejs/svelte/pull/17809)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	6 months ago
Mathias Picker	361b32c7cd	fix: SvelteURL search setter uses unnormalized value (#17828) ... ## Summary - The `SvelteURL` `search` setter stored the raw input `value` instead of `super.search`, unlike every other setter in the class - This caused `url.search` to return incorrect values when the URL API normalizes the input (e.g. adding the `?` prefix, or stripping a lone `?`) - For example: `url.search = 'foo=bar'` would return `'foo=bar'` instead of `'?foo=bar'` ## Test plan - [x] Added `url.search normalizes value` test covering: - Setting search without `?` prefix - Setting search with `?` prefix (existing behavior) - Setting search to lone `?` (normalized to `""`) - [x] All existing reactivity tests pass (46/46) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	6 months ago
Mathias Picker	1043f79d1e	perf: optimize compiler analysis phase (#17823) ... ## Summary Two optimizations to the compiler's analysis phase: - **Cache `ignore_stack` snapshots instead of `structuredClone` on every node.** The universal `_` visitor in the analysis walk runs on every AST node and calls `structuredClone(ignore_stack)` each time. In practice, `svelte-ignore` comments are rare (0–5 per component), so 99%+ of nodes deep-clone an unchanged stack. This adds a copy-on-write cache that only re-creates the snapshot when `push_ignore`/`pop_ignore` actually change the stack. - **Walk the CSS stylesheet once instead of once per element.** `prune()` was called in a loop for each element, each time doing a full `walk()` of the stylesheet AST. This restructures the loop so the stylesheet is walked once, and the element iteration happens inside the `ComplexSelector` visitor. ## Benchmarks Compiled each component 500 times (after 50 warmup iterations), measuring average time per `compile()` call: | Component | Before | After | Speedup | |---|---|---|---| | `has` (80+ CSS selectors, 12 elements) | 3.405 ms | 2.680 ms | **21% faster** | | `siblings-combinator-each-nested` (65 CSS rules, 15 elements) | 2.034 ms | 1.575 ms | **23% faster** | | synthetic (100 CSS rules, 50 elements) | 10.099 ms | 4.564 ms | **55% faster** | The CSS pruning optimization scales with `elements × CSS rules` — the more elements a component has, the bigger the win since we go from N stylesheet walks down to 1. The `structuredClone` fix helps every component regardless of CSS, eliminating ~500–2000 deep clones per compile (one per AST node) and replacing them with 0–5 (one per `svelte-ignore` comment). For typical real-world components with 10–20 elements and some CSS, expect roughly **20–30% faster compilation** in the analysis phase. ## Test plan - [x] Full test suite passes (7329 tests, 0 failures) - [x] CSS pruning tests pass (selector matching, scoping, unused rule detection) - [x] `svelte-ignore` behavior unchanged (snapshot is consumed read-only via `.has()`/`.some()`) 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	6 months ago
Paolo Ricciuti	b6faa2a905	fix: always case insensitive event handlers during ssr (#17822) ... Fixes events not being stripped on svg, mathml and custom elements. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint` --------- Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>	6 months ago
Paolo Ricciuti	e3d277b000	fix: visit synthetic value node during ssr (#17824) ... Closes #17821 ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	6 months ago
Mathias Picker	18db0cab86	fix: SvelteMap incorrectly handles keys with `undefined` values (#17826) ... ## Summary `SvelteMap` had two bugs related to how it checked for key existence internally: ### 1. `has()` and `get()` returned wrong results for keys with `undefined` values Both methods used `super.get(key) !== undefined` to determine if a key existed before creating a per-key reactive source. This fails for keys whose value is legitimately `undefined`, causing: - `has(key)` to return `false` for existing keys with `undefined` values - `get(key)` to skip creating a per-key source and fall back to tracking `version`, resulting in over-notification **Fix:** Replace `super.get(key) !== undefined` with `super.has(key)` in both `has()` and `get()`, matching the pattern already used in `SvelteSet`. ### 2. `delete()` skipped reactive updates when a key had no per-key source The `size` and `version` reactive updates were inside the `if (s !== undefined)` block, meaning they only fired when a per-key source existed (i.e., someone had previously called `has()` or `get()` on that specific key). If a key was added via the constructor or `set()` but never individually read, deleting it would not trigger reactive updates for effects depending on `size` or iterators. **Fix:** Move `set(this.#size, super.size)` and `increment(this.#version)` to a separate `if (res)` block so they fire whenever a key is actually deleted, regardless of whether a per-key source existed. ### Before fix ```js const map = new SvelteMap([['foo', undefined]]); map.has('foo'); // false (should be true) map.get('foo'); // undefined but tracks version instead of per-key source ``` ### After fix ```js const map = new SvelteMap([['foo', undefined]]); map.has('foo'); // true map.get('foo'); // undefined with correct per-key tracking ``` ## Test plan Tests are in `packages/svelte/src/reactivity/map.test.ts`: - `map.has()` returns `true` for constructor-initialized keys with `undefined` values - `map.get()` returns `undefined` with proper per-key reactive tracking - `map.delete()` triggers `has()`/`get()` reactivity for undefined-valued keys - `map.set(key, undefined)` followed by `has()`/`get()` works correctly - `map.delete()` triggers `size` reactivity for keys that were never individually read (no per-key source) - All existing tests pass unchanged 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	6 months ago
Rich Harris	16a13517ef	fix: skip redundant batch.apply (#17816) ... tiny fix — just realised we're calling `this.apply()` (via `this.activate()`) unnecessarily, since it will happen again immediately after in `flush_effects`	6 months ago
Mathias Picker	efb651cd33	perf: optimize parser hot paths for ~18% faster compilation (#17811) ... ## Summary Optimizes the Svelte compiler's parser phase — the hot path that runs on every file compilation during development (HMR). The changes are surgical micro-optimizations to 7 files in `packages/svelte/src/compiler/phases/1-parse/`, with no architectural changes. ### Changes - **`Parser.match()` — `slice` → `startsWith`**: Avoids creating a new substring on every multi-char match call (called thousands of times per compilation) - **`Parser.match_regex()` — `slice` → sticky flag**: Uses `lastIndex` + `y` flag instead of slicing the entire template string on every regex match. All 14 regex patterns passed to `match_regex`/`read` across 4 files updated with `y` flag. - **`Parser.allow_whitespace()` / `require_whitespace()` — regex → charCode**: Replaces `regex_whitespace.test()` with numeric charCode comparisons in a tight loop (called hundreds of times per compilation). Covers the full `\s` character set with a fast path for common ASCII whitespace. - **Text parser — string concatenation → `slice`**: Replaced `data += template[index++]` loop (O(n²)) with tracking start position + single `slice()` call (O(n)) - **`read_sequence` — string concatenation → `slice`**: Same pattern — derive `raw` from `template.slice()` in `flush()` instead of char-by-char concatenation - **`is_valid_element_name()` — inline regexes → module-level constants**: Extracted 2 regex literals to module scope - **Dynamic `new RegExp()` → `indexOf`**: Replaced `parser.read_until(new RegExp(...))` with `template.indexOf()` for script/style closing tags - **`match_bracket` — `Array.includes` → `Set.has`**: Pre-computes close bracket values as a `Set` for O(1) lookups ## Benchmark A benchmark script was written that: 1. Compiles 5 real test components of varying complexity (a11y validators, form bindings, component migration output, rich selects) 2. Compiles 2 synthetic stress-test templates (500 elements and 2000 elements with expressions and entities) 3. Runs 50 warmup iterations for parse, 20 for compile (JIT warmup) 4. Forces GC between benchmarks via `--expose-gc` 5. Measures both parse-only and full compilation (parse + analyze + transform + codegen) ### Parse-only results | Component | Before | After | Speedup | |---|---|---|---| | a11y-role-supports-aria-props (371 lines) | 2.410ms | 2.129ms | **-11.7%** | | form-default-value-spread (199 lines) | 1.726ms | 1.360ms | **-21.2%** | | svelte-component (251 lines) | 1.925ms | 1.648ms | **-14.4%** | | select-with-rich-content (157 lines) | 0.795ms | 0.636ms | **-20.0%** | | rich-select (173 lines) | 0.807ms | 0.637ms | **-21.1%** | | synthetic-large (500 elements) | 2.560ms | 1.547ms | **-39.6%** | | synthetic-huge (2000 elements) | 136.849ms | 114.115ms | **-16.6%** | | **Total** | **147.071ms** | **122.072ms** | **-17.0%** | ### Full compile results | Component | Before | After | Speedup | |---|---|---|---| | a11y-role-supports-aria-props | 25.407ms | 21.990ms | **-13.4%** | | form-default-value-spread | 10.711ms | 9.422ms | **-12.0%** | | svelte-component | 10.304ms | 8.481ms | **-17.7%** | | select-with-rich-content | 5.986ms | 4.694ms | **-21.6%** | | rich-select | 6.010ms | 5.059ms | **-15.8%** | | synthetic-large (500 elements) | 30.511ms | 25.196ms | **-17.4%** | | synthetic-huge (2000 elements) | 932.801ms | 764.794ms | **-18.0%** | | **Total** | **1021.729ms** | **839.637ms** | **-17.8%** | Benchmarked on macOS, Node.js, Apple Silicon. The parse improvements carry through to end-to-end compile time since the parser is a significant portion of the compilation pipeline. Text-heavy templates benefit the most (up to 40% faster parse). Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	6 months ago
Rich Harris	5bd4699539	chore: more efficient effect scheduling (#17808) ... This extracts part of #17805 into its own PR that can be merged independently. Today, if a (non-render) effect is created during traversal (e.g. an `{#if condition}` block becomes true, and an `$effect` is created somewhere inside it) then it goes through `schedule_effect`, ultimately causing the loop in `flush_effects` to run again. This is wasteful. We can instead push to an array — `collected_effects` — which is flushed following the first traversal. By using `collected_effects !== null` as a proxy for 'is traversing', we can also simplify the bail-out logic inside `schedule_effect` and make it work in more cases. Bailing out means that in the case that a signal is written to during traversal (which is the case for `each` blocks, for example), we can avoid triggering another turn of the loop because we know that the affected effects are about to be discovered as a result of the ongoing traversal. All this brings us slightly closer to the intermediate goal in #17805 of ensuring that scheduled effects always belong to a specific batch. No test for this because it shouldn't have any user-observable impact, though I've added a changeset out of an abundance of caution.	6 months ago
Rich Harris	b76cd5cafc	chore: null out current_batch before committing branches (#17809) ... Another small tweak extracted from #17805, just to make that diff a bit more legible. By passing the `batch` to the branch commit callback, we don't need to rely on the value of `current_batch` being the same as the batch currently being processed. That gives us more control over the order of operations — for example we can null out `current_batch` _before_ committing branches, which is important (at present, if a state change occurs while those branches are being committed, it will belong to the current batch, but the resulting effects will happen in the context of a _new_ batch, which is something we need to avoid for the sake of #17805). ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [ ] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	6 months ago
github-actions[bot]	ed14b499d6	Version Packages (#17802) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.5 ### Patch Changes - fix: escape `innerText` and `textContent` bindings of `contenteditable` ([`0df5abcae223058ceb95491470372065fb87951d`](0df5abcae2)) - fix: sanitize `transformError` values prior to embedding in HTML comments ([`0298e979371bb583855c9810db79a70a551d22b9`](0298e97937)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	6 months ago
Paolo Ricciuti	0df5abcae2	Merge commit from fork ... * fix: escape `innerText` and `textContent` bindings of `contenteditable` * fix: better if else structure	6 months ago
Elliott Johnson	0298e97937	Merge commit from fork ... * fix: sanitize `transformError` values prior to embedding in HTML comments * did a little dumb	6 months ago
github-actions[bot]	96fd3ce763	Version Packages (#17786) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.53.4 ### Patch Changes - fix: set server context after async transformError ([#17799](https://github.com/sveltejs/svelte/pull/17799)) - fix: hydrate if blocks correctly ([#17784](https://github.com/sveltejs/svelte/pull/17784)) - fix: handle default parameters scope leaks ([#17788](https://github.com/sveltejs/svelte/pull/17788)) - fix: prevent flushed effects from running again ([#17787](https://github.com/sveltejs/svelte/pull/17787)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	6 months ago
Simon H	1b3e660519	fix: prevent flushed effects from running again (#17787) ... We never cleared the list of (maybe)dirty_effects on the assumption that once a batch has run them it's complete. But that's not the case when a boundary has a pending snippet, in which case the pending snippet shows up, so `blocking_pending` is already 0 and effects are flushed. That can lead to effects being run unnecessarily, even leading to infinite loops. So we clear them. This is safe because any additional effects would either be scheduled by the boundary (which keeps track of the offscreen effects created while the pending snippet is shown, and schedules them once the pending snippet goes away) or by unskipping skipped branches (which reschedules the effects inside it) Fixes #17717 After creating the test I noticed it fails when run together with other tests, but not alone, which lead me to discover that we're missing an `unset_context`. I also added clearing of `#skipped_branches` just to be safe.	6 months ago
Simon H	673a1ab964	fix: set server context after async transformError (#17799) ... This will get the tests in https://github.com/sveltejs/kit/pull/15308 green, right now they fail because page state cannot be found because context not available	6 months ago
Maurício Kishi	3a289797bd	fix: handle default parameters scope leaks (#17788) ... Use separate scopes for function declarations/expressions and function bodies. This prevents variable declarations from leaking into default parameter initialization expressions. Closes #17785. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	6 months ago