diff --git a/documentation/docs/98-reference/30-compiler-errors.md b/documentation/docs/98-reference/30-compiler-errors.md
index ebcaa28ef8..9d38dc20a9 100644
--- a/documentation/docs/98-reference/30-compiler-errors.md
+++ b/documentation/docs/98-reference/30-compiler-errors.md
@@ -3,864 +3,858 @@ title: 'Compiler Errors'
 generated: 'generated by process-messages/index.js'
 ---
 
-## options_invalid_value
+## `animation_duplicate`
 
 ```
-Invalid compiler option: %details%
+An element can only have one 'animate' directive
 ```
 
-## options_removed
+## `animation_invalid_placement`
 
 ```
-Invalid compiler option: %details%
+An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block
 ```
 
-## options_unrecognised
+## `animation_missing_key`
 
 ```
-Unrecognised compiler option %keypath%
+An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block. Did you forget to add a key to your each block?
 ```
 
-## bindable_invalid_location
+## `attribute_contenteditable_dynamic`
 
 ```
-`$bindable()` can only be used inside a `$props()` declaration
+'contenteditable' attribute cannot be dynamic if element uses two-way binding
 ```
 
-## constant_assignment
+## `attribute_contenteditable_missing`
 
 ```
-Cannot assign to %thing%
+'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings
 ```
 
-## constant_binding
+## `attribute_duplicate`
 
 ```
-Cannot bind to %thing%
+Attributes need to be unique
 ```
 
-## declaration_duplicate
+## `attribute_empty_shorthand`
 
 ```
-`%name%` has already been declared
+Attribute shorthand cannot be empty
 ```
 
-## declaration_duplicate_module_import
+## `attribute_invalid_event_handler`
 
 ```
-Cannot declare a variable with the same name as an import inside `<script module>`
+Event attribute must be a JavaScript expression, not a string
 ```
 
-## derived_invalid_export
+## `attribute_invalid_multiple`
 
 ```
-Cannot export derived state from a module. To expose the current derived value, export a function returning its value
+'multiple' attribute must be static if select uses two-way binding
 ```
 
-## dollar_binding_invalid
+## `attribute_invalid_name`
 
 ```
-The $ name is reserved, and cannot be used for variables and imports
+'%name%' is not a valid attribute name
 ```
 
-## dollar_prefix_invalid
+## `attribute_invalid_sequence_expression`
 
 ```
-The $ prefix is reserved, and cannot be used for variables and imports
+Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses
 ```
 
-## each_item_invalid_assignment
+## `attribute_invalid_type`
 
 ```
-Cannot reassign or bind to each block argument in runes mode. Use the array and index variables instead (e.g. `array[i] = value` instead of `entry = value`)
+'type' attribute must be a static text value if input uses two-way binding
 ```
 
-## effect_invalid_placement
+## `attribute_unquoted_sequence`
 
 ```
-`$effect()` can only be used as an expression statement
+Attribute values containing `{...}` must be enclosed in quote marks, unless the value only contains the expression
 ```
 
-## global_reference_invalid
+## `bind_invalid_expression`
 
 ```
-`%name%` is an illegal variable name. To reference a global variable called `%name%`, use `globalThis.%name%`
+Can only bind to an Identifier or MemberExpression
 ```
 
-## host_invalid_placement
+## `bind_invalid_name`
 
 ```
-`$host()` can only be used inside custom element component instances
+`bind:%name%` is not a valid binding
 ```
-
-## import_svelte_internal_forbidden
-
 ```
-Imports of `svelte/internal/*` are forbidden. It contains private runtime code which is subject to change without notice. If you're importing from `svelte/internal/*` to work around a limitation of Svelte, please open an issue at https://github.com/sveltejs/svelte and explain your use case
+`bind:%name%` is not a valid binding. %explanation%
 ```
 
-## invalid_arguments_usage
+## `bind_invalid_target`
 
 ```
-The arguments keyword cannot be used within the template or at the top level of a component
+`bind:%name%` can only be used with %elements%
 ```
 
-## legacy_export_invalid
+## `bind_invalid_value`
 
 ```
-Cannot use `export let` in runes mode — use `$props()` instead
+Can only bind to state or props
 ```
 
-## legacy_props_invalid
+## `bindable_invalid_location`
 
 ```
-Cannot use `$$props` in runes mode
+`$bindable()` can only be used inside a `$props()` declaration
 ```
 
-## legacy_reactive_statement_invalid
+## `block_duplicate_clause`
 
 ```
-`$:` is not allowed in runes mode, use `$derived` or `$effect` instead
+%name% cannot appear more than once within a block
 ```
 
-## legacy_rest_props_invalid
+## `block_invalid_continuation_placement`
 
 ```
-Cannot use `$$restProps` in runes mode
+{:...} block is invalid at this position (did you forget to close the preceeding element or block?)
 ```
 
-## module_illegal_default_export
+## `block_invalid_elseif`
 
 ```
-A component cannot have a default export
+'elseif' should be 'else if'
 ```
 
-## props_duplicate
+## `block_invalid_placement`
 
 ```
-Cannot use `$props()` more than once
+{#%name% ...} block cannot be %location%
 ```
 
-## props_illegal_name
+## `block_unclosed`
 
 ```
-Declaring or accessing a prop starting with `$$` is illegal (they are reserved for Svelte internals)
+Block was left open
 ```
 
-## props_invalid_identifier
+## `block_unexpected_character`
 
 ```
-`$props()` can only be used with an object destructuring pattern
+Expected a `%character%` character immediately following the opening bracket
 ```
 
-## props_invalid_pattern
+## `block_unexpected_close`
 
 ```
-`$props()` assignment must not contain nested properties or computed keys
+Unexpected block closing tag
 ```
 
-## props_invalid_placement
+## `component_invalid_directive`
 
 ```
-`$props()` can only be used at the top level of components as a variable declaration initializer
+This type of directive is not valid on components
 ```
 
-## reactive_declaration_cycle
+## `const_tag_cycle`
 
 ```
 Cyclical dependency detected: %cycle%
 ```
 
-## rune_invalid_arguments
+## `const_tag_invalid_expression`
 
 ```
-`%rune%` cannot be called with arguments
+{@const ...} must consist of a single variable declaration
 ```
 
-## rune_invalid_arguments_length
+## `const_tag_invalid_placement`
 
 ```
-`%rune%` must be called with %args%
+`{@const}` must be the immediate child of `{#snippet}`, `{#if}`, `{:else if}`, `{:else}`, `{#each}`, `{:then}`, `{:catch}`, `<svelte:fragment>` or `<Component>`
 ```
 
-## rune_invalid_computed_property
+## `constant_assignment`
 
 ```
-Cannot access a computed property of a rune
+Cannot assign to %thing%
 ```
 
-## rune_invalid_name
+## `constant_binding`
 
 ```
-`%name%` is not a valid rune
+Cannot bind to %thing%
 ```
 
-## rune_invalid_usage
+## `css_empty_declaration`
 
 ```
-Cannot use `%rune%` rune in non-runes mode
+Declaration cannot be empty
 ```
 
-## rune_missing_parentheses
+## `css_expected_identifier`
 
 ```
-Cannot use rune without parentheses
+Expected a valid CSS identifier
 ```
 
-## rune_removed
+## `css_global_block_invalid_combinator`
 
 ```
-The `%name%` rune has been removed
+A `:global` selector cannot follow a `%name%` combinator
 ```
 
-## rune_renamed
+## `css_global_block_invalid_declaration`
 
 ```
-`%name%` is now `%replacement%`
+A top-level `:global {...}` block can only contain rules, not declarations
 ```
 
-## runes_mode_invalid_import
+## `css_global_block_invalid_list`
 
 ```
-%name% cannot be used in runes mode
+A `:global` selector cannot be part of a selector list with more than one item
 ```
 
-## snippet_parameter_assignment
+## `css_global_block_invalid_modifier`
 
 ```
-Cannot reassign or bind to snippet parameter
+A `:global` selector cannot modify an existing selector
 ```
 
-## state_invalid_export
+## `css_global_block_invalid_modifier_start`
 
 ```
-Cannot export state from a module if it is reassigned. Either export a function returning the state value or only mutate the state value's properties
+A `:global` selector can only be modified if it is a descendant of other selectors
 ```
 
-## state_invalid_placement
+## `css_global_invalid_placement`
 
 ```
-`%rune%(...)` can only be used as a variable declaration initializer or a class field
+`:global(...)` can be at the start or end of a selector sequence, but not in the middle
 ```
 
-## store_invalid_scoped_subscription
+## `css_global_invalid_selector`
 
 ```
-Cannot subscribe to stores that are not declared at the top level of the component
+`:global(...)` must contain exactly one selector
 ```
 
-## store_invalid_subscription
+## `css_global_invalid_selector_list`
 
 ```
-Cannot reference store value inside `<script module>`
+`:global(...)` must not contain type or universal selectors when used in a compound selector
 ```
 
-## store_invalid_subscription_module
+## `css_nesting_selector_invalid_placement`
 
 ```
-Cannot reference store value outside a `.svelte` file
+Nesting selectors can only be used inside a rule or as the first selector inside a lone `:global(...)`
 ```
 
-Using a `$` prefix to refer to the value of a store is only possible inside `.svelte` files, where Svelte can automatically create subscriptions when a component is mounted and unsubscribe when the component is unmounted. Consider migrating to runes instead.
-
-## typescript_invalid_feature
+## `css_selector_invalid`
 
 ```
-TypeScript language features like %feature% are not natively supported, and their use is generally discouraged. Outside of `<script>` tags, these features are not supported. For use within `<script>` tags, you will need to use a preprocessor to convert it to JavaScript before it gets passed to the Svelte compiler. If you are using `vitePreprocess`, make sure to specifically enable preprocessing script tags (`vitePreprocess({ script: true })`)
+Invalid selector
 ```
 
-## css_empty_declaration
+## `css_type_selector_invalid_placement`
 
 ```
-Declaration cannot be empty
+`:global(...)` must not be followed by a type selector
 ```
 
-## css_expected_identifier
+## `debug_tag_invalid_arguments`
 
 ```
-Expected a valid CSS identifier
+{@debug ...} arguments must be identifiers, not arbitrary expressions
 ```
 
-## css_global_block_invalid_combinator
+## `declaration_duplicate`
 
 ```
-A `:global` selector cannot follow a `%name%` combinator
+`%name%` has already been declared
 ```
 
-## css_global_block_invalid_declaration
+## `declaration_duplicate_module_import`
 
 ```
-A top-level `:global {...}` block can only contain rules, not declarations
+Cannot declare a variable with the same name as an import inside `<script module>`
 ```
 
-## css_global_block_invalid_list
+## `derived_invalid_export`
 
 ```
-A `:global` selector cannot be part of a selector list with more than one item
+Cannot export derived state from a module. To expose the current derived value, export a function returning its value
 ```
 
-## css_global_block_invalid_modifier
+## `directive_invalid_value`
 
 ```
-A `:global` selector cannot modify an existing selector
+Directive value must be a JavaScript expression enclosed in curly braces
 ```
 
-## css_global_block_invalid_modifier_start
+## `directive_missing_name`
 
 ```
-A `:global` selector can only be modified if it is a descendant of other selectors
+`%type%` name cannot be empty
 ```
 
-## css_global_invalid_placement
+## `dollar_binding_invalid`
 
 ```
-`:global(...)` can be at the start or end of a selector sequence, but not in the middle
+The $ name is reserved, and cannot be used for variables and imports
 ```
 
-## css_global_invalid_selector
+## `dollar_prefix_invalid`
 
 ```
-`:global(...)` must contain exactly one selector
+The $ prefix is reserved, and cannot be used for variables and imports
 ```
 
-## css_global_invalid_selector_list
+## `each_item_invalid_assignment`
 
 ```
-`:global(...)` must not contain type or universal selectors when used in a compound selector
+Cannot reassign or bind to each block argument in runes mode. Use the array and index variables instead (e.g. `array[i] = value` instead of `entry = value`)
 ```
 
-## css_nesting_selector_invalid_placement
+## `effect_invalid_placement`
 
 ```
-Nesting selectors can only be used inside a rule or as the first selector inside a lone `:global(...)`
+`$effect()` can only be used as an expression statement
 ```
 
-## css_selector_invalid
+## `element_invalid_closing_tag`
 
 ```
-Invalid selector
+`</%name%>` attempted to close an element that was not open
 ```
 
-## css_type_selector_invalid_placement
+## `element_invalid_closing_tag_autoclosed`
 
 ```
-`:global(...)` must not be followed by a type selector
+`</%name%>` attempted to close element that was already automatically closed by `<%reason%>` (cannot nest `<%reason%>` inside `<%name%>`)
 ```
 
-## animation_duplicate
+## `element_unclosed`
 
 ```
-An element can only have one 'animate' directive
+`<%name%>` was left open
 ```
 
-## animation_invalid_placement
+## `event_handler_invalid_component_modifier`
 
 ```
-An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block
+Event modifiers other than 'once' can only be used on DOM elements
 ```
 
-## animation_missing_key
+## `event_handler_invalid_modifier`
 
 ```
-An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block. Did you forget to add a key to your each block?
+Valid event modifiers are %list%
 ```
 
-## attribute_contenteditable_dynamic
+## `event_handler_invalid_modifier_combination`
 
 ```
-'contenteditable' attribute cannot be dynamic if element uses two-way binding
+The '%modifier1%' and '%modifier2%' modifiers cannot be used together
 ```
 
-## attribute_contenteditable_missing
+## `expected_attribute_value`
 
 ```
-'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings
+Expected attribute value
 ```
 
-## attribute_duplicate
+## `expected_block_type`
 
 ```
-Attributes need to be unique
+Expected 'if', 'each', 'await', 'key' or 'snippet'
 ```
 
-## attribute_empty_shorthand
+## `expected_identifier`
 
 ```
-Attribute shorthand cannot be empty
+Expected an identifier
 ```
 
-## attribute_invalid_event_handler
+## `expected_pattern`
 
 ```
-Event attribute must be a JavaScript expression, not a string
+Expected identifier or destructure pattern
 ```
 
-## attribute_invalid_multiple
+## `expected_token`
 
 ```
-'multiple' attribute must be static if select uses two-way binding
+Expected token %token%
 ```
 
-## attribute_invalid_name
+## `expected_whitespace`
 
 ```
-'%name%' is not a valid attribute name
+Expected whitespace
 ```
 
-## attribute_invalid_sequence_expression
+## `global_reference_invalid`
 
 ```
-Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses
+`%name%` is an illegal variable name. To reference a global variable called `%name%`, use `globalThis.%name%`
 ```
 
-## attribute_invalid_type
+## `host_invalid_placement`
 
 ```
-'type' attribute must be a static text value if input uses two-way binding
+`$host()` can only be used inside custom element component instances
 ```
 
-## attribute_unquoted_sequence
+## `import_svelte_internal_forbidden`
 
 ```
-Attribute values containing `{...}` must be enclosed in quote marks, unless the value only contains the expression
+Imports of `svelte/internal/*` are forbidden. It contains private runtime code which is subject to change without notice. If you're importing from `svelte/internal/*` to work around a limitation of Svelte, please open an issue at https://github.com/sveltejs/svelte and explain your use case
 ```
 
-## bind_invalid_expression
+## `invalid_arguments_usage`
 
 ```
-Can only bind to an Identifier or MemberExpression
+The arguments keyword cannot be used within the template or at the top level of a component
 ```
 
-## bind_invalid_name
+## `js_parse_error`
 
 ```
-`bind:%name%` is not a valid binding
-```
-```
-`bind:%name%` is not a valid binding. %explanation%
+%message%
 ```
 
-## bind_invalid_target
+## `legacy_export_invalid`
 
 ```
-`bind:%name%` can only be used with %elements%
+Cannot use `export let` in runes mode — use `$props()` instead
 ```
 
-## bind_invalid_value
+## `legacy_props_invalid`
 
 ```
-Can only bind to state or props
+Cannot use `$$props` in runes mode
 ```
 
-## block_duplicate_clause
+## `legacy_reactive_statement_invalid`
 
 ```
-%name% cannot appear more than once within a block
+`$:` is not allowed in runes mode, use `$derived` or `$effect` instead
 ```
 
-## block_invalid_continuation_placement
+## `legacy_rest_props_invalid`
 
 ```
-{:...} block is invalid at this position (did you forget to close the preceeding element or block?)
+Cannot use `$$restProps` in runes mode
 ```
 
-## block_invalid_elseif
+## `let_directive_invalid_placement`
 
 ```
-'elseif' should be 'else if'
+`let:` directive at invalid position
 ```
 
-## block_invalid_placement
+## `mixed_event_handler_syntaxes`
 
 ```
-{#%name% ...} block cannot be %location%
+Mixing old (on:%name%) and new syntaxes for event handling is not allowed. Use only the on%name% syntax
 ```
 
-## block_unclosed
+## `module_illegal_default_export`
 
 ```
-Block was left open
+A component cannot have a default export
 ```
 
-## block_unexpected_character
+## `node_invalid_placement`
 
 ```
-Expected a `%character%` character immediately following the opening bracket
+%thing% is invalid inside `<%parent%>`
 ```
 
-## block_unexpected_close
+HTML restricts where certain elements can appear. In case of a violation the browser will 'repair' the HTML in a way that breaks Svelte's assumptions about the structure of your components. Some examples:
 
-```
-Unexpected block closing tag
-```
+- `<p>hello <div>world</div></p>` will result in `<p>hello </p><div>world</div><p></p>` for example (the `<div>` autoclosed the `<p>` because `<p>` cannot contain block-level elements)
+- `<option><div>option a</div></option>` will result in `<option>option a</option>` (the `<div>` is removed)
+- `<table><tr><td>cell</td></tr></table>` will result in `<table><tbody><tr><td>cell</td></tr></tbody></table>` (a `<tbody>` is auto-inserted)
 
-## component_invalid_directive
+## `options_invalid_value`
 
 ```
-This type of directive is not valid on components
+Invalid compiler option: %details%
 ```
 
-## const_tag_cycle
+## `options_removed`
 
 ```
-Cyclical dependency detected: %cycle%
+Invalid compiler option: %details%
 ```
 
-## const_tag_invalid_expression
+## `options_unrecognised`
 
 ```
-{@const ...} must consist of a single variable declaration
+Unrecognised compiler option %keypath%
 ```
 
-## const_tag_invalid_placement
+## `props_duplicate`
 
 ```
-`{@const}` must be the immediate child of `{#snippet}`, `{#if}`, `{:else if}`, `{:else}`, `{#each}`, `{:then}`, `{:catch}`, `<svelte:fragment>` or `<Component>`
+Cannot use `$props()` more than once
 ```
 
-## debug_tag_invalid_arguments
+## `props_illegal_name`
 
 ```
-{@debug ...} arguments must be identifiers, not arbitrary expressions
+Declaring or accessing a prop starting with `$$` is illegal (they are reserved for Svelte internals)
 ```
 
-## directive_invalid_value
+## `props_invalid_identifier`
 
 ```
-Directive value must be a JavaScript expression enclosed in curly braces
+`$props()` can only be used with an object destructuring pattern
 ```
 
-## directive_missing_name
+## `props_invalid_pattern`
 
 ```
-`%type%` name cannot be empty
+`$props()` assignment must not contain nested properties or computed keys
 ```
 
-## element_invalid_closing_tag
+## `props_invalid_placement`
 
 ```
-`</%name%>` attempted to close an element that was not open
+`$props()` can only be used at the top level of components as a variable declaration initializer
 ```
 
-## element_invalid_closing_tag_autoclosed
+## `reactive_declaration_cycle`
 
 ```
-`</%name%>` attempted to close element that was already automatically closed by `<%reason%>` (cannot nest `<%reason%>` inside `<%name%>`)
+Cyclical dependency detected: %cycle%
 ```
 
-## element_unclosed
+## `render_tag_invalid_call_expression`
 
 ```
-`<%name%>` was left open
+Calling a snippet function using apply, bind or call is not allowed
 ```
 
-## event_handler_invalid_component_modifier
+## `render_tag_invalid_expression`
 
 ```
-Event modifiers other than 'once' can only be used on DOM elements
+`{@render ...}` tags can only contain call expressions
 ```
 
-## event_handler_invalid_modifier
+## `render_tag_invalid_spread_argument`
 
 ```
-Valid event modifiers are %list%
+cannot use spread arguments in `{@render ...}` tags
 ```
 
-## event_handler_invalid_modifier_combination
+## `rune_invalid_arguments`
 
 ```
-The '%modifier1%' and '%modifier2%' modifiers cannot be used together
+`%rune%` cannot be called with arguments
 ```
 
-## expected_attribute_value
+## `rune_invalid_arguments_length`
 
 ```
-Expected attribute value
+`%rune%` must be called with %args%
 ```
 
-## expected_block_type
+## `rune_invalid_computed_property`
 
 ```
-Expected 'if', 'each', 'await', 'key' or 'snippet'
+Cannot access a computed property of a rune
 ```
 
-## expected_identifier
+## `rune_invalid_name`
 
 ```
-Expected an identifier
+`%name%` is not a valid rune
 ```
 
-## expected_pattern
+## `rune_invalid_usage`
 
 ```
-Expected identifier or destructure pattern
+Cannot use `%rune%` rune in non-runes mode
 ```
 
-## expected_token
+## `rune_missing_parentheses`
 
 ```
-Expected token %token%
+Cannot use rune without parentheses
 ```
 
-## expected_whitespace
+## `rune_removed`
 
 ```
-Expected whitespace
+The `%name%` rune has been removed
 ```
 
-## js_parse_error
+## `rune_renamed`
 
 ```
-%message%
+`%name%` is now `%replacement%`
 ```
 
-## let_directive_invalid_placement
+## `runes_mode_invalid_import`
 
 ```
-`let:` directive at invalid position
+%name% cannot be used in runes mode
 ```
 
-## mixed_event_handler_syntaxes
+## `script_duplicate`
 
 ```
-Mixing old (on:%name%) and new syntaxes for event handling is not allowed. Use only the on%name% syntax
+A component can have a single top-level `<script>` element and/or a single top-level `<script module>` element
 ```
 
-## node_invalid_placement
+## `script_invalid_attribute_value`
 
 ```
-%thing% is invalid inside `<%parent%>`
+If the `%name%` attribute is supplied, it must be a boolean attribute
 ```
 
-HTML restricts where certain elements can appear. In case of a violation the browser will 'repair' the HTML in a way that breaks Svelte's assumptions about the structure of your components. Some examples:
+## `script_invalid_context`
 
-- `<p>hello <div>world</div></p>` will result in `<p>hello </p><div>world</div><p></p>` for example (the `<div>` autoclosed the `<p>` because `<p>` cannot contain block-level elements)
-- `<option><div>option a</div></option>` will result in `<option>option a</option>` (the `<div>` is removed)
-- `<table><tr><td>cell</td></tr></table>` will result in `<table><tbody><tr><td>cell</td></tr></tbody></table>` (a `<tbody>` is auto-inserted)
+```
+If the context attribute is supplied, its value must be "module"
+```
 
-## render_tag_invalid_call_expression
+## `script_reserved_attribute`
 
 ```
-Calling a snippet function using apply, bind or call is not allowed
+The `%name%` attribute is reserved and cannot be used
 ```
 
-## render_tag_invalid_expression
+## `slot_attribute_duplicate`
 
 ```
-`{@render ...}` tags can only contain call expressions
+Duplicate slot name '%name%' in <%component%>
 ```
 
-## render_tag_invalid_spread_argument
+## `slot_attribute_invalid`
 
 ```
-cannot use spread arguments in `{@render ...}` tags
+slot attribute must be a static value
 ```
 
-## script_duplicate
+## `slot_attribute_invalid_placement`
 
 ```
-A component can have a single top-level `<script>` element and/or a single top-level `<script module>` element
+Element with a slot='...' attribute must be a child of a component or a descendant of a custom element
 ```
 
-## script_invalid_attribute_value
+## `slot_default_duplicate`
 
 ```
-If the `%name%` attribute is supplied, it must be a boolean attribute
+Found default slot content alongside an explicit slot="default"
 ```
 
-## script_invalid_context
+## `slot_element_invalid_attribute`
 
 ```
-If the context attribute is supplied, its value must be "module"
+`<slot>` can only receive attributes and (optionally) let directives
 ```
 
-## script_reserved_attribute
+## `slot_element_invalid_name`
 
 ```
-The `%name%` attribute is reserved and cannot be used
+slot attribute must be a static value
 ```
 
-## slot_attribute_duplicate
+## `slot_element_invalid_name_default`
 
 ```
-Duplicate slot name '%name%' in <%component%>
+`default` is a reserved word — it cannot be used as a slot name
 ```
 
-## slot_attribute_invalid
+## `slot_snippet_conflict`
 
 ```
-slot attribute must be a static value
+Cannot use `<slot>` syntax and `{@render ...}` tags in the same component. Migrate towards `{@render ...}` tags completely
 ```
 
-## slot_attribute_invalid_placement
+## `snippet_conflict`
 
 ```
-Element with a slot='...' attribute must be a child of a component or a descendant of a custom element
+Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block
 ```
 
-## slot_default_duplicate
+## `snippet_invalid_rest_parameter`
 
 ```
-Found default slot content alongside an explicit slot="default"
+Snippets do not support rest parameters; use an array instead
 ```
 
-## slot_element_invalid_attribute
+## `snippet_parameter_assignment`
 
 ```
-`<slot>` can only receive attributes and (optionally) let directives
+Cannot reassign or bind to snippet parameter
 ```
 
-## slot_element_invalid_name
+## `snippet_shadowing_prop`
 
 ```
-slot attribute must be a static value
+This snippet is shadowing the prop `%prop%` with the same name
 ```
 
-## slot_element_invalid_name_default
+## `state_invalid_export`
 
 ```
-`default` is a reserved word — it cannot be used as a slot name
+Cannot export state from a module if it is reassigned. Either export a function returning the state value or only mutate the state value's properties
 ```
 
-## slot_snippet_conflict
+## `state_invalid_placement`
 
 ```
-Cannot use `<slot>` syntax and `{@render ...}` tags in the same component. Migrate towards `{@render ...}` tags completely
+`%rune%(...)` can only be used as a variable declaration initializer or a class field
 ```
 
-## snippet_conflict
+## `store_invalid_scoped_subscription`
 
 ```
-Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block
+Cannot subscribe to stores that are not declared at the top level of the component
 ```
 
-## snippet_invalid_rest_parameter
+## `store_invalid_subscription`
 
 ```
-Snippets do not support rest parameters; use an array instead
+Cannot reference store value inside `<script module>`
 ```
 
-## snippet_shadowing_prop
+## `store_invalid_subscription_module`
 
 ```
-This snippet is shadowing the prop `%prop%` with the same name
+Cannot reference store value outside a `.svelte` file
 ```
 
-## style_directive_invalid_modifier
+Using a `$` prefix to refer to the value of a store is only possible inside `.svelte` files, where Svelte can automatically create subscriptions when a component is mounted and unsubscribe when the component is unmounted. Consider migrating to runes instead.
+
+## `style_directive_invalid_modifier`
 
 ```
 `style:` directive can only use the `important` modifier
 ```
 
-## style_duplicate
+## `style_duplicate`
 
 ```
 A component can have a single top-level `<style>` element
 ```
 
-## svelte_body_illegal_attribute
+## `svelte_body_illegal_attribute`
 
 ```
 `<svelte:body>` does not support non-event attributes or spread attributes
 ```
 
-## svelte_component_invalid_this
+## `svelte_component_invalid_this`
 
 ```
 Invalid component definition — must be an `{expression}`
 ```
 
-## svelte_component_missing_this
+## `svelte_component_missing_this`
 
 ```
 `<svelte:component>` must have a 'this' attribute
 ```
 
-## svelte_element_missing_this
+## `svelte_element_missing_this`
 
 ```
 `<svelte:element>` must have a 'this' attribute with a value
 ```
 
-## svelte_fragment_invalid_attribute
+## `svelte_fragment_invalid_attribute`
 
 ```
 `<svelte:fragment>` can only have a slot attribute and (optionally) a let: directive
 ```
 
-## svelte_fragment_invalid_placement
+## `svelte_fragment_invalid_placement`
 
 ```
 `<svelte:fragment>` must be the direct child of a component
 ```
 
-## svelte_head_illegal_attribute
+## `svelte_head_illegal_attribute`
 
 ```
 `<svelte:head>` cannot have attributes nor directives
 ```
 
-## svelte_meta_duplicate
+## `svelte_meta_duplicate`
 
 ```
 A component can only have one `<%name%>` element
 ```
 
-## svelte_meta_invalid_content
+## `svelte_meta_invalid_content`
 
 ```
 <%name%> cannot have children
 ```
 
-## svelte_meta_invalid_placement
+## `svelte_meta_invalid_placement`
 
 ```
 `<%name%>` tags cannot be inside elements or blocks
 ```
 
-## svelte_meta_invalid_tag
+## `svelte_meta_invalid_tag`
 
 ```
 Valid `<svelte:...>` tag names are %list%
 ```
 
-## svelte_options_deprecated_tag
+## `svelte_options_deprecated_tag`
 
 ```
 "tag" option is deprecated — use "customElement" instead
 ```
 
-## svelte_options_invalid_attribute
+## `svelte_options_invalid_attribute`
 
 ```
 `<svelte:options>` can only receive static attributes
 ```
 
-## svelte_options_invalid_attribute_value
+## `svelte_options_invalid_attribute_value`
 
 ```
 Value must be %list%, if specified
 ```
 
-## svelte_options_invalid_customelement
+## `svelte_options_invalid_customelement`
 
 ```
 "customElement" must be a string literal defining a valid custom element name or an object of the form { tag?: string; shadow?: "open" | "none"; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }
 ```
 
-## svelte_options_invalid_customelement_props
+## `svelte_options_invalid_customelement_props`
 
 ```
 "props" must be a statically analyzable object literal of the form "{ [key: string]: { attribute?: string; reflect?: boolean; type?: "String" | "Boolean" | "Number" | "Array" | "Object" }"
 ```
 
-## svelte_options_invalid_customelement_shadow
+## `svelte_options_invalid_customelement_shadow`
 
 ```
 "shadow" must be either "open" or "none"
 ```
 
-## svelte_options_invalid_tagname
+## `svelte_options_invalid_tagname`
 
 ```
 Tag name must be lowercase and hyphenated
@@ -868,7 +862,7 @@ Tag name must be lowercase and hyphenated
 
 See https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name for more information on valid tag names
 
-## svelte_options_reserved_tagname
+## `svelte_options_reserved_tagname`
 
 ```
 Tag name is reserved
@@ -876,73 +870,79 @@ Tag name is reserved
 
 See https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name for more information on valid tag names
 
-## svelte_options_unknown_attribute
+## `svelte_options_unknown_attribute`
 
 ```
 `<svelte:options>` unknown attribute '%name%'
 ```
 
-## svelte_self_invalid_placement
+## `svelte_self_invalid_placement`
 
 ```
 `<svelte:self>` components can only exist inside `{#if}` blocks, `{#each}` blocks, `{#snippet}` blocks or slots passed to components
 ```
 
-## tag_invalid_name
+## `tag_invalid_name`
 
 ```
 Expected a valid element or component name. Components must have a valid variable name or dot notation expression
 ```
 
-## tag_invalid_placement
+## `tag_invalid_placement`
 
 ```
 {@%name% ...} tag cannot be %location%
 ```
 
-## textarea_invalid_content
+## `textarea_invalid_content`
 
 ```
 A `<textarea>` can have either a value attribute or (equivalently) child content, but not both
 ```
 
-## title_illegal_attribute
+## `title_illegal_attribute`
 
 ```
 `<title>` cannot have attributes nor directives
 ```
 
-## title_invalid_content
+## `title_invalid_content`
 
 ```
 `<title>` can only contain text and {tags}
 ```
 
-## transition_conflict
+## `transition_conflict`
 
 ```
 Cannot use `%type%:` alongside existing `%existing%:` directive
 ```
 
-## transition_duplicate
+## `transition_duplicate`
 
 ```
 Cannot use multiple `%type%:` directives on a single element
 ```
 
-## unexpected_eof
+## `typescript_invalid_feature`
+
+```
+TypeScript language features like %feature% are not natively supported, and their use is generally discouraged. Outside of `<script>` tags, these features are not supported. For use within `<script>` tags, you will need to use a preprocessor to convert it to JavaScript before it gets passed to the Svelte compiler. If you are using `vitePreprocess`, make sure to specifically enable preprocessing script tags (`vitePreprocess({ script: true })`)
+```
+
+## `unexpected_eof`
 
 ```
 Unexpected end of input
 ```
 
-## unexpected_reserved_word
+## `unexpected_reserved_word`
 
 ```
 '%word%' is a reserved word in JavaScript and cannot be used here
 ```
 
-## void_element_invalid_content
+## `void_element_invalid_content`
 
 ```
 Void elements cannot have children or closing tags
diff --git a/documentation/docs/98-reference/30-compiler-warnings.md b/documentation/docs/98-reference/30-compiler-warnings.md
index da87329157..8d1ed908b6 100644
--- a/documentation/docs/98-reference/30-compiler-warnings.md
+++ b/documentation/docs/98-reference/30-compiler-warnings.md
@@ -3,247 +3,247 @@ title: 'Compiler Warnings'
 generated: 'generated by process-messages/index.js'
 ---
 
-## a11y_accesskey
+## `a11y_accesskey`
 
 ```
 Avoid using accesskey
 ```
 
-## a11y_aria_activedescendant_has_tabindex
+## `a11y_aria_activedescendant_has_tabindex`
 
 ```
 An element with an aria-activedescendant attribute should have a tabindex value
 ```
 
-## a11y_aria_attributes
+## `a11y_aria_attributes`
 
 ```
 `<%name%>` should not have aria-* attributes
 ```
 
-## a11y_autocomplete_valid
+## `a11y_autocomplete_valid`
 
 ```
 '%value%' is an invalid value for 'autocomplete' on `<input type="%type%">`
 ```
 
-## a11y_autofocus
+## `a11y_autofocus`
 
 ```
 Avoid using autofocus
 ```
 
-## a11y_click_events_have_key_events
+## `a11y_click_events_have_key_events`
 
 ```
 Visible, non-interactive elements with a click event must be accompanied by a keyboard event handler. Consider whether an interactive element such as `<button type="button">` or `<a>` might be more appropriate. See https://svelte.dev/docs/accessibility-warnings#a11y-click-events-have-key-events for more details
 ```
 
-## a11y_consider_explicit_label
+## `a11y_consider_explicit_label`
 
 ```
 Buttons and links should either contain text or have an `aria-label` or `aria-labelledby` attribute
 ```
 
-## a11y_distracting_elements
+## `a11y_distracting_elements`
 
 ```
 Avoid `<%name%>` elements
 ```
 
-## a11y_figcaption_index
+## `a11y_figcaption_index`
 
 ```
 `<figcaption>` must be first or last child of `<figure>`
 ```
 
-## a11y_figcaption_parent
+## `a11y_figcaption_parent`
 
 ```
 `<figcaption>` must be an immediate child of `<figure>`
 ```
 
-## a11y_hidden
+## `a11y_hidden`
 
 ```
 `<%name%>` element should not be hidden
 ```
 
-## a11y_img_redundant_alt
+## `a11y_img_redundant_alt`
 
 ```
 Screenreaders already announce `<img>` elements as an image
 ```
 
-## a11y_incorrect_aria_attribute_type
+## `a11y_incorrect_aria_attribute_type`
 
 ```
 The value of '%attribute%' must be a %type%
 ```
 
-## a11y_incorrect_aria_attribute_type_boolean
+## `a11y_incorrect_aria_attribute_type_boolean`
 
 ```
 The value of '%attribute%' must be either 'true' or 'false'. It cannot be empty
 ```
 
-## a11y_incorrect_aria_attribute_type_id
+## `a11y_incorrect_aria_attribute_type_id`
 
 ```
 The value of '%attribute%' must be a string that represents a DOM element ID
 ```
 
-## a11y_incorrect_aria_attribute_type_idlist
+## `a11y_incorrect_aria_attribute_type_idlist`
 
 ```
 The value of '%attribute%' must be a space-separated list of strings that represent DOM element IDs
 ```
 
-## a11y_incorrect_aria_attribute_type_integer
+## `a11y_incorrect_aria_attribute_type_integer`
 
 ```
 The value of '%attribute%' must be an integer
 ```
 
-## a11y_incorrect_aria_attribute_type_token
+## `a11y_incorrect_aria_attribute_type_token`
 
 ```
 The value of '%attribute%' must be exactly one of %values%
 ```
 
-## a11y_incorrect_aria_attribute_type_tokenlist
+## `a11y_incorrect_aria_attribute_type_tokenlist`
 
 ```
 The value of '%attribute%' must be a space-separated list of one or more of %values%
 ```
 
-## a11y_incorrect_aria_attribute_type_tristate
+## `a11y_incorrect_aria_attribute_type_tristate`
 
 ```
 The value of '%attribute%' must be exactly one of true, false, or mixed
 ```
 
-## a11y_interactive_supports_focus
+## `a11y_interactive_supports_focus`
 
 ```
 Elements with the '%role%' interactive role must have a tabindex value
 ```
 
-## a11y_invalid_attribute
+## `a11y_invalid_attribute`
 
 ```
 '%href_value%' is not a valid %href_attribute% attribute
 ```
 
-## a11y_label_has_associated_control
+## `a11y_label_has_associated_control`
 
 ```
 A form label must be associated with a control
 ```
 
-## a11y_media_has_caption
+## `a11y_media_has_caption`
 
 ```
 `<video>` elements must have a `<track kind="captions">`
 ```
 
-## a11y_misplaced_role
+## `a11y_misplaced_role`
 
 ```
 `<%name%>` should not have role attribute
 ```
 
-## a11y_misplaced_scope
+## `a11y_misplaced_scope`
 
 ```
 The scope attribute should only be used with `<th>` elements
 ```
 
-## a11y_missing_attribute
+## `a11y_missing_attribute`
 
 ```
 `<%name%>` element should have %article% %sequence% attribute
 ```
 
-## a11y_missing_content
+## `a11y_missing_content`
 
 ```
 `<%name%>` element should contain text
 ```
 
-## a11y_mouse_events_have_key_events
+## `a11y_mouse_events_have_key_events`
 
 ```
 '%event%' event must be accompanied by '%accompanied_by%' event
 ```
 
-## a11y_no_abstract_role
+## `a11y_no_abstract_role`
 
 ```
 Abstract role '%role%' is forbidden
 ```
 
-## a11y_no_interactive_element_to_noninteractive_role
+## `a11y_no_interactive_element_to_noninteractive_role`
 
 ```
 `<%element%>` cannot have role '%role%'
 ```
 
-## a11y_no_noninteractive_element_interactions
+## `a11y_no_noninteractive_element_interactions`
 
 ```
 Non-interactive element `<%element%>` should not be assigned mouse or keyboard event listeners
 ```
 
-## a11y_no_noninteractive_element_to_interactive_role
+## `a11y_no_noninteractive_element_to_interactive_role`
 
 ```
 Non-interactive element `<%element%>` cannot have interactive role '%role%'
 ```
 
-## a11y_no_noninteractive_tabindex
+## `a11y_no_noninteractive_tabindex`
 
 ```
 noninteractive element cannot have nonnegative tabIndex value
 ```
 
-## a11y_no_redundant_roles
+## `a11y_no_redundant_roles`
 
 ```
 Redundant role '%role%'
 ```
 
-## a11y_no_static_element_interactions
+## `a11y_no_static_element_interactions`
 
 ```
 `<%element%>` with a %handler% handler must have an ARIA role
 ```
 
-## a11y_positive_tabindex
+## `a11y_positive_tabindex`
 
 ```
 Avoid tabindex values above zero
 ```
 
-## a11y_role_has_required_aria_props
+## `a11y_role_has_required_aria_props`
 
 ```
 Elements with the ARIA role "%role%" must have the following attributes defined: %props%
 ```
 
-## a11y_role_supports_aria_props
+## `a11y_role_supports_aria_props`
 
 ```
 The attribute '%attribute%' is not supported by the role '%role%'
 ```
 
-## a11y_role_supports_aria_props_implicit
+## `a11y_role_supports_aria_props_implicit`
 
 ```
 The attribute '%attribute%' is not supported by the role '%role%'. This role is implicit on the element `<%name%>`
 ```
 
-## a11y_unknown_aria_attribute
+## `a11y_unknown_aria_attribute`
 
 ```
 Unknown aria attribute 'aria-%attribute%'
@@ -252,7 +252,7 @@ Unknown aria attribute 'aria-%attribute%'
 Unknown aria attribute 'aria-%attribute%'. Did you mean '%suggestion%'?
 ```
 
-## a11y_unknown_role
+## `a11y_unknown_role`
 
 ```
 Unknown role '%role%'
@@ -261,222 +261,213 @@ Unknown role '%role%'
 Unknown role '%role%'. Did you mean '%suggestion%'?
 ```
 
-## legacy_code
+## `attribute_avoid_is`
 
 ```
-`%code%` is no longer valid — please use `%suggestion%` instead
+The "is" attribute is not supported cross-browser and should be avoided
 ```
 
-## unknown_code
+## `attribute_global_event_reference`
 
 ```
-`%code%` is not a recognised code
-```
-```
-`%code%` is not a recognised code (did you mean `%suggestion%`?)
+You are referencing `globalThis.%name%`. Did you forget to declare a variable with that name?
 ```
 
-## options_deprecated_accessors
+## `attribute_illegal_colon`
 
 ```
-The `accessors` option has been deprecated. It will have no effect in runes mode
+Attributes should not contain ':' characters to prevent ambiguity with Svelte directives
 ```
 
-## options_deprecated_immutable
+## `attribute_invalid_property_name`
 
 ```
-The `immutable` option has been deprecated. It will have no effect in runes mode
+'%wrong%' is not a valid HTML attribute. Did you mean '%right%'?
 ```
 
-## options_missing_custom_element
+## `attribute_quoted`
 
 ```
-The `customElement` option is used when generating a custom element. Did you forget the `customElement: true` compile option?
+Quoted attributes on components and custom elements will be stringified in a future version of Svelte. If this isn't what you want, remove the quotes
 ```
 
-## options_removed_enable_sourcemap
+## `bind_invalid_each_rest`
 
 ```
-The `enableSourcemap` option has been removed. Source maps are always generated now, and tooling can choose to ignore them
+The rest operator (...) will create a new object and binding '%name%' with the original object will not work
 ```
 
-## options_removed_hydratable
+## `block_empty`
 
 ```
-The `hydratable` option has been removed. Svelte components are always hydratable now
+Empty block
 ```
 
-## options_removed_loop_guard_timeout
+## `component_name_lowercase`
 
 ```
-The `loopGuardTimeout` option has been removed
+`<%name%>` will be treated as an HTML element unless it begins with a capital letter
 ```
 
-## options_renamed_ssr_dom
+## `css_unused_selector`
 
 ```
-`generate: "dom"` and `generate: "ssr"` options have been renamed to "client" and "server" respectively
+Unused CSS selector "%name%"
 ```
 
-## export_let_unused
+## `element_invalid_self_closing_tag`
 
 ```
-Component has unused export property '%name%'. If it is for external reference only, please consider using `export const %name%`
+Self-closing HTML tags for non-void elements are ambiguous — use `<%name% ...></%name%>` rather than `<%name% ... />`
 ```
 
-## legacy_component_creation
+## `event_directive_deprecated`
 
 ```
-Svelte 5 components are no longer classes. Instantiate them using `mount` or `hydrate` (imported from 'svelte') instead.
+Using `on:%name%` to listen to the %name% event is deprecated. Use the event attribute `on%name%` instead
 ```
 
-## non_reactive_update
+## `export_let_unused`
 
 ```
-`%name%` is updated, but is not declared with `$state(...)`. Changing its value will not correctly trigger updates
+Component has unused export property '%name%'. If it is for external reference only, please consider using `export const %name%`
 ```
 
-## perf_avoid_inline_class
+## `legacy_code`
 
 ```
-Avoid 'new class' — instead, declare the class at the top level scope
+`%code%` is no longer valid — please use `%suggestion%` instead
 ```
 
-## perf_avoid_nested_class
+## `legacy_component_creation`
 
 ```
-Avoid declaring classes below the top level scope
+Svelte 5 components are no longer classes. Instantiate them using `mount` or `hydrate` (imported from 'svelte') instead.
 ```
 
-## reactive_declaration_invalid_placement
+## `node_invalid_placement_ssr`
 
 ```
-Reactive declarations only exist at the top level of the instance script
+%thing% is invalid inside `<%parent%>`. When rendering this component on the server, the resulting HTML will be modified by the browser, likely resulting in a `hydration_mismatch` warning
 ```
 
-## reactive_declaration_module_script_dependency
+HTML restricts where certain elements can appear. In case of a violation the browser will 'repair' the HTML in a way that breaks Svelte's assumptions about the structure of your components. Some examples:
 
-```
-Reassignments of module-level declarations will not cause reactive statements to update
-```
+- `<p>hello <div>world</div></p>` will result in `<p>hello </p><div>world</div><p></p>` for example (the `<div>` autoclosed the `<p>` because `<p>` cannot contain block-level elements)
+- `<option><div>option a</div></option>` will result in `<option>option a</option>` (the `<div>` is removed)
+- `<table><tr><td>cell</td></tr></table>` will result in `<table><tbody><tr><td>cell</td></tr></tbody></table>` (a `<tbody>` is auto-inserted)
+
+This code will work when the component is rendered on the client (which is why this is a warning rather than an error), but if you use server rendering it will cause hydration to fail.
 
-## reactive_declaration_non_reactive_property
+## `non_reactive_update`
 
 ```
-Properties of objects and arrays are not reactive unless in runes mode. Changes to this property will not cause the reactive statement to update
+`%name%` is updated, but is not declared with `$state(...)`. Changing its value will not correctly trigger updates
 ```
 
-## state_referenced_locally
+## `options_deprecated_accessors`
 
 ```
-State referenced in its own scope will never update. Did you mean to reference it inside a closure?
+The `accessors` option has been deprecated. It will have no effect in runes mode
 ```
 
-## store_rune_conflict
+## `options_deprecated_immutable`
 
 ```
-It looks like you're using the `$%name%` rune, but there is a local binding called `%name%`. Referencing a local variable with a `$` prefix will create a store subscription. Please rename `%name%` to avoid the ambiguity
+The `immutable` option has been deprecated. It will have no effect in runes mode
 ```
 
-## css_unused_selector
+## `options_missing_custom_element`
 
 ```
-Unused CSS selector "%name%"
+The `customElement` option is used when generating a custom element. Did you forget the `customElement: true` compile option?
 ```
 
-## attribute_avoid_is
+## `options_removed_enable_sourcemap`
 
 ```
-The "is" attribute is not supported cross-browser and should be avoided
+The `enableSourcemap` option has been removed. Source maps are always generated now, and tooling can choose to ignore them
 ```
 
-## attribute_global_event_reference
+## `options_removed_hydratable`
 
 ```
-You are referencing `globalThis.%name%`. Did you forget to declare a variable with that name?
+The `hydratable` option has been removed. Svelte components are always hydratable now
 ```
 
-## attribute_illegal_colon
+## `options_removed_loop_guard_timeout`
 
 ```
-Attributes should not contain ':' characters to prevent ambiguity with Svelte directives
+The `loopGuardTimeout` option has been removed
 ```
 
-## attribute_invalid_property_name
+## `options_renamed_ssr_dom`
 
 ```
-'%wrong%' is not a valid HTML attribute. Did you mean '%right%'?
+`generate: "dom"` and `generate: "ssr"` options have been renamed to "client" and "server" respectively
 ```
 
-## attribute_quoted
+## `perf_avoid_inline_class`
 
 ```
-Quoted attributes on components and custom elements will be stringified in a future version of Svelte. If this isn't what you want, remove the quotes
+Avoid 'new class' — instead, declare the class at the top level scope
 ```
 
-## bind_invalid_each_rest
+## `perf_avoid_nested_class`
 
 ```
-The rest operator (...) will create a new object and binding '%name%' with the original object will not work
+Avoid declaring classes below the top level scope
 ```
 
-## block_empty
+## `reactive_declaration_invalid_placement`
 
 ```
-Empty block
+Reactive declarations only exist at the top level of the instance script
 ```
 
-## component_name_lowercase
+## `reactive_declaration_module_script_dependency`
 
 ```
-`<%name%>` will be treated as an HTML element unless it begins with a capital letter
+Reassignments of module-level declarations will not cause reactive statements to update
 ```
 
-## element_invalid_self_closing_tag
+## `reactive_declaration_non_reactive_property`
 
 ```
-Self-closing HTML tags for non-void elements are ambiguous — use `<%name% ...></%name%>` rather than `<%name% ... />`
+Properties of objects and arrays are not reactive unless in runes mode. Changes to this property will not cause the reactive statement to update
 ```
 
-## event_directive_deprecated
+## `script_context_deprecated`
 
 ```
-Using `on:%name%` to listen to the %name% event is deprecated. Use the event attribute `on%name%` instead
+`context="module"` is deprecated, use the `module` attribute instead
 ```
 
-## node_invalid_placement_ssr
+## `script_unknown_attribute`
 
 ```
-%thing% is invalid inside `<%parent%>`. When rendering this component on the server, the resulting HTML will be modified by the browser, likely resulting in a `hydration_mismatch` warning
+Unrecognized attribute — should be one of `generics`, `lang` or `module`. If this exists for a preprocessor, ensure that the preprocessor removes it
 ```
 
-HTML restricts where certain elements can appear. In case of a violation the browser will 'repair' the HTML in a way that breaks Svelte's assumptions about the structure of your components. Some examples:
-
-- `<p>hello <div>world</div></p>` will result in `<p>hello </p><div>world</div><p></p>` for example (the `<div>` autoclosed the `<p>` because `<p>` cannot contain block-level elements)
-- `<option><div>option a</div></option>` will result in `<option>option a</option>` (the `<div>` is removed)
-- `<table><tr><td>cell</td></tr></table>` will result in `<table><tbody><tr><td>cell</td></tr></tbody></table>` (a `<tbody>` is auto-inserted)
-
-This code will work when the component is rendered on the client (which is why this is a warning rather than an error), but if you use server rendering it will cause hydration to fail.
-
-## script_context_deprecated
+## `slot_element_deprecated`
 
 ```
-`context="module"` is deprecated, use the `module` attribute instead
+Using `<slot>` to render parent content is deprecated. Use `{@render ...}` tags instead
 ```
 
-## script_unknown_attribute
+## `state_referenced_locally`
 
 ```
-Unrecognized attribute — should be one of `generics`, `lang` or `module`. If this exists for a preprocessor, ensure that the preprocessor removes it
+State referenced in its own scope will never update. Did you mean to reference it inside a closure?
 ```
 
-## slot_element_deprecated
+## `store_rune_conflict`
 
 ```
-Using `<slot>` to render parent content is deprecated. Use `{@render ...}` tags instead
+It looks like you're using the `$%name%` rune, but there is a local binding called `%name%`. Referencing a local variable with a `$` prefix will create a store subscription. Please rename `%name%` to avoid the ambiguity
 ```
 
-## svelte_component_deprecated
+## `svelte_component_deprecated`
 
 ```
 `<svelte:component>` is deprecated in runes mode — components are dynamic by default
@@ -510,14 +501,23 @@ A derived value may be used in other contexts:
 + <Component />
 ```
 
-## svelte_element_invalid_this
+## `svelte_element_invalid_this`
 
 ```
 `this` should be an `{expression}`. Using a string attribute value will cause an error in future versions of Svelte
 ```
 
-## svelte_self_deprecated
+## `svelte_self_deprecated`
 
 ```
 `<svelte:self>` is deprecated — use self-imports (e.g. `import %name% from './%basename%'`) instead
 ```
+
+## `unknown_code`
+
+```
+`%code%` is not a recognised code
+```
+```
+`%code%` is not a recognised code (did you mean `%suggestion%`?)
+```
diff --git a/documentation/docs/98-reference/30-runtime-errors.md b/documentation/docs/98-reference/30-runtime-errors.md
index 8c7b286a7b..ad58776772 100644
--- a/documentation/docs/98-reference/30-runtime-errors.md
+++ b/documentation/docs/98-reference/30-runtime-errors.md
@@ -3,43 +3,43 @@ title: 'Runtime Errors'
 generated: 'generated by process-messages/index.js'
 ---
 
-## bind_invalid_checkbox_value
+## `bind_invalid_checkbox_value`
 
 ```
 Using `bind:value` together with a checkbox input is not allowed. Use `bind:checked` instead
 ```
 
-## bind_invalid_export
+## `bind_invalid_export`
 
 ```
 Component %component% has an export named `%key%` that a consumer component is trying to access using `bind:%key%`, which is disallowed. Instead, use `bind:this` (e.g. `<%name% bind:this={component} />`) and then access the property on the bound component instance (e.g. `component.%key%`)
 ```
 
-## bind_not_bindable
+## `bind_not_bindable`
 
 ```
 A component is attempting to bind to a non-bindable property `%key%` belonging to %component% (i.e. `<%name% bind:%key%={...}>`). To mark a property as bindable: `let { %key% = $bindable() } = $props()`
 ```
 
-## component_api_changed
+## `component_api_changed`
 
 ```
 %parent% called `%method%` on an instance of %component%, which is no longer valid in Svelte 5. See https://svelte-5-preview.vercel.app/docs/breaking-changes#components-are-no-longer-classes for more information
 ```
 
-## component_api_invalid_new
+## `component_api_invalid_new`
 
 ```
 Attempted to instantiate %component% with `new %name%`, which is no longer valid in Svelte 5. If this component is not under your control, set the `compatibility.componentApi` compiler option to `4` to keep it working. See https://svelte-5-preview.vercel.app/docs/breaking-changes#components-are-no-longer-classes for more information
 ```
 
-## derived_references_self
+## `derived_references_self`
 
 ```
 A derived value cannot reference itself recursively
 ```
 
-## each_key_duplicate
+## `each_key_duplicate`
 
 ```
 Keyed each block has duplicate key at indexes %a% and %b%
@@ -48,115 +48,115 @@ Keyed each block has duplicate key at indexes %a% and %b%
 Keyed each block has duplicate key `%value%` at indexes %a% and %b%
 ```
 
-## effect_in_teardown
+## `effect_in_teardown`
 
 ```
 `%rune%` cannot be used inside an effect cleanup function
 ```
 
-## effect_in_unowned_derived
+## `effect_in_unowned_derived`
 
 ```
 Effect cannot be created inside a `$derived` value that was not itself created inside an effect
 ```
 
-## effect_orphan
+## `effect_orphan`
 
 ```
 `%rune%` can only be used inside an effect (e.g. during component initialisation)
 ```
 
-## effect_update_depth_exceeded
+## `effect_update_depth_exceeded`
 
 ```
 Maximum update depth exceeded. This can happen when a reactive block or effect repeatedly sets a new value. Svelte limits the number of nested updates to prevent infinite loops
 ```
 
-## hydration_failed
+## `hydration_failed`
 
 ```
 Failed to hydrate the application
 ```
 
-## invalid_snippet
+## `invalid_default_snippet`
 
 ```
-Could not `{@render}` snippet due to the expression being `null` or `undefined`. Consider using optional chaining `{@render snippet?.()}`
+Cannot use `{@render children(...)}` if the parent component uses `let:` directives. Consider using a named snippet instead
 ```
 
-## lifecycle_legacy_only
+## `invalid_snippet`
 
 ```
-`%name%(...)` cannot be used in runes mode
+Could not `{@render}` snippet due to the expression being `null` or `undefined`. Consider using optional chaining `{@render snippet?.()}`
 ```
 
-## props_invalid_value
+## `lifecycle_function_unavailable`
 
 ```
-Cannot do `bind:%key%={undefined}` when `%key%` has a fallback value
+`%name%(...)` is not available on the server
 ```
 
-## props_rest_readonly
+## `lifecycle_legacy_only`
 
 ```
-Rest element properties of `$props()` such as `%property%` are readonly
+`%name%(...)` cannot be used in runes mode
 ```
 
-## rune_outside_svelte
+## `lifecycle_outside_component`
 
 ```
-The `%rune%` rune is only available inside `.svelte` and `.svelte.js/ts` files
+`%name%(...)` can only be used during component initialisation
 ```
 
-## state_descriptors_fixed
+## `props_invalid_value`
 
 ```
-Property descriptors defined on `$state` objects must contain `value` and always be `enumerable`, `configurable` and `writable`.
+Cannot do `bind:%key%={undefined}` when `%key%` has a fallback value
 ```
 
-## state_prototype_fixed
+## `props_rest_readonly`
 
 ```
-Cannot set prototype of `$state` object
+Rest element properties of `$props()` such as `%property%` are readonly
 ```
 
-## state_unsafe_local_read
+## `rune_outside_svelte`
 
 ```
-Reading state that was created inside the same derived is forbidden. Consider using `untrack` to read locally created state
+The `%rune%` rune is only available inside `.svelte` and `.svelte.js/ts` files
 ```
 
-## state_unsafe_mutation
+## `state_descriptors_fixed`
 
 ```
-Updating state inside a derived is forbidden. If the value should not be reactive, declare it without `$state`
+Property descriptors defined on `$state` objects must contain `value` and always be `enumerable`, `configurable` and `writable`.
 ```
 
-## lifecycle_function_unavailable
+## `state_prototype_fixed`
 
 ```
-`%name%(...)` is not available on the server
+Cannot set prototype of `$state` object
 ```
 
-## invalid_default_snippet
+## `state_unsafe_local_read`
 
 ```
-Cannot use `{@render children(...)}` if the parent component uses `let:` directives. Consider using a named snippet instead
+Reading state that was created inside the same derived is forbidden. Consider using `untrack` to read locally created state
 ```
 
-## lifecycle_outside_component
+## `state_unsafe_mutation`
 
 ```
-`%name%(...)` can only be used during component initialisation
+Updating state inside a derived is forbidden. If the value should not be reactive, declare it without `$state`
 ```
 
-## store_invalid_shape
+## `store_invalid_shape`
 
 ```
 `%name%` is not a store with a `subscribe` method
 ```
 
-## svelte_element_invalid_this_value
+## `svelte_element_invalid_this_value`
 
 ```
 The `this` prop on `<svelte:element>` must be a string, if defined
diff --git a/documentation/docs/98-reference/30-runtime-warnings.md b/documentation/docs/98-reference/30-runtime-warnings.md
index c1c6ba2fb1..5b4eaaac8e 100644
--- a/documentation/docs/98-reference/30-runtime-warnings.md
+++ b/documentation/docs/98-reference/30-runtime-warnings.md
@@ -3,7 +3,7 @@ title: 'Runtime Warnings'
 generated: 'generated by process-messages/index.js'
 ---
 
-## binding_property_non_reactive
+## `binding_property_non_reactive`
 
 ```
 `%binding%` is binding to a non-reactive property
@@ -12,7 +12,7 @@ generated: 'generated by process-messages/index.js'
 `%binding%` (%location%) is binding to a non-reactive property
 ```
 
-## console_log_state
+## `console_log_state`
 
 ```
 Your `console.%method%` contained `$state` proxies. Consider using `$inspect(...)` or `$state.snapshot(...)` instead
@@ -22,19 +22,25 @@ When logging a [proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/R
 
 The easiest way to log a value as it changes over time is to use the [`$inspect`](https://svelte-5-preview.vercel.app/docs/runes#$inspect) rune. Alternatively, to log things on a one-off basis (for example, inside an event handler) you can use [`$state.snapshot`](https://svelte-5-preview.vercel.app/docs/runes#$state-snapshot) to take a snapshot of the current value.
 
-## event_handler_invalid
+## `dynamic_void_element_content`
+
+```
+`<svelte:element this="%tag%">` is a void element — it cannot have content
+```
+
+## `event_handler_invalid`
 
 ```
 %handler% should be a function. Did you mean to %suggestion%?
 ```
 
-## hydration_attribute_changed
+## `hydration_attribute_changed`
 
 ```
 The `%attribute%` attribute on `%html%` changed its value between server and client renders. The client value, `%value%`, will be ignored in favour of the server value
 ```
 
-## hydration_html_changed
+## `hydration_html_changed`
 
 ```
 The value of an `{@html ...}` block changed between server and client renders. The client value will be ignored in favour of the server value
@@ -43,7 +49,7 @@ The value of an `{@html ...}` block changed between server and client renders. T
 The value of an `{@html ...}` block %location% changed between server and client renders. The client value will be ignored in favour of the server value
 ```
 
-## hydration_mismatch
+## `hydration_mismatch`
 
 ```
 Hydration failed because the initial UI does not match what was rendered on the server
@@ -52,25 +58,25 @@ Hydration failed because the initial UI does not match what was rendered on the
 Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near %location%
 ```
 
-## invalid_raw_snippet_render
+## `invalid_raw_snippet_render`
 
 ```
 The `render` function passed to `createRawSnippet` should return HTML for a single element
 ```
 
-## lifecycle_double_unmount
+## `lifecycle_double_unmount`
 
 ```
 Tried to unmount a component that was not mounted
 ```
 
-## ownership_invalid_binding
+## `ownership_invalid_binding`
 
 ```
 %parent% passed a value to %child% with `bind:`, but the value is owned by %owner%. Consider creating a binding between %owner% and %parent%
 ```
 
-## ownership_invalid_mutation
+## `ownership_invalid_mutation`
 
 ```
 Mutating a value outside the component that created it is strongly discouraged. Consider passing values to child components with `bind:`, or use a callback instead
@@ -79,7 +85,7 @@ Mutating a value outside the component that created it is strongly discouraged.
 %component% mutated a value owned by %owner%. This is strongly discouraged. Consider passing values to child components with `bind:`, or use a callback instead
 ```
 
-## state_proxy_equality_mismatch
+## `state_proxy_equality_mismatch`
 
 ```
 Reactive `$state(...)` proxies and the values they proxy have different identities. Because of this, comparisons with `%operator%` will produce unexpected results
@@ -98,13 +104,7 @@ 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.
 
-## dynamic_void_element_content
-
-```
-`<svelte:element this="%tag%">` is a void element — it cannot have content
-```
-
-## state_snapshot_uncloneable
+## `state_snapshot_uncloneable`
 
 ```
 Value cannot be cloned with `$state.snapshot` — the original value was returned
diff --git a/packages/svelte/scripts/process-messages/index.js b/packages/svelte/scripts/process-messages/index.js
index 889c4b7e18..66ec66bfbc 100644
--- a/packages/svelte/scripts/process-messages/index.js
+++ b/packages/svelte/scripts/process-messages/index.js
@@ -97,8 +97,10 @@ for (const [category, codes] of Object.entries(consolidated_messages)) {
 		'---\n'
 	];
 
-	for (const [code, { messages, details }] of Object.entries(codes)) {
-		lines.push(`## ${code}\n`);
+	const sorted_codes = Object.entries(codes).sort(([a], [b]) => (a < b ? -1 : 1));
+
+	for (const [code, { messages, details }] of sorted_codes) {
+		lines.push(`## \`${code}\`\n`);
 		for (const message of messages) {
 			lines.push('```');
 			lines.push(message);