From 73490bbb8e3c0640ac72151d7e9aa8b5bf6604d6 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 23 Apr 2024 10:39:37 -0400
Subject: [PATCH] chore: markdown errors (#11294)

* rename errors.js to errors-tmp.js

* start porting errors

* generate markdown files for more errors

* convert parse errors

* convert css errors

* convert special_element errors

* convert runes errors

* convert element errors

* more

* more

* more

* more

* more

* more

* fix some tests

* fix some tests

* more tests

* remove unused error

* prettierignore

* weird

* ugh

* lint
---
 .prettierignore                               |    2 +
 eslint.config.js                              |    5 +-
 .../messages/compile-errors/attributes.md     |   59 +
 .../messages/compile-errors/bindings.md       |   35 +
 .../compile-errors/compiler_options.md        |    7 +
 .../messages/compile-errors/components.md     |    3 +
 .../messages/compile-errors/const_tag.md      |    3 +
 .../svelte/messages/compile-errors/css.md     |   51 +
 .../messages/compile-errors/elements.md       |   27 +
 .../compile-errors/legacy_reactivity.md       |    3 +
 .../svelte/messages/compile-errors/parse.md   |  147 ++
 .../svelte/messages/compile-errors/runes.md   |   95 +
 .../svelte/messages/compile-errors/slots.md   |   31 +
 .../compile-errors/special_elements.md        |   99 +
 .../messages/compile-errors/variables.md      |   19 +
 .../svelte/scripts/process-messages/index.js  |  213 ++
 .../templates/compile-errors.js               |   74 +
 packages/svelte/src/compiler/errors.js        | 1849 ++++++++++++-----
 .../src/compiler/phases/1-parse/index.js      |   22 +-
 .../compiler/phases/1-parse/read/context.js   |   10 +-
 .../phases/1-parse/read/expression.js         |    4 +-
 .../compiler/phases/1-parse/read/options.js   |   91 +-
 .../compiler/phases/1-parse/read/script.js    |    8 +-
 .../src/compiler/phases/1-parse/read/style.js |   22 +-
 .../compiler/phases/1-parse/state/element.js  |   74 +-
 .../src/compiler/phases/1-parse/state/tag.js  |   30 +-
 .../phases/2-analyze/css/css-analyze.js       |   27 +-
 .../src/compiler/phases/2-analyze/index.js    |   22 +-
 .../compiler/phases/2-analyze/validation.js   |  267 +--
 .../3-transform/client/transform-client.js    |   27 +-
 .../phases/3-transform/client/utils.js        |    3 +-
 .../3-transform/client/visitors/template.js   |    7 +-
 .../3-transform/server/transform-server.js    |   18 +-
 packages/svelte/src/compiler/phases/scope.js  |   12 +-
 packages/svelte/src/compiler/utils/assert.js  |    6 +-
 .../svelte/src/compiler/validate-options.js   |    9 +-
 .../samples/attribute-empty/_config.js        |    2 +-
 .../_config.js                                |    2 +-
 .../attribute-sequence-expression/_config.js  |    2 +-
 .../attribute-unique-binding/_config.js       |    2 +-
 .../attribute-unique-shorthand/_config.js     |    2 +-
 .../samples/attribute-unique/_config.js       |    2 +-
 .../samples/catch-before-closing/_config.js   |    2 +-
 .../samples/catch-without-await/_config.js    |    2 +-
 .../class-state-field-static/_config.js       |    5 +-
 .../samples/comment-unclosed/_config.js       |    4 +-
 .../_config.js                                |    2 +-
 .../_config.js                                |    2 +-
 .../_config.js                                |    2 +-
 .../_config.js                                |    2 +-
 .../_config.js                                |    2 +-
 .../component-slot-duplicate-error/_config.js |    2 +-
 .../component-slot-nested-error-2/_config.js  |    2 +-
 .../component-slot-nested-error-3/_config.js  |    2 +-
 .../component-slot-nested-error/_config.js    |    2 +-
 .../css-global-block-combinator/_config.js    |    2 +-
 .../css-global-block-declaration/_config.js   |    2 +-
 .../css-global-block-modifier/_config.js      |    2 +-
 .../css-global-block-multiple/_config.js      |    2 +-
 .../compiler-errors/samples/css/_config.js    |    2 +-
 .../dollar-binding-declaration/_config.js     |    2 +-
 .../dollar-binding-global-js/_config.js       |    4 +-
 .../samples/dollar-binding-global/_config.js  |    4 +-
 .../samples/dollar-binding-import/_config.js  |    2 +-
 .../_config.js                                |    4 +-
 .../samples/else-before-closing-2/_config.js  |    2 +-
 .../samples/else-before-closing-3/_config.js  |    2 +-
 .../samples/else-before-closing/_config.js    |    2 +-
 .../else-if-before-closing-2/_config.js       |    2 +-
 .../samples/else-if-before-closing/_config.js |    2 +-
 .../samples/else-if-without-if/_config.js     |    2 +-
 .../empty-attribute-shorthand/_config.js      |    2 +-
 .../empty-classname-binding/_config.js        |    2 +-
 .../samples/empty-directive-name/_config.js   |    2 +-
 .../samples/export-derived-state/_config.js   |    2 +-
 .../samples/export-state-module/_config.js    |    2 +-
 .../samples/export-state/_config.js           |    2 +-
 .../samples/illegal-expression/_config.js     |    2 +-
 .../invalid-snippet-binding/_config.js        |    2 +-
 .../invalid-snippet-mutation/_config.js       |    2 +-
 .../legacy-no-const-assignment/_config.js     |    4 +-
 .../samples/legacy-no-const-update/_config.js |    4 +-
 .../samples/multiple-styles/_config.js        |    4 +-
 .../samples/options-children/_config.js       |    2 +-
 .../raw-mustaches-whitespace/_config.js       |    2 +-
 .../render-tag-invalid-call/_config.js        |    2 +-
 .../runes-before-after-update/_config.js      |    2 +-
 .../samples/runes-duplicate-props/_config.js  |    4 +-
 .../samples/runes-export-let/_config.js       |    2 +-
 .../runes-export-named-state/_config.js       |    2 +-
 .../runes-invalid-each-binding/_config.js     |    4 +-
 .../runes-invalid-each-mutation/_config.js    |    4 +-
 .../runes-no-const-assignment/_config.js      |    4 +-
 .../samples/runes-no-const-update/_config.js  |    4 +-
 .../runes-no-derived-assignment/_config.js    |    4 +-
 .../runes-no-derived-binding/_config.js       |    4 +-
 .../_config.js                                |    4 +-
 .../_config.js                                |    4 +-
 .../runes-no-derived-update/_config.js        |    4 +-
 .../samples/runes-no-rune-each/_config.js     |    4 +-
 .../runes-prop-export-conflict/_config.js     |    2 +-
 .../runes-wrong-bindable-args/_config.js      |    4 +-
 .../runes-wrong-bindable-placement/_config.js |    4 +-
 .../runes-wrong-derived-args/_config.js       |    4 +-
 .../runes-wrong-derived-placement/_config.js  |    5 +-
 .../runes-wrong-effect-args/_config.js        |    4 +-
 .../runes-wrong-effect-placement/_config.js   |    4 +-
 .../runes-wrong-host-placement/_config.js     |    4 +-
 .../samples/runes-wrong-props-args/_config.js |    4 +-
 .../runes-wrong-props-placement/_config.js    |    4 +-
 .../samples/runes-wrong-state-args/_config.js |    4 +-
 .../runes-wrong-state-placement/_config.js    |    4 +-
 .../_config.js                                |    4 +-
 .../samples/script-unclosed-eof/_config.js    |    2 +-
 .../samples/script-unclosed/_config.js        |    4 +-
 .../samples/self-reference/_config.js         |    4 +-
 .../_config.js                                |    4 +-
 .../snippet-children-conflict/_config.js      |    2 +-
 .../store-autosub-context-module/_config.js   |    4 +-
 .../samples/store-contextual/_config.js       |    2 +-
 .../store-global-disallowed/_config.js        |    4 +-
 .../_config.js                                |    2 +-
 .../samples/store-shadow-scope-2/_config.js   |    2 +-
 .../samples/store-shadow-scope-3/_config.js   |    2 +-
 .../samples/store-shadow-scope/_config.js     |    2 +-
 .../_config.js                                |    2 +-
 .../samples/style-unclosed-eof/_config.js     |    2 +-
 .../samples/style-unclosed/_config.js         |    2 +-
 .../samples/svelte-selfdestructive/_config.js |    4 +-
 .../samples/then-before-closing/_config.js    |    2 +-
 .../samples/then-without-await/_config.js     |    2 +-
 .../_config.js                                |    2 +-
 .../unexpected-end-of-input-b/_config.js      |    2 +-
 .../unexpected-end-of-input-c/_config.js      |    2 +-
 .../unexpected-end-of-input-d/_config.js      |    2 +-
 .../unexpected-end-of-input/_config.js        |    4 +-
 .../_config.js                                |    2 +-
 .../_config.js                                |    2 +-
 .../samples/unmatched-closing-tag/_config.js  |    2 +-
 .../samples/void-closing/_config.js           |    2 +-
 .../samples/window-children/_config.js        |    2 +-
 .../samples/window-duplicate/_config.js       |    2 +-
 .../samples/window-inside-block/_config.js    |    2 +-
 .../samples/window-inside-element/_config.js  |    2 +-
 .../samples/action-on-component/errors.json   |    2 +-
 .../samples/animation-duplicate/errors.json   |    2 +-
 .../samples/animation-not-in-each/errors.json |    4 +-
 .../animation-not-in-keyed-each/errors.json   |    4 +-
 .../animation-on-component/errors.json        |    2 +-
 .../samples/animation-siblings/errors.json    |    4 +-
 .../samples/assignment-to-const-2/errors.json |    4 +-
 .../samples/assignment-to-const-3/errors.json |    4 +-
 .../samples/assignment-to-const-4/errors.json |    4 +-
 .../samples/assignment-to-const-5/errors.json |    4 +-
 .../samples/assignment-to-const-7/errors.json |    4 +-
 .../samples/assignment-to-const/errors.json   |    4 +-
 .../attribute-expected-equals/errors.json     |    2 +-
 .../attribute-invalid-name-2/errors.json      |    2 +-
 .../attribute-invalid-name-3/errors.json      |    2 +-
 .../attribute-invalid-name-4/errors.json      |    2 +-
 .../attribute-invalid-name-5/errors.json      |    2 +-
 .../attribute-invalid-name/errors.json        |    2 +-
 .../samples/binding-await-catch/errors.json   |   14 +-
 .../samples/binding-await-then-2/errors.json  |   14 +-
 .../samples/binding-await-then/errors.json    |   14 +-
 .../samples/binding-const/errors.json         |    4 +-
 .../binding-dimensions-svg/errors.json        |    4 +-
 .../samples/binding-input-checked/errors.json |    4 +-
 .../binding-input-type-boolean/errors.json    |    2 +-
 .../errors.json                               |    4 +-
 .../binding-invalid-on-element-2/errors.json  |    4 +-
 .../binding-invalid-on-element/errors.json    |    4 +-
 .../binding-invalid-value-global/errors.json  |    2 +-
 .../samples/binding-invalid-value/errors.json |    2 +-
 .../samples/binding-invalid/errors.json       |    4 +-
 .../validator/samples/binding-let/errors.json |    4 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |   12 +-
 .../errors.json                               |    4 +-
 .../errors.json                               |    2 +-
 .../component-slot-dynamic/errors.json        |    2 +-
 .../errors.json                               |   12 +-
 .../component-slotted-each-block/errors.json  |    2 +-
 .../component-slotted-if-block/errors.json    |    2 +-
 .../samples/const-tag-conflict-1/errors.json  |   14 +-
 .../samples/const-tag-conflict-2/errors.json  |   14 +-
 .../samples/const-tag-placement-1/errors.json |   12 +-
 .../samples/const-tag-placement-2/errors.json |   12 +-
 .../samples/const-tag-readonly-1/errors.json  |   14 +-
 .../samples/const-tag-readonly-2/errors.json  |   14 +-
 .../contenteditable-dynamic/errors.json       |    2 +-
 .../contenteditable-missing/errors.json       |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../css-invalid-global-placement/errors.json  |    2 +-
 .../css-invalid-global-selector-2/errors.json |    2 +-
 .../css-invalid-global-selector-3/errors.json |    2 +-
 .../css-invalid-global-selector-4/errors.json |    2 +-
 .../css-invalid-global-selector-5/errors.json |    2 +-
 .../css-invalid-global-selector-6/errors.json |    2 +-
 .../errors.json                               |    2 +-
 .../css-invalid-global-selector/errors.json   |    2 +-
 .../errors.json                               |    2 +-
 .../samples/css-mismatched-quotes/errors.json |    2 +-
 .../samples/debug-invalid-args/errors.json    |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../samples/default-export/errors.json        |    2 +-
 .../directive-non-expression/errors.json      |    2 +-
 .../errors.json                               |    4 +-
 .../errors.json                               |    4 +-
 .../dollar-global-in-markup/errors.json       |    4 +-
 .../dollar-global-in-script/errors.json       |    4 +-
 .../dynamic-element-invalid-tag/errors.json   |    2 +-
 .../dynamic-element-missing-tag/errors.json   |    4 +-
 .../samples/dynamic-element-this/errors.json  |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../each-block-invalid-context/errors.json    |    2 +-
 .../samples/event-attribute/errors.json       |    2 +-
 .../errors.json                               |    2 +-
 .../errors.json                               |    2 +-
 .../event-modifiers-invalid/errors.json       |    2 +-
 .../html-block-in-attribute/errors.json       |   12 +-
 .../html-block-in-textarea/errors.json        |   12 +-
 .../illegal-variable-declaration/errors.json  |    4 +-
 .../invalid-empty-css-declaration/errors.json |    2 +-
 .../invalid-node-placement-2/errors.json      |    2 +-
 .../invalid-node-placement/errors.json        |    2 +-
 .../samples/let-directive/errors.json         |   14 +-
 .../logic-block-in-attribute/errors.json      |   12 +-
 .../logic-block-in-textarea/errors.json       |   12 +-
 .../errors.json                               |    4 +-
 .../errors.json                               |    4 +-
 .../samples/namespace-invalid/errors.json     |    4 +-
 .../samples/namespace-non-literal/errors.json |    4 +-
 .../reactive-declaration-cyclical/errors.json |   12 +-
 .../script-invalid-context/errors.json        |    2 +-
 .../slot-attribute-invalid/errors.json        |    2 +-
 .../errors.json                               |    2 +-
 .../svelte-fragment-placement-2/errors.json   |   14 +-
 .../svelte-fragment-placement/errors.json     |   14 +-
 .../svelte-head-attributes/errors.json        |   14 +-
 .../validator/samples/tag-invalid/errors.json |    4 +-
 .../samples/tag-non-string/errors.json        |    2 +-
 .../textarea-value-children/errors.json       |    4 +-
 .../samples/title-no-attributes/errors.json   |    4 +-
 .../samples/title-no-children/errors.json     |    4 +-
 .../errors.json                               |    4 +-
 .../transition-duplicate-in/errors.json       |    4 +-
 .../errors.json                               |    4 +-
 .../transition-duplicate-out/errors.json      |    4 +-
 .../errors.json                               |    4 +-
 .../errors.json                               |    4 +-
 .../errors.json                               |    4 +-
 .../transition-on-component/errors.json       |    2 +-
 .../errors.json                               |    4 +-
 .../window-binding-invalid/errors.json        |    4 +-
 267 files changed, 3027 insertions(+), 1198 deletions(-)
 create mode 100644 packages/svelte/messages/compile-errors/attributes.md
 create mode 100644 packages/svelte/messages/compile-errors/bindings.md
 create mode 100644 packages/svelte/messages/compile-errors/compiler_options.md
 create mode 100644 packages/svelte/messages/compile-errors/components.md
 create mode 100644 packages/svelte/messages/compile-errors/const_tag.md
 create mode 100644 packages/svelte/messages/compile-errors/css.md
 create mode 100644 packages/svelte/messages/compile-errors/elements.md
 create mode 100644 packages/svelte/messages/compile-errors/legacy_reactivity.md
 create mode 100644 packages/svelte/messages/compile-errors/parse.md
 create mode 100644 packages/svelte/messages/compile-errors/runes.md
 create mode 100644 packages/svelte/messages/compile-errors/slots.md
 create mode 100644 packages/svelte/messages/compile-errors/special_elements.md
 create mode 100644 packages/svelte/messages/compile-errors/variables.md
 create mode 100644 packages/svelte/scripts/process-messages/index.js
 create mode 100644 packages/svelte/scripts/process-messages/templates/compile-errors.js

diff --git a/.prettierignore b/.prettierignore
index 48d37dc02f..77bdd29cf3 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -2,6 +2,8 @@ packages/**/dist/*.js
 packages/**/build/*.js
 packages/**/npm/**/*
 packages/**/config/*.js
+packages/svelte/messages/**/*.md
+packages/svelte/src/compiler/errors.js
 packages/svelte/tests/**/*.svelte
 packages/svelte/tests/**/_expected*
 packages/svelte/tests/**/_actual*
diff --git a/eslint.config.js b/eslint.config.js
index 75fcc7fa06..a86f724d34 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -33,13 +33,16 @@ export default [
 		ignores: [
 			'**/*.d.ts',
 			'**/tests',
+			'packages/svelte/scripts/process-messages/templates/*.js',
+			'packages/svelte/src/compiler/errors.js',
 			'packages/svelte/compiler/index.js',
 			// documentation can contain invalid examples
 			'documentation',
 			// contains a fork of the REPL which doesn't adhere to eslint rules
 			'sites/svelte-5-preview/**',
 			// wasn't checked previously, reenable at some point
-			'sites/svelte.dev/**'
+			'sites/svelte.dev/**',
+			'tmp/**'
 		]
 	}
 ];
diff --git a/packages/svelte/messages/compile-errors/attributes.md b/packages/svelte/messages/compile-errors/attributes.md
new file mode 100644
index 0000000000..9501080ee0
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/attributes.md
@@ -0,0 +1,59 @@
+## empty_attribute_shorthand
+
+Attribute shorthand cannot be empty
+
+## duplicate_attribute
+
+Attributes need to be unique
+
+## invalid_event_attribute_value
+
+Event attribute must be a JavaScript expression, not a string
+
+## invalid_attribute_name
+
+'%name%' is not a valid attribute name
+
+## animation_invalid_placement
+
+An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block
+
+## animation_missing_key
+
+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?
+
+## animation_duplicate
+
+An element can only have one 'animate' directive
+
+## invalid_event_modifier
+
+Valid event modifiers are %list%
+
+## invalid_component_event_modifier
+
+Event modifiers other than 'once' can only be used on DOM elements
+
+## invalid_event_modifier_combination
+
+The '%modifier1%' and '%modifier2%' modifiers cannot be used together
+
+## transition_duplicate
+
+Cannot use multiple `%type%:` directives on a single element
+
+## transition_conflict
+
+Cannot use `%type%:` alongside existing `%existing%:` directive
+
+## invalid_let_directive_placement
+
+`let:` directive at invalid position
+
+## invalid_style_directive_modifier
+
+Invalid 'style:' modifier. Valid modifiers are: 'important'
+
+## invalid_sequence_expression
+
+Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses
diff --git a/packages/svelte/messages/compile-errors/bindings.md b/packages/svelte/messages/compile-errors/bindings.md
new file mode 100644
index 0000000000..5e88c5890a
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/bindings.md
@@ -0,0 +1,35 @@
+## invalid_binding_expression
+
+Can only bind to an Identifier or MemberExpression
+
+## invalid_binding_value
+
+Can only bind to state or props
+
+## bind_invalid_target
+
+`bind:%name%` can only be used with %elements%
+
+## bind_invalid
+
+`bind:%name%` is not a valid binding
+
+## bind_invalid_detailed
+
+`bind:%name%` is not a valid binding. %explanation%
+
+## invalid_type_attribute
+
+'type' attribute must be a static text value if input uses two-way binding
+
+## invalid_multiple_attribute
+
+'multiple' attribute must be static if select uses two-way binding
+
+## missing_contenteditable_attribute
+
+'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings
+
+## dynamic_contenteditable_attribute
+
+'contenteditable' attribute cannot be dynamic if element uses two-way binding
diff --git a/packages/svelte/messages/compile-errors/compiler_options.md b/packages/svelte/messages/compile-errors/compiler_options.md
new file mode 100644
index 0000000000..761d74c72a
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/compiler_options.md
@@ -0,0 +1,7 @@
+## invalid_compiler_option
+
+Invalid compiler option: %msg%
+
+## removed_compiler_option
+
+Invalid compiler option: %msg%
\ No newline at end of file
diff --git a/packages/svelte/messages/compile-errors/components.md b/packages/svelte/messages/compile-errors/components.md
new file mode 100644
index 0000000000..88a31a81c6
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/components.md
@@ -0,0 +1,3 @@
+## invalid_component_directive
+
+This type of directive is not valid on components
\ No newline at end of file
diff --git a/packages/svelte/messages/compile-errors/const_tag.md b/packages/svelte/messages/compile-errors/const_tag.md
new file mode 100644
index 0000000000..de8a8ca909
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/const_tag.md
@@ -0,0 +1,3 @@
+## invalid_const_placement
+
+{@const} must be the immediate child of {#snippet}, {#if}, {:else if}, {:else}, {#each}, {:then}, {:catch}, <svelte:fragment> or <Component>
\ No newline at end of file
diff --git a/packages/svelte/messages/compile-errors/css.md b/packages/svelte/messages/compile-errors/css.md
new file mode 100644
index 0000000000..33331cfac6
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/css.md
@@ -0,0 +1,51 @@
+## invalid_css_empty_declaration
+
+Declaration cannot be empty
+
+## invalid_css_global_block_list
+
+A :global {...} block cannot be part of a selector list with more than one item
+
+## invalid_css_global_block_modifier
+
+A :global {...} block cannot modify an existing selector
+
+## invalid_css_global_block_combinator
+
+A :global {...} block cannot follow a %name% combinator
+
+## invalid_css_global_block_declaration
+
+A :global {...} block can only contain rules, not declarations
+
+## invalid_css_global_placement
+
+:global(...) can be at the start or end of a selector sequence, but not in the middle
+
+## invalid_css_global_selector
+
+:global(...) must contain exactly one selector
+
+## invalid_css_global_selector_list
+
+:global(...) must not contain type or universal selectors when used in a compound selector
+
+## invalid_css_type_selector_placement
+
+:global(...) must not be followed with a type selector
+
+## invalid_css_selector
+
+Invalid selector
+
+## invalid_css_identifier
+
+Expected a valid CSS identifier
+
+## invalid_nesting_selector
+
+Nesting selectors can only be used inside a rule
+
+## invalid_css_declaration
+
+Declaration cannot be empty
diff --git a/packages/svelte/messages/compile-errors/elements.md b/packages/svelte/messages/compile-errors/elements.md
new file mode 100644
index 0000000000..466a26a7ac
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/elements.md
@@ -0,0 +1,27 @@
+## invalid_textarea_content
+
+A `<textarea>` can have either a value attribute or (equivalently) child content, but not both
+
+## invalid_void_content
+
+Void elements cannot have children or closing tags
+
+## invalid_element_content
+
+<%name%> cannot have children
+
+## invalid_tag_name
+
+Expected valid tag name
+
+## invalid_node_placement
+
+%thing% is invalid inside <%parent%>
+
+## illegal_title_attribute
+
+`<title>` cannot have attributes nor directives
+
+## invalid_title_content
+
+`<title>` can only contain text and {tags}
diff --git a/packages/svelte/messages/compile-errors/legacy_reactivity.md b/packages/svelte/messages/compile-errors/legacy_reactivity.md
new file mode 100644
index 0000000000..6f4234aa01
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/legacy_reactivity.md
@@ -0,0 +1,3 @@
+## cyclical_reactive_declaration
+
+Cyclical dependency detected: %cycle%
diff --git a/packages/svelte/messages/compile-errors/parse.md b/packages/svelte/messages/compile-errors/parse.md
new file mode 100644
index 0000000000..e09c61e419
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/parse.md
@@ -0,0 +1,147 @@
+## unclosed_element
+
+`<%name%>` was left open
+
+## unclosed_block
+
+Block was left open
+
+## unexpected_block_close
+
+Unexpected block closing tag
+
+## unexpected_eof
+
+Unexpected end of input
+
+## js_parse_error
+
+%message%
+
+## expected_token
+
+Expected token %token%
+
+## unexpected_reserved_word
+
+'%word%' is a reserved word in JavaScript and cannot be used here
+
+## missing_whitespace
+
+Expected whitespace
+
+## expected_pattern
+
+Expected identifier or destructure pattern
+
+## invalid_script_context
+
+If the context attribute is supplied, its value must be "module"
+
+## invalid_elseif
+
+'elseif' should be 'else if'
+
+## invalid_continuing_block_placement
+
+{:...} block is invalid at this position (did you forget to close the preceeding element or block?)
+
+## invalid_block_missing_parent
+
+%child% block must be a child of %parent%
+
+## duplicate_block_part
+
+%name% cannot appear more than once within a block
+
+## expected_block_type
+
+Expected 'if', 'each', 'await', 'key' or 'snippet'
+
+## expected_identifier
+
+Expected an identifier
+
+## invalid_debug
+
+{@debug ...} arguments must be identifiers, not arbitrary expressions
+
+## invalid_const
+
+{@const ...} must be an assignment
+
+## invalid_block_placement
+
+{#%name% ...} block cannot be %location%
+
+## invalid_tag_placement
+
+{@%name% ...} tag cannot be %location%
+
+## missing_attribute_value
+
+Expected attribute value
+
+## unclosed_attribute_value
+
+Expected closing %delimiter% character
+
+## invalid_directive_value
+
+Directive value must be a JavaScript expression enclosed in curly braces
+
+## empty_directive_name
+
+%type% name cannot be empty
+
+## invalid_closing_tag
+
+</%name%> attempted to close an element that was not open
+
+## invalid_closing_tag_after_autoclose
+
+</%name%> attempted to close element that was already automatically closed by <%reason%> (cannot nest <%reason%> inside <%name%>)
+
+## invalid_dollar_binding
+
+The $ name is reserved, and cannot be used for variables and imports
+
+## invalid_dollar_prefix
+
+The $ prefix is reserved, and cannot be used for variables and imports
+
+## invalid_dollar_global
+
+The $ name is reserved. To reference a global variable called $, use globalThis.$
+
+## illegal_subscription
+
+Cannot reference store value inside `<script context="module">`
+
+## duplicate_style_element
+
+A component can have a single top-level `<style>` element
+
+## duplicate_script_element
+
+A component can have a single top-level `<script>` element and/or a single top-level `<script context="module">` element
+
+## invalid_render_expression
+
+{@render ...} tags can only contain call expressions
+
+## invalid_render_arguments
+
+expected at most one argument
+
+## invalid_render_call
+
+Calling a snippet function using apply, bind or call is not allowed
+
+## invalid_render_spread_argument
+
+cannot use spread arguments in {@render ...} tags
+
+## invalid_snippet_rest_parameter
+
+snippets do not support rest parameters; use an array instead
diff --git a/packages/svelte/messages/compile-errors/runes.md b/packages/svelte/messages/compile-errors/runes.md
new file mode 100644
index 0000000000..c8efa4eefb
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/runes.md
@@ -0,0 +1,95 @@
+## invalid_legacy_props
+
+Cannot use `$$props` in runes mode
+
+## invalid_legacy_rest_props
+
+Cannot use `$$restProps` in runes mode
+
+## invalid_legacy_reactive_statement
+
+`$:` is not allowed in runes mode, use `$derived` or `$effect` instead
+
+## invalid_legacy_export
+
+Cannot use `export let` in runes mode — use $props instead
+
+## invalid_rune_usage
+
+Cannot use %rune% rune in non-runes mode
+
+## invalid_state_export
+
+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
+
+## invalid_derived_export
+
+Cannot export derived state from a module. To expose the current derived value, export a function returning its value
+
+## invalid_props_id
+
+`$props()` can only be used with an object destructuring pattern
+
+## invalid_props_pattern
+
+`$props()` assignment must not contain nested properties or computed keys
+
+## invalid_props_location
+
+`$props()` can only be used at the top level of components as a variable declaration initializer
+
+## invalid_bindable_location
+
+`$bindable()` can only be used inside a `$props()` declaration
+
+## invalid_state_location
+
+`%rune%(...)` can only be used as a variable declaration initializer or a class field
+
+## invalid_effect_location
+
+`$effect()` can only be used as an expression statement
+
+## invalid_host_location
+
+`$host()` can only be used inside custom element component instances
+
+## invalid_assignment
+
+Cannot assign to %thing%
+
+## invalid_binding
+
+Cannot bind to %thing%
+
+## invalid_rune_args
+
+`%rune%` cannot be called with arguments
+
+## invalid_rune_args_length
+
+`%rune%` must be called with %args%
+
+## invalid_runes_mode_import
+
+%name% cannot be used in runes mode
+
+## duplicate_props_rune
+
+Cannot use `$props()` more than once
+
+## invalid_each_assignment
+
+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`)
+
+## invalid_snippet_assignment
+
+Cannot reassign or bind to snippet parameter
+
+## invalid_derived_call
+
+`$derived.call(...)` has been replaced with `$derived.by(...)`
+
+## conflicting_property_name
+
+Cannot have a property and a component export with the same name
diff --git a/packages/svelte/messages/compile-errors/slots.md b/packages/svelte/messages/compile-errors/slots.md
new file mode 100644
index 0000000000..51213c5b5d
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/slots.md
@@ -0,0 +1,31 @@
+## invalid_slot_element_attribute
+
+`<slot>` can only receive attributes and (optionally) let directives
+
+## invalid_slot_attribute
+
+slot attribute must be a static value
+
+## invalid_slot_name_default
+
+`default` is a reserved word — it cannot be used as a slot name
+
+## invalid_slot_name
+
+slot attribute must be a static value
+
+## invalid_slot_placement
+
+Element with a slot='...' attribute must be a child of a component or a descendant of a custom element
+
+## duplicate_slot_name
+
+Duplicate slot name '%name%' in <%component%>
+
+## invalid_default_slot_content
+
+Found default slot content alongside an explicit slot="default"
+
+## conflicting_children_snippet
+
+Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block
diff --git a/packages/svelte/messages/compile-errors/special_elements.md b/packages/svelte/messages/compile-errors/special_elements.md
new file mode 100644
index 0000000000..6617d0e0fb
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/special_elements.md
@@ -0,0 +1,99 @@
+## invalid_svelte_option_attribute
+
+`<svelte:options>` can only receive static attributes
+
+## invalid_svelte_option_namespace
+
+Unsupported `<svelte:option>` value for "namespace". Valid values are "html", "svg" or "foreign"
+
+## tag_option_deprecated
+
+"tag" option is deprecated — use "customElement" instead
+
+## invalid_svelte_option_runes
+
+Unsupported `<svelte:option>` value for "runes". Valid values are true or false
+
+## invalid_svelte_option_accessors
+
+Unsupported `<svelte:option>` value for "accessors". Valid values are true or false
+
+## invalid_svelte_option_preserveWhitespace
+
+Unsupported `<svelte:option>` value for "preserveWhitespace". Valid values are true or false
+
+## invalid_svelte_option_immutable
+
+Unsupported `<svelte:option>` value for "immutable". Valid values are true or false
+
+## invalid_tag_property
+
+Tag name must be two or more words joined by the "-" character
+
+## invalid_svelte_option_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: .. } } }
+
+## invalid_customElement_props_attribute
+
+"props" must be a statically analyzable object literal of the form "{ [key: string]: { attribute?: string; reflect?: boolean; type?: "String" | "Boolean" | "Number" | "Array" | "Object" }"
+
+## invalid_customElement_shadow_attribute
+
+"shadow" must be either "open" or "none"
+
+## unknown_svelte_option_attribute
+
+`<svelte:options>` unknown attribute '%name%'
+
+## illegal_svelte_head_attribute
+
+`<svelte:head>` cannot have attributes nor directives
+
+## invalid_svelte_fragment_attribute
+
+`<svelte:fragment>` can only have a slot attribute and (optionally) a let: directive
+
+## invalid_svelte_fragment_slot
+
+`<svelte:fragment>` slot attribute must have a static value
+
+## invalid_svelte_fragment_placement
+
+`<svelte:fragment>` must be the direct child of a component
+
+## invalid_svelte_element_placement
+
+<%name%> tags cannot be inside elements or blocks
+
+## duplicate_svelte_element
+
+A component can only have one <%name%> element
+
+## invalid_self_placement
+
+`<svelte:self>` components can only exist inside {#if} blocks, {#each} blocks, {#snippet} blocks or slots passed to components
+
+## missing_svelte_element_definition
+
+`<svelte:element>` must have a 'this' attribute
+
+## missing_svelte_component_definition
+
+`<svelte:component>` must have a 'this' attribute
+
+## invalid_svelte_element_definition
+
+Invalid element definition — must be an {expression}
+
+## invalid_svelte_component_definition
+
+Invalid component definition — must be an {expression}
+
+## invalid_svelte_tag
+
+Valid `<svelte:...>` tag names are %list%
+
+## conflicting_slot_usage
+
+Cannot use `<slot>` syntax and `{@render ...}` tags in the same component. Migrate towards `{@render ...}` tags completely.
diff --git a/packages/svelte/messages/compile-errors/variables.md b/packages/svelte/messages/compile-errors/variables.md
new file mode 100644
index 0000000000..f1ac317b59
--- /dev/null
+++ b/packages/svelte/messages/compile-errors/variables.md
@@ -0,0 +1,19 @@
+## illegal_global
+
+`%name%` is an illegal variable name. To reference a global variable called `%name%`, use `globalThis.%name%`
+
+## duplicate_declaration
+
+`%name%` has already been declared
+
+## default_export
+
+A component cannot have a default export
+
+## illegal_variable_declaration
+
+Cannot declare same variable name which is imported inside `<script context="module">`
+
+## illegal_store_subscription
+
+Cannot subscribe to stores that are not declared at the top level of the component
diff --git a/packages/svelte/scripts/process-messages/index.js b/packages/svelte/scripts/process-messages/index.js
new file mode 100644
index 0000000000..52cb23aec3
--- /dev/null
+++ b/packages/svelte/scripts/process-messages/index.js
@@ -0,0 +1,213 @@
+// @ts-check
+import fs from 'node:fs';
+import * as acorn from 'acorn';
+import { walk } from 'zimmerframe';
+import * as esrap from 'esrap';
+
+const messages = {};
+const seen = new Set();
+
+for (const category of fs.readdirSync('messages')) {
+	messages[category] = {};
+
+	for (const file of fs.readdirSync(`messages/${category}`)) {
+		if (!file.endsWith('.md')) continue;
+
+		const markdown = fs.readFileSync(`messages/${category}/${file}`, 'utf-8');
+
+		for (const match of markdown.matchAll(/## ([\w]+)\n\n([^]+?)(?=$|\n\n## )/g)) {
+			const [_, code, text] = match;
+
+			if (seen.has(code)) {
+				throw new Error(`Duplicate message code ${category}/${code}`);
+			}
+
+			seen.add(code);
+			messages[category][code] = text.trim();
+		}
+	}
+}
+
+function transform(name, dest) {
+	const source = fs.readFileSync(new URL(`./templates/${name}.js`, import.meta.url), 'utf-8');
+
+	const comments = [];
+
+	const ast = acorn.parse(source, {
+		ecmaVersion: 'latest',
+		sourceType: 'module',
+		onComment: (block, value, start, end) => {
+			if (block && /\n/.test(value)) {
+				let a = start;
+				while (a > 0 && source[a - 1] !== '\n') a -= 1;
+
+				let b = a;
+				while (/[ \t]/.test(source[b])) b += 1;
+
+				const indentation = source.slice(a, b);
+				value = value.replace(new RegExp(`^${indentation}`, 'gm'), '');
+			}
+
+			comments.push({ type: block ? 'Block' : 'Line', value, start, end });
+		}
+	});
+
+	walk(ast, null, {
+		_(node, { next }) {
+			let comment;
+
+			while (comments[0] && comments[0].start < node.start) {
+				comment = comments.shift();
+				// @ts-expect-error
+				(node.leadingComments ||= []).push(comment);
+			}
+
+			next();
+
+			if (comments[0]) {
+				const slice = source.slice(node.end, comments[0].start);
+
+				if (/^[,) \t]*$/.test(slice)) {
+					// @ts-expect-error
+					node.trailingComments = [comments.shift()];
+				}
+			}
+		}
+	});
+
+	const category = messages[name];
+
+	// find the `export function CODE` node
+	const index = ast.body.findIndex((node) => {
+		if (
+			node.type === 'ExportNamedDeclaration' &&
+			node.declaration &&
+			node.declaration.type === 'FunctionDeclaration'
+		) {
+			return node.declaration.id.name === 'CODE';
+		}
+	});
+
+	if (index === -1) throw new Error(`missing export function CODE in ${name}.js`);
+
+	const template_node = ast.body[index];
+	ast.body.splice(index, 1);
+
+	for (const code in category) {
+		const message = category[code];
+		const vars = [];
+		for (const match of message.matchAll(/%(\w+)%/g)) {
+			const name = match[1];
+			if (!vars.includes(name)) {
+				vars.push(match[1]);
+			}
+		}
+
+		const clone = walk(/** @type {import('estree').Node} */ (template_node), null, {
+			// @ts-expect-error Block is a block comment, which is not recognised
+			Block(node, context) {
+				if (!node.value.includes('PARAMETER')) return;
+
+				const value = node.value
+					.split('\n')
+					.map((line) => {
+						if (line.includes('PARAMETER')) {
+							return vars.map((name) => ` * @param {string} ${name}`).join('\n');
+						}
+
+						return line;
+					})
+					.join('\n');
+
+				if (value !== node.value) {
+					return { ...node, value };
+				}
+			},
+			FunctionDeclaration(node, context) {
+				if (node.id.name !== 'CODE') return;
+
+				const params = [];
+
+				for (const param of node.params) {
+					if (param.type === 'Identifier' && param.name === 'PARAMETER') {
+						params.push(...vars.map((name) => ({ type: 'Identifier', name })));
+					} else {
+						params.push(param);
+					}
+				}
+
+				return /** @type {import('estree').FunctionDeclaration} */ ({
+					.../** @type {import('estree').FunctionDeclaration} */ (context.next()),
+					params,
+					id: {
+						...node.id,
+						name: code
+					}
+				});
+			},
+			Literal(node) {
+				if (node.value === 'CODE') {
+					return {
+						type: 'Literal',
+						value: code
+					};
+				}
+			},
+			Identifier(node) {
+				if (node.name !== 'MESSAGE') return;
+
+				if (/%\w+%/.test(message)) {
+					const parts = message.split(/(%\w+%)/);
+
+					/** @type {import('estree').Expression[]} */
+					const expressions = [];
+
+					/** @type {import('estree').TemplateElement[]} */
+					const quasis = [];
+
+					for (let i = 0; i < parts.length; i += 1) {
+						const part = parts[i];
+						if (i % 2 === 0) {
+							const str = part.replace(/(`|\$)/g, '\\$1');
+							quasis.push({
+								type: 'TemplateElement',
+								value: { raw: str, cooked: str },
+								tail: i === parts.length - 1
+							});
+						} else {
+							expressions.push({
+								type: 'Identifier',
+								name: part.slice(1, -1)
+							});
+						}
+					}
+
+					return {
+						type: 'TemplateLiteral',
+						expressions,
+						quasis
+					};
+				}
+
+				return {
+					type: 'Literal',
+					value: message
+				};
+			}
+		});
+
+		// @ts-expect-error
+		ast.body.push(clone);
+	}
+
+	// @ts-expect-error
+	const module = esrap.print(ast);
+
+	fs.writeFileSync(
+		dest,
+		`/* This file is generated by scripts/process-messages.js. Do not edit! */\n\n` + module.code,
+		'utf-8'
+	);
+}
+
+transform('compile-errors', 'src/compiler/errors.js');
diff --git a/packages/svelte/scripts/process-messages/templates/compile-errors.js b/packages/svelte/scripts/process-messages/templates/compile-errors.js
new file mode 100644
index 0000000000..96dcb72b3f
--- /dev/null
+++ b/packages/svelte/scripts/process-messages/templates/compile-errors.js
@@ -0,0 +1,74 @@
+/** @typedef {{ start?: number, end?: number }} NodeLike */
+
+// interface is duplicated between here (used internally) and ./interfaces.js
+// (exposed publicly), and I'm not sure how to avoid that
+export class CompileError extends Error {
+	name = 'CompileError';
+
+	/** @type {import('#compiler').CompileError['filename']} */
+	filename = undefined;
+
+	/** @type {import('#compiler').CompileError['position']} */
+	position = undefined;
+
+	/** @type {import('#compiler').CompileError['start']} */
+	start = undefined;
+
+	/** @type {import('#compiler').CompileError['end']} */
+	end = undefined;
+
+	/**
+	 *
+	 * @param {string} code
+	 * @param {string} message
+	 * @param {[number, number] | undefined} position
+	 */
+	constructor(code, message, position) {
+		super(message);
+		this.code = code;
+		this.position = position;
+	}
+
+	toString() {
+		let out = `${this.name}: ${this.message}`;
+
+		out += `\n(${this.code})`;
+
+		if (this.filename) {
+			out += `\n${this.filename}`;
+
+			if (this.start) {
+				out += `${this.start.line}:${this.start.column}`;
+			}
+		}
+
+		return out;
+	}
+}
+
+/**
+ *
+ * @param {null | number | NodeLike} node
+ * @param {string} code
+ * @param {string} message
+ * @returns {never}
+ */
+function e(node, code, message) {
+	const start = typeof node === 'number' ? node : node?.start;
+	const end = typeof node === 'number' ? node : node?.end;
+
+	throw new CompileError(
+		code,
+		message,
+		start !== undefined && end !== undefined ? [start, end] : undefined
+	);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} PARAMETER
+ * @returns {never}
+ */
+export function CODE(node, PARAMETER) {
+	e(node, 'CODE', MESSAGE);
+}
diff --git a/packages/svelte/src/compiler/errors.js b/packages/svelte/src/compiler/errors.js
index 71bc353336..ee2a961868 100644
--- a/packages/svelte/src/compiler/errors.js
+++ b/packages/svelte/src/compiler/errors.js
@@ -1,497 +1,16 @@
-/** @typedef {{ start?: number, end?: number }} NodeLike */
-/** @typedef {Record<string, (...args: any[]) => string>} Errors */
-
-/**
- * @param {Array<string | number>} items
- * @param {string} conjunction
- */
-function list(items, conjunction = 'or') {
-	if (items.length === 1) return items[0];
-	return `${items.slice(0, -1).join(', ')} ${conjunction} ${items[items.length - 1]}`;
-}
-
-/** @satisfies {Errors} */
-const internal = {
-	/** @param {string} message */
-	TODO: (message) => `TODO ${message}`,
-
-	/** @param {string} message */
-	INTERNAL: (message) =>
-		`Internal compiler error: ${message}. Please report this to https://github.com/sveltejs/svelte/issues`
-};
-
-/** @satisfies {Errors} */
-const parse = {
-	/** @param {string} name */
-	'unclosed-element': (name) => `<${name}> was left open`,
-	'unclosed-block': () => `Block was left open`,
-	'unexpected-block-close': () => `Unexpected block closing tag`,
-	/** @param {string} [expected]  */
-	'unexpected-eof': (expected) =>
-		`Unexpected end of input` + (expected ? ` (expected ${expected})` : ''),
-	/** @param {string} message */
-	'js-parse-error': (message) => message,
-	/** @param {string} token */
-	'expected-token': (token) => `Expected token ${token}`,
-	/** @param {string} word */
-	'unexpected-reserved-word': (word) =>
-		`'${word}' is a reserved word in JavaScript and cannot be used here`,
-	'missing-whitespace': () => `Expected whitespace`,
-	'expected-pattern': () => `Expected identifier or destructure pattern`,
-	'invalid-script-context': () =>
-		`If the context attribute is supplied, its value must be "module"`,
-	'invalid-elseif': () => `'elseif' should be 'else if'`,
-	'invalid-continuing-block-placement': () =>
-		`{:...} block is invalid at this position (did you forget to close the preceeding element or block?)`,
-	/**
-	 * @param {string} child
-	 * @param {string} parent
-	 */
-	'invalid-block-missing-parent': (child, parent) => `${child} block must be a child of ${parent}`,
-	/** @param {string} name */
-	'duplicate-block-part': (name) => `${name} cannot appear more than once within a block`,
-	'expected-block-type': () => `Expected 'if', 'each', 'await', 'key' or 'snippet'`,
-	'expected-identifier': () => `Expected an identifier`,
-	'invalid-debug': () => `{@debug ...} arguments must be identifiers, not arbitrary expressions`,
-	'invalid-const': () => `{@const ...} must be an assignment`,
-	/**
-	 * @param {string} location
-	 * @param {string} name
-	 */
-	'invalid-block-placement': (location, name) => `{#${name} ...} block cannot be ${location}`,
-	/**
-	 * @param {string} location
-	 * @param {string} name
-	 */
-	'invalid-tag-placement': (location, name) => `{@${name} ...} tag cannot be ${location}`,
-	'missing-attribute-value': () => `Expected attribute value`,
-	/** @param {string} delimiter */
-	'unclosed-attribute-value': (delimiter) => `Expected closing ${delimiter} character`,
-	'invalid-directive-value': () =>
-		`Directive value must be a JavaScript expression enclosed in curly braces`,
-	/** @param {string} type */
-	'empty-directive-name': (type) => `${type} name cannot be empty`,
-	/** @param {string} name */
-	'invalid-closing-tag': (name) => `</${name}> attempted to close an element that was not open`,
-	/**
-	 * @param {string} name
-	 * @param {string} reason
-	 */
-	'invalid-closing-tag-after-autoclose': (name, reason) =>
-		`</${name}> attempted to close element that was already automatically closed by <${reason}> (cannot nest <${reason}> inside <${name}>)`,
-	'invalid-dollar-binding': () =>
-		`The $ name is reserved, and cannot be used for variables and imports`,
-	'invalid-dollar-prefix': () =>
-		`The $ prefix is reserved, and cannot be used for variables and imports`,
-	'invalid-dollar-global': () =>
-		`The $ name is reserved. To reference a global variable called $, use globalThis.$`,
-	'illegal-subscription': () => `Cannot reference store value inside <script context="module">`,
-	'duplicate-style-element': () => `A component can have a single top-level <style> element`,
-	'duplicate-script-element': () =>
-		`A component can have a single top-level <script> element and/or a single top-level <script context="module"> element`,
-	'invalid-render-expression': () => '{@render ...} tags can only contain call expressions',
-	'invalid-render-arguments': () => 'expected at most one argument',
-	'invalid-render-call': () =>
-		'Calling a snippet function using apply, bind or call is not allowed',
-	'invalid-render-spread-argument': () => 'cannot use spread arguments in {@render ...} tags',
-	'invalid-snippet-rest-parameter': () =>
-		'snippets do not support rest parameters; use an array instead'
-};
-
-/** @satisfies {Errors} */
-const css = {
-	/** @param {string} message */
-	'css-parse-error': (message) => message,
-	'invalid-css-empty-declaration': () => `Declaration cannot be empty`,
-	'invalid-css-global-block-list': () =>
-		`A :global {...} block cannot be part of a selector list with more than one item`,
-	'invalid-css-global-block-modifier': () =>
-		`A :global {...} block cannot modify an existing selector`,
-	/** @param {string} name */
-	'invalid-css-global-block-combinator': (name) =>
-		`A :global {...} block cannot follow a ${name} combinator`,
-	'invalid-css-global-block-declaration': () =>
-		`A :global {...} block can only contain rules, not declarations`,
-	'invalid-css-global-placement': () =>
-		`:global(...) can be at the start or end of a selector sequence, but not in the middle`,
-	'invalid-css-global-selector': () => `:global(...) must contain exactly one selector`,
-	'invalid-css-global-selector-list': () =>
-		`:global(...) must not contain type or universal selectors when used in a compound selector`,
-	'invalid-css-type-selector-placement': () =>
-		`:global(...) must not be followed with a type selector`,
-	'invalid-css-selector': () => `Invalid selector`,
-	'invalid-css-identifier': () => 'Expected a valid CSS identifier',
-	'invalid-nesting-selector': () => `Nesting selectors can only be used inside a rule`,
-	'invalid-css-declaration': () => 'Declaration cannot be empty'
-};
-
-/** @satisfies {Errors} */
-const special_elements = {
-	'invalid-svelte-option-attribute': () => `<svelte:options> can only receive static attributes`,
-	'invalid-svelte-option-namespace': () =>
-		`Unsupported <svelte:option> value for "namespace". Valid values are "html", "svg" or "foreign".`,
-	'tag-option-deprecated': () => `"tag" option is deprecated — use "customElement" instead`,
-	'invalid-svelte-option-runes': () =>
-		`Unsupported <svelte:option> value for "runes". Valid values are true or false.`,
-	'invalid-svelte-option-accessors': () =>
-		'Unsupported <svelte:option> value for "accessors". Valid values are true or false.',
-	'invalid-svelte-option-preserveWhitespace': () =>
-		'Unsupported <svelte:option> value for "preserveWhitespace". Valid values are true or false.',
-	'invalid-svelte-option-immutable': () =>
-		'Unsupported <svelte:option> value for "immutable". Valid values are true or false.',
-	'invalid-tag-property': () => 'tag name must be two or more words joined by the "-" character',
-	'invalid-svelte-option-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: .. } } }',
-	'invalid-customElement-props-attribute': () =>
-		'"props" must be a statically analyzable object literal of the form ' +
-		'"{ [key: string]: { attribute?: string; reflect?: boolean; type?: "String" | "Boolean" | "Number" | "Array" | "Object" }"',
-	'invalid-customElement-shadow-attribute': () => '"shadow" must be either "open" or "none"',
-	'unknown-svelte-option-attribute': /** @param {string} name */ (name) =>
-		`<svelte:options> unknown attribute '${name}'`,
-	'illegal-svelte-head-attribute': () => '<svelte:head> cannot have attributes nor directives',
-	'invalid-svelte-fragment-attribute': () =>
-		`<svelte:fragment> can only have a slot attribute and (optionally) a let: directive`,
-	'invalid-svelte-fragment-slot': () => `<svelte:fragment> slot attribute must have a static value`,
-	'invalid-svelte-fragment-placement': () =>
-		`<svelte:fragment> must be the direct child of a component`,
-	/** @param {string} name */
-	'invalid-svelte-element-placement': (name) =>
-		`<${name}> tags cannot be inside elements or blocks`,
-	/** @param {string} name */
-	'duplicate-svelte-element': (name) => `A component can only have one <${name}> element`,
-	'invalid-self-placement': () =>
-		`<svelte:self> components can only exist inside {#if} blocks, {#each} blocks, {#snippet} blocks or slots passed to components`,
-	'missing-svelte-element-definition': () => `<svelte:element> must have a 'this' attribute`,
-	'missing-svelte-component-definition': () => `<svelte:component> must have a 'this' attribute`,
-	'invalid-svelte-element-definition': () => `Invalid element definition — must be an {expression}`,
-	'invalid-svelte-component-definition': () =>
-		`Invalid component definition — must be an {expression}`,
-	/**
-	 * @param {string[]} tags
-	 * @param {string | null} match
-	 */
-	'invalid-svelte-tag': (tags, match) =>
-		`Valid <svelte:...> tag names are ${list(tags)}${match ? ' (did you mean ' + match + '?)' : ''}`,
-	'conflicting-slot-usage': () =>
-		`Cannot use <slot> syntax and {@render ...} tags in the same component. Migrate towards {@render ...} tags completely.`
-};
-
-/** @satisfies {Errors} */
-const runes = {
-	'invalid-legacy-props': () => `Cannot use $$props in runes mode`,
-	'invalid-legacy-rest-props': () => `Cannot use $$restProps in runes mode`,
-	'invalid-legacy-reactive-statement': () =>
-		`$: is not allowed in runes mode, use $derived or $effect instead`,
-	'invalid-legacy-export': () => `Cannot use \`export let\` in runes mode — use $props instead`,
-	/** @param {string} rune */
-	'invalid-rune-usage': (rune) => `Cannot use ${rune} rune in non-runes mode`,
-	'invalid-state-export': () =>
-		`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`,
-	'invalid-derived-export': () =>
-		`Cannot export derived state from a module. To expose the current derived value, export a function returning its value`,
-	'invalid-props-id': () => `$props() can only be used with an object destructuring pattern`,
-	'invalid-props-pattern': () =>
-		`$props() assignment must not contain nested properties or computed keys`,
-	'invalid-props-location': () =>
-		`$props() can only be used at the top level of components as a variable declaration initializer`,
-	'invalid-bindable-location': () => `$bindable() can only be used inside a $props() declaration`,
-	/** @param {string} rune */
-	'invalid-state-location': (rune) =>
-		`${rune}(...) can only be used as a variable declaration initializer or a class field`,
-	'invalid-effect-location': () => `$effect() can only be used as an expression statement`,
-	'invalid-host-location': () =>
-		`$host() can only be used inside custom element component instances`,
-	/**
-	 * @param {boolean} is_binding
-	 * @param {boolean} show_details
-	 */
-	'invalid-const-assignment': (is_binding, show_details) =>
-		`Invalid ${is_binding ? 'binding' : 'assignment'} to const variable${
-			show_details
-				? ' ($derived values, let: directives, :then/:catch variables and @const declarations count as const)'
-				: ''
-		}`,
-	'invalid-derived-assignment': () => `Invalid assignment to derived state`,
-	'invalid-derived-binding': () => `Invalid binding to derived state`,
-	/**
-	 * @param {string} rune
-	 * @param {Array<number | string>} args
-	 */
-	'invalid-rune-args-length': (rune, args) =>
-		`${rune} can only be called with ${list(args, 'or')} ${
-			args.length === 1 && args[0] === 1 ? 'argument' : 'arguments'
-		}`,
-	/** @param {string} name */
-	'invalid-runes-mode-import': (name) => `${name} cannot be used in runes mode`,
-	'duplicate-props-rune': () => `Cannot use $props() more than once`,
-	'invalid-each-assignment': () =>
-		`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')`,
-	'invalid-snippet-assignment': () => `Cannot reassign or bind to snippet parameter`,
-	'invalid-derived-call': () => `$derived.call(...) has been replaced with $derived.by(...)`,
-	'conflicting-property-name': () =>
-		`Cannot have a property and a component export with the same name`
-};
-
-/** @satisfies {Errors} */
-const elements = {
-	'invalid-textarea-content': () =>
-		`A <textarea> can have either a value attribute or (equivalently) child content, but not both`,
-	'invalid-void-content': () => `Void elements cannot have children or closing tags`,
-	/** @param {string} name */
-	'invalid-element-content': (name) => `<${name}> cannot have children`,
-	'invalid-tag-name': () => 'Expected valid tag name',
-	/**
-	 * @param {string} node
-	 * @param {string} parent
-	 */
-	'invalid-node-placement': (node, parent) => `${node} is invalid inside <${parent}>`,
-	'illegal-title-attribute': () => '<title> cannot have attributes nor directives',
-	'invalid-title-content': () => '<title> can only contain text and {tags}'
-};
-
-/** @satisfies {Errors} */
-const components = {
-	'invalid-component-directive': () => `This type of directive is not valid on components`
-};
-
-/** @satisfies {Errors} */
-const attributes = {
-	'empty-attribute-shorthand': () => `Attribute shorthand cannot be empty`,
-	'duplicate-attribute': () => `Attributes need to be unique`,
-	'invalid-event-attribute-value': () =>
-		`Event attribute must be a JavaScript expression, not a string`,
-	/** @param {string} name */
-	'invalid-attribute-name': (name) => `'${name}' is not a valid attribute name`,
-	/** @param {'no-each' | 'each-key' | 'child'} type */
-	'invalid-animation': (type) =>
-		type === 'no-each'
-			? `An element that uses the animate directive must be the immediate child of a keyed each block`
-			: type === 'each-key'
-				? `An element that uses the animate directive must be used inside a keyed each block. Did you forget to add a key to your each block?`
-				: `An element that uses the animate directive must be the sole child of a keyed each block`,
-	'duplicate-animation': () => `An element can only have one 'animate' directive`,
-	/** @param {string[] | undefined} [modifiers] */
-	'invalid-event-modifier': (modifiers) =>
-		modifiers
-			? `Valid event modifiers are ${modifiers.slice(0, -1).join(', ')} or ${modifiers.slice(-1)}`
-			: `Event modifiers other than 'once' can only be used on DOM elements`,
-	/**
-	 * @param {string} modifier1
-	 * @param {string} modifier2
-	 */
-	'invalid-event-modifier-combination': (modifier1, modifier2) =>
-		`The '${modifier1}' and '${modifier2}' modifiers cannot be used together`,
-	/**
-	 * @param {string} directive1
-	 * @param {string} directive2
-	 */
-	'duplicate-transition': (directive1, directive2) => {
-		/** @param {string} _directive */
-		function describe(_directive) {
-			return _directive === 'transition' ? "a 'transition'" : `an '${_directive}'`;
-		}
-
-		return directive1 === directive2
-			? `An element can only have one '${directive1}' directive`
-			: `An element cannot have both ${describe(directive1)} directive and ${describe(
-					directive2
-				)} directive`;
-	},
-	'invalid-let-directive-placement': () => 'let directive at invalid position',
-	'invalid-style-directive-modifier': () =>
-		`Invalid 'style:' modifier. Valid modifiers are: 'important'`,
-	'invalid-sequence-expression': () =>
-		`Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses`
-};
-
-/** @satisfies {Errors} */
-const slots = {
-	'invalid-slot-element-attribute': () =>
-		`<slot> can only receive attributes and (optionally) let directives`,
-	'invalid-slot-attribute': () => `slot attribute must be a static value`,
-	/** @param {boolean} is_default */
-	'invalid-slot-name': (is_default) =>
-		is_default
-			? `default is a reserved word — it cannot be used as a slot name`
-			: `slot attribute must be a static value`,
-	'invalid-slot-placement': () =>
-		`Element with a slot='...' attribute must be a child of a component or a descendant of a custom element`,
-	/** @param {string} name @param {string} component */
-	'duplicate-slot-name': (name, component) => `Duplicate slot name '${name}' in <${component}>`,
-	'invalid-default-slot-content': () =>
-		`Found default slot content alongside an explicit slot="default"`,
-	'conflicting-children-snippet': () =>
-		`Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block`
-};
-
-/** @satisfies {Errors} */
-const bindings = {
-	'invalid-binding-expression': () => `Can only bind to an Identifier or MemberExpression`,
-	'invalid-binding-value': () => `Can only bind to state or props`,
-	/**
-	 * @param {string} binding
-	 * @param {string} [elements]
-	 * @param {string} [post]
-	 */
-	'invalid-binding': (binding, elements, post = '') =>
-		(elements
-			? `'${binding}' binding can only be used with ${elements}`
-			: `'${binding}' is not a valid binding`) + post,
-	'invalid-type-attribute': () =>
-		`'type' attribute must be a static text value if input uses two-way binding`,
-	'invalid-multiple-attribute': () =>
-		`'multiple' attribute must be static if select uses two-way binding`,
-	'missing-contenteditable-attribute': () =>
-		`'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings`,
-	'dynamic-contenteditable-attribute': () =>
-		`'contenteditable' attribute cannot be dynamic if element uses two-way binding`
-};
-
-/** @satisfies {Errors} */
-const variables = {
-	'illegal-global': /** @param {string} name */ (name) =>
-		`${name} is an illegal variable name. To reference a global variable called ${name}, use globalThis.${name}`,
-	/** @param {string} name */
-	'duplicate-declaration': (name) => `'${name}' has already been declared`,
-	'default-export': () => `A component cannot have a default export`,
-	'illegal-variable-declaration': () =>
-		'Cannot declare same variable name which is imported inside <script context="module">',
-	'illegal-store-subscription': () =>
-		'Cannot subscribe to stores that are not declared at the top level of the component'
-};
-
-/** @satisfies {Errors} */
-const legacy_reactivity = {
-	'cyclical-reactive-declaration': /** @param {string[]} cycle */ (cycle) =>
-		`Cyclical dependency detected: ${cycle.join(' → ')}`
-};
-
-/** @satisfies {Errors} */
-const compiler_options = {
-	/** @param {string} msg */
-	'invalid-compiler-option': (msg) => `Invalid compiler option: ${msg}`,
-	/** @param {string} msg */
-	'removed-compiler-option': (msg) => `Invalid compiler option: ${msg}`
-};
-
-/** @satisfies {Errors} */
-const const_tag = {
-	'invalid-const-placement': () =>
-		`{@const} must be the immediate child of {#snippet}, {#if}, {:else if}, {:else}, {#each}, {:then}, {:catch}, <svelte:fragment> or <Component>`
-};
-
-/** @satisfies {Errors} */
-const errors = {
-	...internal,
-	...parse,
-	...css,
-	...special_elements,
-	...runes,
-	...elements,
-	...components,
-	...attributes,
-	...slots,
-	...bindings,
-	...variables,
-	...compiler_options,
-	...legacy_reactivity,
-	...const_tag
-
-	// missing_contenteditable_attribute: {
-	// 	code: 'missing-contenteditable-attribute',
-	// 	message:
-	// 		"'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings"
-	// },
-	// textarea_duplicate_value: {
-	// 	code: 'textarea-duplicate-value',
-	// 	message:
-	// 		'A <textarea> can have either a value attribute or (equivalently) child content, but not both'
-	// },
-	// invalid_attribute_head: {
-	// 	code: 'invalid-attribute',
-	// 	message: '<svelte:head> should not have any attributes or directives'
-	// },
-	// invalid_action: {
-	// 	code: 'invalid-action',
-	// 	message: 'Actions can only be applied to DOM elements, not components'
-	// },
-	// invalid_class: {
-	// 	code: 'invalid-class',
-	// 	message: 'Classes can only be applied to DOM elements, not components'
-	// },
-	// invalid_transition: {
-	// 	code: 'invalid-transition',
-	// 	message: 'Transitions can only be applied to DOM elements, not components'
-	// },
-	// invalid_let: {
-	// 	code: 'invalid-let',
-	// 	message: 'let directive value must be an identifier or an object/array pattern'
-	// },
-	// invalid_slot_directive: {
-	// 	code: 'invalid-slot-directive',
-	// 	message: '<slot> cannot have directives'
-	// },
-	// dynamic_slot_name: {
-	// 	code: 'dynamic-slot-name',
-	// 	message: '<slot> name cannot be dynamic'
-	// },
-	// invalid_slot_attribute_value_missing: {
-	// 	code: 'invalid-slot-attribute',
-	// 	message: 'slot attribute value is missing'
-	// },
-	// illegal_structure_title: {
-	// 	code: 'illegal-structure',
-	// 	message: '<title> can only contain text and {tags}'
-	// },
-	// duplicate_transition: /**
-	//  * @param {string} directive
-	//  * @param {string} parent_directive
-	//  */ (directive, parent_directive) => {
-	// 	/** @param {string} _directive */
-	// 	function describe(_directive) {
-	// 		return _directive === 'transition' ? "a 'transition'" : `an '${_directive}'`;
-	// 	}
-	// 	const message =
-	// 		directive === parent_directive
-	// 			? `An element can only have one '${directive}' directive`
-	// 			: `An element cannot have both ${describe(parent_directive)} directive and ${describe(
-	// 					directive
-	// 			  )} directive`;
-	// 	return {
-	// 		code: 'duplicate-transition',
-	// 		message
-	// 	};
-	// },
-	// default_export: {
-	// 	code: 'default-export',
-	// 	message: 'A component cannot have a default export'
-	// },
-	// illegal_declaration: {
-	// 	code: 'illegal-declaration',
-	// 	message: 'The $ prefix is reserved, and cannot be used for variable and import names'
-	// },
-	// invalid_directive_value: {
-	// 	code: 'invalid-directive-value',
-	// 	message:
-	// 		'Can only bind to an identifier (e.g. `foo`) or a member expression (e.g. `foo.bar` or `foo[baz]`)'
-	// },
-};
+/* This file is generated by scripts/process-messages.js. Do not edit! */
 
+/** @typedef {{ start?: number, end?: number }} NodeLike */
 // interface is duplicated between here (used internally) and ./interfaces.js
 // (exposed publicly), and I'm not sure how to avoid that
 export class CompileError extends Error {
 	name = 'CompileError';
-
 	/** @type {import('#compiler').CompileError['filename']} */
 	filename = undefined;
-
 	/** @type {import('#compiler').CompileError['position']} */
 	position = undefined;
-
 	/** @type {import('#compiler').CompileError['start']} */
 	start = undefined;
-
 	/** @type {import('#compiler').CompileError['end']} */
 	end = undefined;
 
@@ -525,24 +44,1358 @@ export class CompileError extends Error {
 }
 
 /**
- * @template {Exclude<keyof typeof errors, 'TODO'>} T
- * @param {NodeLike | number | null} node
- * @param {T} code
- * @param  {Parameters<typeof errors[T]>} args
+ *
+ * @param {null | number | NodeLike} node
+ * @param {string} code
+ * @param {string} message
  * @returns {never}
  */
-export function error(node, code, ...args) {
-	const fn = errors[code];
-
-	// @ts-expect-error
-	const message = fn(...args);
-
+function e(node, code, message) {
 	const start = typeof node === 'number' ? node : node?.start;
 	const end = typeof node === 'number' ? node : node?.end;
 
-	throw new CompileError(
-		code,
-		message,
-		start !== undefined && end !== undefined ? [start, end] : undefined
-	);
+	throw new CompileError(code, message, start !== undefined && end !== undefined ? [start, end] : undefined);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function empty_attribute_shorthand(node) {
+	e(node, "empty_attribute_shorthand", "Attribute shorthand cannot be empty");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function duplicate_attribute(node) {
+	e(node, "duplicate_attribute", "Attributes need to be unique");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_event_attribute_value(node) {
+	e(node, "invalid_event_attribute_value", "Event attribute must be a JavaScript expression, not a string");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function invalid_attribute_name(node, name) {
+	e(node, "invalid_attribute_name", `'${name}' is not a valid attribute name`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function animation_invalid_placement(node) {
+	e(node, "animation_invalid_placement", "An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function animation_missing_key(node) {
+	e(node, "animation_missing_key", "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?");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function animation_duplicate(node) {
+	e(node, "animation_duplicate", "An element can only have one 'animate' directive");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} list
+ * @returns {never}
+ */
+export function invalid_event_modifier(node, list) {
+	e(node, "invalid_event_modifier", `Valid event modifiers are ${list}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_component_event_modifier(node) {
+	e(node, "invalid_component_event_modifier", "Event modifiers other than 'once' can only be used on DOM elements");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} modifier1
+ * @param {string} modifier2
+ * @returns {never}
+ */
+export function invalid_event_modifier_combination(node, modifier1, modifier2) {
+	e(node, "invalid_event_modifier_combination", `The '${modifier1}' and '${modifier2}' modifiers cannot be used together`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} type
+ * @returns {never}
+ */
+export function transition_duplicate(node, type) {
+	e(node, "transition_duplicate", `Cannot use multiple \`${type}:\` directives on a single element`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} type
+ * @param {string} existing
+ * @returns {never}
+ */
+export function transition_conflict(node, type, existing) {
+	e(node, "transition_conflict", `Cannot use \`${type}:\` alongside existing \`${existing}:\` directive`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_let_directive_placement(node) {
+	e(node, "invalid_let_directive_placement", "`let:` directive at invalid position");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_style_directive_modifier(node) {
+	e(node, "invalid_style_directive_modifier", "Invalid 'style:' modifier. Valid modifiers are: 'important'");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_sequence_expression(node) {
+	e(node, "invalid_sequence_expression", "Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_binding_expression(node) {
+	e(node, "invalid_binding_expression", "Can only bind to an Identifier or MemberExpression");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_binding_value(node) {
+	e(node, "invalid_binding_value", "Can only bind to state or props");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @param {string} elements
+ * @returns {never}
+ */
+export function bind_invalid_target(node, name, elements) {
+	e(node, "bind_invalid_target", `\`bind:${name}\` can only be used with ${elements}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function bind_invalid(node, name) {
+	e(node, "bind_invalid", `\`bind:${name}\` is not a valid binding`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @param {string} explanation
+ * @returns {never}
+ */
+export function bind_invalid_detailed(node, name, explanation) {
+	e(node, "bind_invalid_detailed", `\`bind:${name}\` is not a valid binding. ${explanation}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_type_attribute(node) {
+	e(node, "invalid_type_attribute", "'type' attribute must be a static text value if input uses two-way binding");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_multiple_attribute(node) {
+	e(node, "invalid_multiple_attribute", "'multiple' attribute must be static if select uses two-way binding");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function missing_contenteditable_attribute(node) {
+	e(node, "missing_contenteditable_attribute", "'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function dynamic_contenteditable_attribute(node) {
+	e(node, "dynamic_contenteditable_attribute", "'contenteditable' attribute cannot be dynamic if element uses two-way binding");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} msg
+ * @returns {never}
+ */
+export function invalid_compiler_option(node, msg) {
+	e(node, "invalid_compiler_option", `Invalid compiler option: ${msg}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} msg
+ * @returns {never}
+ */
+export function removed_compiler_option(node, msg) {
+	e(node, "removed_compiler_option", `Invalid compiler option: ${msg}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_component_directive(node) {
+	e(node, "invalid_component_directive", "This type of directive is not valid on components");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_const_placement(node) {
+	e(node, "invalid_const_placement", "{@const} must be the immediate child of {#snippet}, {#if}, {:else if}, {:else}, {#each}, {:then}, {:catch}, <svelte:fragment> or <Component>");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_empty_declaration(node) {
+	e(node, "invalid_css_empty_declaration", "Declaration cannot be empty");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_global_block_list(node) {
+	e(node, "invalid_css_global_block_list", "A :global {...} block cannot be part of a selector list with more than one item");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_global_block_modifier(node) {
+	e(node, "invalid_css_global_block_modifier", "A :global {...} block cannot modify an existing selector");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function invalid_css_global_block_combinator(node, name) {
+	e(node, "invalid_css_global_block_combinator", `A :global {...} block cannot follow a ${name} combinator`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_global_block_declaration(node) {
+	e(node, "invalid_css_global_block_declaration", "A :global {...} block can only contain rules, not declarations");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_global_placement(node) {
+	e(node, "invalid_css_global_placement", ":global(...) can be at the start or end of a selector sequence, but not in the middle");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_global_selector(node) {
+	e(node, "invalid_css_global_selector", ":global(...) must contain exactly one selector");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_global_selector_list(node) {
+	e(node, "invalid_css_global_selector_list", ":global(...) must not contain type or universal selectors when used in a compound selector");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_type_selector_placement(node) {
+	e(node, "invalid_css_type_selector_placement", ":global(...) must not be followed with a type selector");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_selector(node) {
+	e(node, "invalid_css_selector", "Invalid selector");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_identifier(node) {
+	e(node, "invalid_css_identifier", "Expected a valid CSS identifier");
 }
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_nesting_selector(node) {
+	e(node, "invalid_nesting_selector", "Nesting selectors can only be used inside a rule");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_css_declaration(node) {
+	e(node, "invalid_css_declaration", "Declaration cannot be empty");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_textarea_content(node) {
+	e(node, "invalid_textarea_content", "A `<textarea>` can have either a value attribute or (equivalently) child content, but not both");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_void_content(node) {
+	e(node, "invalid_void_content", "Void elements cannot have children or closing tags");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function invalid_element_content(node, name) {
+	e(node, "invalid_element_content", `<${name}> cannot have children`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_tag_name(node) {
+	e(node, "invalid_tag_name", "Expected valid tag name");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} thing
+ * @param {string} parent
+ * @returns {never}
+ */
+export function invalid_node_placement(node, thing, parent) {
+	e(node, "invalid_node_placement", `${thing} is invalid inside <${parent}>`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function illegal_title_attribute(node) {
+	e(node, "illegal_title_attribute", "`<title>` cannot have attributes nor directives");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_title_content(node) {
+	e(node, "invalid_title_content", "`<title>` can only contain text and {tags}");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} cycle
+ * @returns {never}
+ */
+export function cyclical_reactive_declaration(node, cycle) {
+	e(node, "cyclical_reactive_declaration", `Cyclical dependency detected: ${cycle}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function unclosed_element(node, name) {
+	e(node, "unclosed_element", `\`<${name}>\` was left open`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function unclosed_block(node) {
+	e(node, "unclosed_block", "Block was left open");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function unexpected_block_close(node) {
+	e(node, "unexpected_block_close", "Unexpected block closing tag");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function unexpected_eof(node) {
+	e(node, "unexpected_eof", "Unexpected end of input");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} message
+ * @returns {never}
+ */
+export function js_parse_error(node, message) {
+	e(node, "js_parse_error", `${message}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} token
+ * @returns {never}
+ */
+export function expected_token(node, token) {
+	e(node, "expected_token", `Expected token ${token}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} word
+ * @returns {never}
+ */
+export function unexpected_reserved_word(node, word) {
+	e(node, "unexpected_reserved_word", `'${word}' is a reserved word in JavaScript and cannot be used here`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function missing_whitespace(node) {
+	e(node, "missing_whitespace", "Expected whitespace");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function expected_pattern(node) {
+	e(node, "expected_pattern", "Expected identifier or destructure pattern");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_script_context(node) {
+	e(node, "invalid_script_context", "If the context attribute is supplied, its value must be \"module\"");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_elseif(node) {
+	e(node, "invalid_elseif", "'elseif' should be 'else if'");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_continuing_block_placement(node) {
+	e(node, "invalid_continuing_block_placement", "{:...} block is invalid at this position (did you forget to close the preceeding element or block?)");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} child
+ * @param {string} parent
+ * @returns {never}
+ */
+export function invalid_block_missing_parent(node, child, parent) {
+	e(node, "invalid_block_missing_parent", `${child} block must be a child of ${parent}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function duplicate_block_part(node, name) {
+	e(node, "duplicate_block_part", `${name} cannot appear more than once within a block`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function expected_block_type(node) {
+	e(node, "expected_block_type", "Expected 'if', 'each', 'await', 'key' or 'snippet'");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function expected_identifier(node) {
+	e(node, "expected_identifier", "Expected an identifier");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_debug(node) {
+	e(node, "invalid_debug", "{@debug ...} arguments must be identifiers, not arbitrary expressions");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_const(node) {
+	e(node, "invalid_const", "{@const ...} must be an assignment");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @param {string} location
+ * @returns {never}
+ */
+export function invalid_block_placement(node, name, location) {
+	e(node, "invalid_block_placement", `{#${name} ...} block cannot be ${location}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @param {string} location
+ * @returns {never}
+ */
+export function invalid_tag_placement(node, name, location) {
+	e(node, "invalid_tag_placement", `{@${name} ...} tag cannot be ${location}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function missing_attribute_value(node) {
+	e(node, "missing_attribute_value", "Expected attribute value");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} delimiter
+ * @returns {never}
+ */
+export function unclosed_attribute_value(node, delimiter) {
+	e(node, "unclosed_attribute_value", `Expected closing ${delimiter} character`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_directive_value(node) {
+	e(node, "invalid_directive_value", "Directive value must be a JavaScript expression enclosed in curly braces");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} type
+ * @returns {never}
+ */
+export function empty_directive_name(node, type) {
+	e(node, "empty_directive_name", `${type} name cannot be empty`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function invalid_closing_tag(node, name) {
+	e(node, "invalid_closing_tag", `</${name}> attempted to close an element that was not open`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @param {string} reason
+ * @returns {never}
+ */
+export function invalid_closing_tag_after_autoclose(node, name, reason) {
+	e(node, "invalid_closing_tag_after_autoclose", `</${name}> attempted to close element that was already automatically closed by <${reason}> (cannot nest <${reason}> inside <${name}>)`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_dollar_binding(node) {
+	e(node, "invalid_dollar_binding", "The $ name is reserved, and cannot be used for variables and imports");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_dollar_prefix(node) {
+	e(node, "invalid_dollar_prefix", "The $ prefix is reserved, and cannot be used for variables and imports");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_dollar_global(node) {
+	e(node, "invalid_dollar_global", "The $ name is reserved. To reference a global variable called $, use globalThis.$");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function illegal_subscription(node) {
+	e(node, "illegal_subscription", "Cannot reference store value inside `<script context=\"module\">`");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function duplicate_style_element(node) {
+	e(node, "duplicate_style_element", "A component can have a single top-level `<style>` element");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function duplicate_script_element(node) {
+	e(node, "duplicate_script_element", "A component can have a single top-level `<script>` element and/or a single top-level `<script context=\"module\">` element");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_render_expression(node) {
+	e(node, "invalid_render_expression", "{@render ...} tags can only contain call expressions");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_render_arguments(node) {
+	e(node, "invalid_render_arguments", "expected at most one argument");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_render_call(node) {
+	e(node, "invalid_render_call", "Calling a snippet function using apply, bind or call is not allowed");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_render_spread_argument(node) {
+	e(node, "invalid_render_spread_argument", "cannot use spread arguments in {@render ...} tags");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_snippet_rest_parameter(node) {
+	e(node, "invalid_snippet_rest_parameter", "snippets do not support rest parameters; use an array instead");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_legacy_props(node) {
+	e(node, "invalid_legacy_props", "Cannot use `$$props` in runes mode");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_legacy_rest_props(node) {
+	e(node, "invalid_legacy_rest_props", "Cannot use `$$restProps` in runes mode");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_legacy_reactive_statement(node) {
+	e(node, "invalid_legacy_reactive_statement", "`$:` is not allowed in runes mode, use `$derived` or `$effect` instead");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_legacy_export(node) {
+	e(node, "invalid_legacy_export", "Cannot use `export let` in runes mode — use $props instead");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} rune
+ * @returns {never}
+ */
+export function invalid_rune_usage(node, rune) {
+	e(node, "invalid_rune_usage", `Cannot use ${rune} rune in non-runes mode`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_state_export(node) {
+	e(node, "invalid_state_export", "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");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_derived_export(node) {
+	e(node, "invalid_derived_export", "Cannot export derived state from a module. To expose the current derived value, export a function returning its value");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_props_id(node) {
+	e(node, "invalid_props_id", "`$props()` can only be used with an object destructuring pattern");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_props_pattern(node) {
+	e(node, "invalid_props_pattern", "`$props()` assignment must not contain nested properties or computed keys");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_props_location(node) {
+	e(node, "invalid_props_location", "`$props()` can only be used at the top level of components as a variable declaration initializer");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_bindable_location(node) {
+	e(node, "invalid_bindable_location", "`$bindable()` can only be used inside a `$props()` declaration");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} rune
+ * @returns {never}
+ */
+export function invalid_state_location(node, rune) {
+	e(node, "invalid_state_location", `\`${rune}(...)\` can only be used as a variable declaration initializer or a class field`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_effect_location(node) {
+	e(node, "invalid_effect_location", "`$effect()` can only be used as an expression statement");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_host_location(node) {
+	e(node, "invalid_host_location", "`$host()` can only be used inside custom element component instances");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} thing
+ * @returns {never}
+ */
+export function invalid_assignment(node, thing) {
+	e(node, "invalid_assignment", `Cannot assign to ${thing}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} thing
+ * @returns {never}
+ */
+export function invalid_binding(node, thing) {
+	e(node, "invalid_binding", `Cannot bind to ${thing}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} rune
+ * @returns {never}
+ */
+export function invalid_rune_args(node, rune) {
+	e(node, "invalid_rune_args", `\`${rune}\` cannot be called with arguments`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} rune
+ * @param {string} args
+ * @returns {never}
+ */
+export function invalid_rune_args_length(node, rune, args) {
+	e(node, "invalid_rune_args_length", `\`${rune}\` must be called with ${args}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function invalid_runes_mode_import(node, name) {
+	e(node, "invalid_runes_mode_import", `${name} cannot be used in runes mode`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function duplicate_props_rune(node) {
+	e(node, "duplicate_props_rune", "Cannot use `$props()` more than once");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_each_assignment(node) {
+	e(node, "invalid_each_assignment", "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`)");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_snippet_assignment(node) {
+	e(node, "invalid_snippet_assignment", "Cannot reassign or bind to snippet parameter");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_derived_call(node) {
+	e(node, "invalid_derived_call", "`$derived.call(...)` has been replaced with `$derived.by(...)`");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function conflicting_property_name(node) {
+	e(node, "conflicting_property_name", "Cannot have a property and a component export with the same name");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_slot_element_attribute(node) {
+	e(node, "invalid_slot_element_attribute", "`<slot>` can only receive attributes and (optionally) let directives");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_slot_attribute(node) {
+	e(node, "invalid_slot_attribute", "slot attribute must be a static value");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_slot_name_default(node) {
+	e(node, "invalid_slot_name_default", "`default` is a reserved word — it cannot be used as a slot name");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_slot_name(node) {
+	e(node, "invalid_slot_name", "slot attribute must be a static value");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_slot_placement(node) {
+	e(node, "invalid_slot_placement", "Element with a slot='...' attribute must be a child of a component or a descendant of a custom element");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @param {string} component
+ * @returns {never}
+ */
+export function duplicate_slot_name(node, name, component) {
+	e(node, "duplicate_slot_name", `Duplicate slot name '${name}' in <${component}>`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_default_slot_content(node) {
+	e(node, "invalid_default_slot_content", "Found default slot content alongside an explicit slot=\"default\"");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function conflicting_children_snippet(node) {
+	e(node, "conflicting_children_snippet", "Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_option_attribute(node) {
+	e(node, "invalid_svelte_option_attribute", "`<svelte:options>` can only receive static attributes");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_option_namespace(node) {
+	e(node, "invalid_svelte_option_namespace", "Unsupported `<svelte:option>` value for \"namespace\". Valid values are \"html\", \"svg\" or \"foreign\"");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function tag_option_deprecated(node) {
+	e(node, "tag_option_deprecated", "\"tag\" option is deprecated — use \"customElement\" instead");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_option_runes(node) {
+	e(node, "invalid_svelte_option_runes", "Unsupported `<svelte:option>` value for \"runes\". Valid values are true or false");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_option_accessors(node) {
+	e(node, "invalid_svelte_option_accessors", "Unsupported `<svelte:option>` value for \"accessors\". Valid values are true or false");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_option_preserveWhitespace(node) {
+	e(node, "invalid_svelte_option_preserveWhitespace", "Unsupported `<svelte:option>` value for \"preserveWhitespace\". Valid values are true or false");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_option_immutable(node) {
+	e(node, "invalid_svelte_option_immutable", "Unsupported `<svelte:option>` value for \"immutable\". Valid values are true or false");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_tag_property(node) {
+	e(node, "invalid_tag_property", "Tag name must be two or more words joined by the \"-\" character");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_option_customElement(node) {
+	e(node, "invalid_svelte_option_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: .. } } }");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_customElement_props_attribute(node) {
+	e(node, "invalid_customElement_props_attribute", "\"props\" must be a statically analyzable object literal of the form \"{ [key: string]: { attribute?: string; reflect?: boolean; type?: \"String\" | \"Boolean\" | \"Number\" | \"Array\" | \"Object\" }\"");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_customElement_shadow_attribute(node) {
+	e(node, "invalid_customElement_shadow_attribute", "\"shadow\" must be either \"open\" or \"none\"");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function unknown_svelte_option_attribute(node, name) {
+	e(node, "unknown_svelte_option_attribute", `\`<svelte:options>\` unknown attribute '${name}'`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function illegal_svelte_head_attribute(node) {
+	e(node, "illegal_svelte_head_attribute", "`<svelte:head>` cannot have attributes nor directives");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_fragment_attribute(node) {
+	e(node, "invalid_svelte_fragment_attribute", "`<svelte:fragment>` can only have a slot attribute and (optionally) a let: directive");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_fragment_slot(node) {
+	e(node, "invalid_svelte_fragment_slot", "`<svelte:fragment>` slot attribute must have a static value");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_fragment_placement(node) {
+	e(node, "invalid_svelte_fragment_placement", "`<svelte:fragment>` must be the direct child of a component");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function invalid_svelte_element_placement(node, name) {
+	e(node, "invalid_svelte_element_placement", `<${name}> tags cannot be inside elements or blocks`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function duplicate_svelte_element(node, name) {
+	e(node, "duplicate_svelte_element", `A component can only have one <${name}> element`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_self_placement(node) {
+	e(node, "invalid_self_placement", "`<svelte:self>` components can only exist inside {#if} blocks, {#each} blocks, {#snippet} blocks or slots passed to components");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function missing_svelte_element_definition(node) {
+	e(node, "missing_svelte_element_definition", "`<svelte:element>` must have a 'this' attribute");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function missing_svelte_component_definition(node) {
+	e(node, "missing_svelte_component_definition", "`<svelte:component>` must have a 'this' attribute");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_element_definition(node) {
+	e(node, "invalid_svelte_element_definition", "Invalid element definition — must be an {expression}");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function invalid_svelte_component_definition(node) {
+	e(node, "invalid_svelte_component_definition", "Invalid component definition — must be an {expression}");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} list
+ * @returns {never}
+ */
+export function invalid_svelte_tag(node, list) {
+	e(node, "invalid_svelte_tag", `Valid \`<svelte:...>\` tag names are ${list}`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function conflicting_slot_usage(node) {
+	e(node, "conflicting_slot_usage", "Cannot use `<slot>` syntax and `{@render ...}` tags in the same component. Migrate towards `{@render ...}` tags completely.");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function illegal_global(node, name) {
+	e(node, "illegal_global", `\`${name}\` is an illegal variable name. To reference a global variable called \`${name}\`, use \`globalThis.${name}\``);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+ * @param {string} name
+ * @returns {never}
+ */
+export function duplicate_declaration(node, name) {
+	e(node, "duplicate_declaration", `\`${name}\` has already been declared`);
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function default_export(node) {
+	e(node, "default_export", "A component cannot have a default export");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function illegal_variable_declaration(node) {
+	e(node, "illegal_variable_declaration", "Cannot declare same variable name which is imported inside `<script context=\"module\">`");
+}
+
+/**
+ * @param {null | number | NodeLike} node
+
+ * @returns {never}
+ */
+export function illegal_store_subscription(node) {
+	e(node, "illegal_store_subscription", "Cannot subscribe to stores that are not declared at the top level of the component");
+}
\ No newline at end of file
diff --git a/packages/svelte/src/compiler/phases/1-parse/index.js b/packages/svelte/src/compiler/phases/1-parse/index.js
index 5c77d36ea6..d5f5cda052 100644
--- a/packages/svelte/src/compiler/phases/1-parse/index.js
+++ b/packages/svelte/src/compiler/phases/1-parse/index.js
@@ -4,7 +4,7 @@ import fragment from './state/fragment.js';
 import { regex_whitespace } from '../patterns.js';
 import { reserved } from './utils/names.js';
 import full_char_code_at from './utils/full_char_code_at.js';
-import { error } from '../../errors.js';
+import * as e from '../../errors.js';
 import { create_fragment } from './utils/create.js';
 import read_options from './read/options.js';
 import { getLocator } from 'locate-character';
@@ -92,15 +92,15 @@ export class Parser {
 
 			if (current.type === 'RegularElement') {
 				current.end = current.start + 1;
-				error(current, 'unclosed-element', current.name);
+				e.unclosed_element(current, current.name);
 			} else {
 				current.end = current.start + 1;
-				error(current, 'unclosed-block');
+				e.unclosed_block(current);
 			}
 		}
 
 		if (state !== fragment) {
-			error(this.index, 'unexpected-eof');
+			e.unexpected_eof(this.index);
 		}
 
 		if (this.root.fragment.nodes.length) {
@@ -158,7 +158,7 @@ export class Parser {
 	 * @returns {never}
 	 */
 	acorn_error(err) {
-		error(err.pos, 'js-parse-error', err.message.replace(regex_position_indicator, ''));
+		e.js_parse_error(err.pos, err.message.replace(regex_position_indicator, ''));
 	}
 
 	/**
@@ -172,11 +172,7 @@ export class Parser {
 		}
 
 		if (required) {
-			if (this.index === this.template.length) {
-				error(this.index, 'unexpected-eof', str);
-			} else {
-				error(this.index, 'expected-token', str);
-			}
+			e.expected_token(this.index, str);
 		}
 
 		return false;
@@ -241,7 +237,7 @@ export class Parser {
 		const identifier = this.template.slice(this.index, (this.index = i));
 
 		if (!allow_reserved && reserved.includes(identifier)) {
-			error(start, 'unexpected-reserved-word', identifier);
+			e.unexpected_reserved_word(start, identifier);
 		}
 
 		return identifier;
@@ -250,7 +246,7 @@ export class Parser {
 	/** @param {RegExp} pattern */
 	read_until(pattern) {
 		if (this.index >= this.template.length) {
-			error(this.template.length, 'unexpected-eof');
+			e.unexpected_eof(this.template.length);
 		}
 
 		const start = this.index;
@@ -267,7 +263,7 @@ export class Parser {
 
 	require_whitespace() {
 		if (!regex_whitespace.test(this.template[this.index])) {
-			error(this.index, 'missing-whitespace');
+			e.missing_whitespace(this.index);
 		}
 
 		this.allow_whitespace();
diff --git a/packages/svelte/src/compiler/phases/1-parse/read/context.js b/packages/svelte/src/compiler/phases/1-parse/read/context.js
index b69c16d320..10cdaa44b7 100644
--- a/packages/svelte/src/compiler/phases/1-parse/read/context.js
+++ b/packages/svelte/src/compiler/phases/1-parse/read/context.js
@@ -9,7 +9,7 @@ import {
 } from '../utils/bracket.js';
 import { parse_expression_at } from '../acorn.js';
 import { regex_not_newline_characters } from '../../patterns.js';
-import { error } from '../../../errors.js';
+import * as e from '../../../errors.js';
 
 /**
  * @param {import('../index.js').Parser} parser
@@ -36,7 +36,7 @@ export default function read_pattern(parser, optional_allowed = false) {
 	}
 
 	if (!is_bracket_open(code)) {
-		error(i, 'expected-pattern');
+		e.expected_pattern(i);
 	}
 
 	const bracket_stack = [code];
@@ -49,11 +49,7 @@ export default function read_pattern(parser, optional_allowed = false) {
 		} else if (is_bracket_close(code)) {
 			const popped = /** @type {number} */ (bracket_stack.pop());
 			if (!is_bracket_pair(popped, code)) {
-				error(
-					i,
-					'expected-token',
-					String.fromCharCode(/** @type {number} */ (get_bracket_close(popped)))
-				);
+				e.expected_token(i, String.fromCharCode(/** @type {number} */ (get_bracket_close(popped))));
 			}
 			if (bracket_stack.length === 0) {
 				i += code <= 0xffff ? 1 : 2;
diff --git a/packages/svelte/src/compiler/phases/1-parse/read/expression.js b/packages/svelte/src/compiler/phases/1-parse/read/expression.js
index 21d4bb96fe..506fc354fb 100644
--- a/packages/svelte/src/compiler/phases/1-parse/read/expression.js
+++ b/packages/svelte/src/compiler/phases/1-parse/read/expression.js
@@ -1,6 +1,6 @@
 import { parse_expression_at } from '../acorn.js';
 import { regex_whitespace } from '../../patterns.js';
-import { error } from '../../../errors.js';
+import * as e from '../../../errors.js';
 
 /**
  * @param {import('../index.js').Parser} parser
@@ -23,7 +23,7 @@ export default function read_expression(parser) {
 			if (char === ')') {
 				num_parens -= 1;
 			} else if (!regex_whitespace.test(char)) {
-				error(index, 'expected-token', ')');
+				e.expected_token(index, ')');
 			}
 
 			index += 1;
diff --git a/packages/svelte/src/compiler/phases/1-parse/read/options.js b/packages/svelte/src/compiler/phases/1-parse/read/options.js
index c9262c54a8..18264ae9bc 100644
--- a/packages/svelte/src/compiler/phases/1-parse/read/options.js
+++ b/packages/svelte/src/compiler/phases/1-parse/read/options.js
@@ -1,5 +1,5 @@
 import { namespace_svg } from '../../../../constants.js';
-import { error } from '../../../errors.js';
+import * as e from '../../../errors.js';
 
 const regex_valid_tag_name = /^[a-zA-Z][a-zA-Z0-9]*-[a-zA-Z0-9-]+$/;
 
@@ -22,24 +22,18 @@ export default function read_options(node) {
 
 	for (const attribute of node.attributes) {
 		if (attribute.type !== 'Attribute') {
-			error(attribute, 'invalid-svelte-option-attribute');
+			e.invalid_svelte_option_attribute(attribute);
 		}
 
 		const { name } = attribute;
 
 		switch (name) {
 			case 'runes': {
-				const value = get_static_value(attribute, () =>
-					error(attribute, 'invalid-svelte-option-runes')
-				);
-				if (typeof value !== 'boolean') {
-					error(attribute, 'invalid-svelte-option-runes');
-				}
-				component_options.runes = value;
+				component_options.runes = get_boolean_value(attribute, e.invalid_svelte_option_runes);
 				break;
 			}
 			case 'tag': {
-				error(attribute, 'tag-option-deprecated');
+				e.tag_option_deprecated(attribute);
 				break; // eslint doesn't know this is unnecessary
 			}
 			case 'customElement': {
@@ -48,9 +42,9 @@ export default function read_options(node) {
 
 				const { value } = attribute;
 				if (value === true) {
-					error(attribute, 'invalid-svelte-option-customElement');
+					e.invalid_svelte_option_customElement(attribute);
 				} else if (value[0].type === 'Text') {
-					const tag = get_static_value(attribute, () => error(attribute, 'invalid-tag-property'));
+					const tag = get_static_value(attribute, () => e.invalid_tag_property(attribute));
 					validate_tag(attribute, tag);
 					ce.tag = tag;
 					component_options.customElement = ce;
@@ -61,7 +55,7 @@ export default function read_options(node) {
 					if (value[0].expression.type === 'Literal' && value[0].expression.value === null) {
 						break;
 					}
-					error(attribute, 'invalid-svelte-option-customElement');
+					e.invalid_svelte_option_customElement(attribute);
 				}
 
 				/** @type {Array<[string, any]>} */
@@ -72,7 +66,7 @@ export default function read_options(node) {
 						property.computed ||
 						property.key.type !== 'Identifier'
 					) {
-						error(attribute, 'invalid-svelte-option-customElement');
+						e.invalid_svelte_option_customElement(attribute);
 					}
 					properties.push([property.key.name, property.value]);
 				}
@@ -83,13 +77,13 @@ export default function read_options(node) {
 					validate_tag(tag, tag_value);
 					ce.tag = tag_value;
 				} else {
-					error(attribute, 'invalid-svelte-option-customElement');
+					e.invalid_svelte_option_customElement(attribute);
 				}
 
 				const props = properties.find(([name]) => name === 'props')?.[1];
 				if (props) {
 					if (props.type !== 'ObjectExpression') {
-						error(attribute, 'invalid-customElement-props-attribute');
+						e.invalid_customElement_props_attribute(attribute);
 					}
 					ce.props = {};
 					for (const property of /** @type {import('estree').ObjectExpression} */ (props)
@@ -100,7 +94,7 @@ export default function read_options(node) {
 							property.key.type !== 'Identifier' ||
 							property.value.type !== 'ObjectExpression'
 						) {
-							error(attribute, 'invalid-customElement-props-attribute');
+							e.invalid_customElement_props_attribute(attribute);
 						}
 						ce.props[property.key.name] = {};
 						for (const prop of property.value.properties) {
@@ -110,7 +104,7 @@ export default function read_options(node) {
 								prop.key.type !== 'Identifier' ||
 								prop.value.type !== 'Literal'
 							) {
-								error(attribute, 'invalid-customElement-props-attribute');
+								e.invalid_customElement_props_attribute(attribute);
 							}
 
 							if (prop.key.name === 'type') {
@@ -119,21 +113,21 @@ export default function read_options(node) {
 										/** @type {string} */ (prop.value.value)
 									) === -1
 								) {
-									error(attribute, 'invalid-customElement-props-attribute');
+									e.invalid_customElement_props_attribute(attribute);
 								}
 								ce.props[property.key.name].type = /** @type {any} */ (prop.value.value);
 							} else if (prop.key.name === 'reflect') {
 								if (typeof prop.value.value !== 'boolean') {
-									error(attribute, 'invalid-customElement-props-attribute');
+									e.invalid_customElement_props_attribute(attribute);
 								}
 								ce.props[property.key.name].reflect = prop.value.value;
 							} else if (prop.key.name === 'attribute') {
 								if (typeof prop.value.value !== 'string') {
-									error(attribute, 'invalid-customElement-props-attribute');
+									e.invalid_customElement_props_attribute(attribute);
 								}
 								ce.props[property.key.name].attribute = prop.value.value;
 							} else {
-								error(attribute, 'invalid-customElement-props-attribute');
+								e.invalid_customElement_props_attribute(attribute);
 							}
 						}
 					}
@@ -143,7 +137,7 @@ export default function read_options(node) {
 				if (shadow) {
 					const shadowdom = shadow?.value;
 					if (shadowdom !== 'open' && shadowdom !== 'none') {
-						error(shadow, 'invalid-customElement-shadow-attribute');
+						e.invalid_customElement_shadow_attribute(shadow);
 					}
 					ce.shadow = shadowdom;
 				}
@@ -158,10 +152,10 @@ export default function read_options(node) {
 			}
 			case 'namespace': {
 				const value = get_static_value(attribute, () =>
-					error(attribute, 'invalid-svelte-option-namespace')
+					e.invalid_svelte_option_namespace(attribute)
 				);
 				if (typeof value !== 'string') {
-					error(attribute, 'invalid-svelte-option-namespace');
+					e.invalid_svelte_option_namespace(attribute);
 				}
 
 				if (value === namespace_svg) {
@@ -169,43 +163,34 @@ export default function read_options(node) {
 				} else if (value === 'html' || value === 'svg' || value === 'foreign') {
 					component_options.namespace = value;
 				} else {
-					error(attribute, 'invalid-svelte-option-namespace');
+					e.invalid_svelte_option_namespace(attribute);
 				}
 
 				break;
 			}
 			case 'immutable': {
-				const value = get_static_value(attribute, () =>
-					error(attribute, 'invalid-svelte-option-immutable')
+				component_options.immutable = get_boolean_value(
+					attribute,
+					e.invalid_svelte_option_immutable
 				);
-				if (typeof value !== 'boolean') {
-					error(attribute, 'invalid-svelte-option-immutable');
-				}
-				component_options.immutable = value;
 				break;
 			}
 			case 'preserveWhitespace': {
-				const value = get_static_value(attribute, () =>
-					error(attribute, 'invalid-svelte-option-preserveWhitespace')
+				component_options.preserveWhitespace = get_boolean_value(
+					attribute,
+					e.invalid_svelte_option_preserveWhitespace
 				);
-				if (typeof value !== 'boolean') {
-					error(attribute, 'invalid-svelte-option-preserveWhitespace');
-				}
-				component_options.preserveWhitespace = value;
 				break;
 			}
 			case 'accessors': {
-				const value = get_static_value(attribute, () =>
-					error(attribute, 'invalid-svelte-option-accessors')
+				component_options.accessors = get_boolean_value(
+					attribute,
+					e.invalid_svelte_option_accessors
 				);
-				if (typeof value !== 'boolean') {
-					error(attribute, 'invalid-svelte-option-accessors');
-				}
-				component_options.accessors = value;
 				break;
 			}
 			default:
-				error(attribute, 'unknown-svelte-option-attribute', name);
+				e.unknown_svelte_option_attribute(attribute, name);
 		}
 	}
 
@@ -230,6 +215,18 @@ function get_static_value(attribute, error) {
 	return chunk.expression.value;
 }
 
+/**
+ * @param {any} attribute
+ * @param {(attribute: any) => never} error
+ */
+function get_boolean_value(attribute, error) {
+	const value = get_static_value(attribute, () => error(attribute));
+	if (typeof value !== 'boolean') {
+		error(attribute);
+	}
+	return value;
+}
+
 /**
  * @param {any} attribute
  * @param {string} tag
@@ -237,10 +234,10 @@ function get_static_value(attribute, error) {
  */
 function validate_tag(attribute, tag) {
 	if (typeof tag !== 'string' && tag !== null) {
-		error(attribute, 'invalid-tag-property');
+		e.invalid_tag_property(attribute);
 	}
 	if (tag && !regex_valid_tag_name.test(tag)) {
-		error(attribute, 'invalid-tag-property');
+		e.invalid_tag_property(attribute);
 	}
 	// TODO do we still need this?
 	// if (tag && !component.compile_options.customElement) {
diff --git a/packages/svelte/src/compiler/phases/1-parse/read/script.js b/packages/svelte/src/compiler/phases/1-parse/read/script.js
index cd9129e8b5..172e1dddf1 100644
--- a/packages/svelte/src/compiler/phases/1-parse/read/script.js
+++ b/packages/svelte/src/compiler/phases/1-parse/read/script.js
@@ -1,6 +1,6 @@
 import * as acorn from '../acorn.js';
 import { regex_not_newline_characters } from '../../patterns.js';
-import { error } from '../../../errors.js';
+import * as e from '../../../errors.js';
 
 const regex_closing_script_tag = /<\/script\s*>/;
 const regex_starts_with_closing_script_tag = /^<\/script\s*>/;
@@ -16,13 +16,13 @@ function get_context(attributes) {
 	if (!context) return 'default';
 
 	if (context.value.length !== 1 || context.value[0].type !== 'Text') {
-		error(context.start, 'invalid-script-context');
+		e.invalid_script_context(context.start);
 	}
 
 	const value = context.value[0].data;
 
 	if (value !== 'module') {
-		error(context.start, 'invalid-script-context');
+		e.invalid_script_context(context.start);
 	}
 
 	return value;
@@ -38,7 +38,7 @@ export function read_script(parser, start, attributes) {
 	const script_start = parser.index;
 	const data = parser.read_until(regex_closing_script_tag);
 	if (parser.index >= parser.template.length) {
-		error(parser.template.length, 'unclosed-element', 'script');
+		e.unclosed_element(parser.template.length, 'script');
 	}
 
 	const source =
diff --git a/packages/svelte/src/compiler/phases/1-parse/read/style.js b/packages/svelte/src/compiler/phases/1-parse/read/style.js
index 8ec00daff1..de5a457889 100644
--- a/packages/svelte/src/compiler/phases/1-parse/read/style.js
+++ b/packages/svelte/src/compiler/phases/1-parse/read/style.js
@@ -1,4 +1,4 @@
-import { error } from '../../../errors.js';
+import * as e from '../../../errors.js';
 
 const REGEX_MATCHER = /^[~^$*|]?=/;
 const REGEX_CLOSING_BRACKET = /[\s\]]/;
@@ -64,7 +64,7 @@ function read_body(parser, close) {
 		}
 	}
 
-	error(parser.template.length, 'expected-token', close);
+	e.expected_token(parser.template.length, close);
 }
 
 /**
@@ -154,7 +154,7 @@ function read_selector_list(parser, inside_pseudo_class = false) {
 		}
 	}
 
-	error(parser.template.length, 'unexpected-eof');
+	e.unexpected_eof(parser.template.length);
 }
 
 /**
@@ -352,7 +352,7 @@ function read_selector(parser, inside_pseudo_class = false) {
 		if (combinator) {
 			if (relative_selector.selectors.length === 0) {
 				if (!inside_pseudo_class) {
-					error(start, 'invalid-css-selector');
+					e.invalid_css_selector(start);
 				}
 			} else {
 				relative_selector.end = index;
@@ -365,12 +365,12 @@ function read_selector(parser, inside_pseudo_class = false) {
 			parser.allow_whitespace();
 
 			if (parser.match(',') || (inside_pseudo_class ? parser.match(')') : parser.match('{'))) {
-				error(parser.index, 'invalid-css-selector');
+				e.invalid_css_selector(parser.index);
 			}
 		}
 	}
 
-	error(parser.template.length, 'unexpected-eof');
+	e.unexpected_eof(parser.template.length);
 }
 
 /**
@@ -476,7 +476,7 @@ function read_declaration(parser) {
 	const value = read_value(parser);
 
 	if (!value && !property.startsWith('--')) {
-		error(parser.index, 'invalid-css-declaration');
+		e.invalid_css_declaration(parser.index);
 	}
 
 	const end = parser.index;
@@ -531,7 +531,7 @@ function read_value(parser) {
 		parser.index++;
 	}
 
-	error(parser.template.length, 'unexpected-eof');
+	e.unexpected_eof(parser.template.length);
 }
 
 /**
@@ -564,7 +564,7 @@ function read_attribute_value(parser) {
 		parser.index++;
 	}
 
-	error(parser.template.length, 'unexpected-eof');
+	e.unexpected_eof(parser.template.length);
 }
 
 /**
@@ -577,7 +577,7 @@ function read_identifier(parser) {
 	let identifier = '';
 
 	if (parser.match('--') || parser.match_regex(REGEX_LEADING_HYPHEN_OR_DIGIT)) {
-		error(start, 'invalid-css-identifier');
+		e.invalid_css_identifier(start);
 	}
 
 	let escaped = false;
@@ -602,7 +602,7 @@ function read_identifier(parser) {
 	}
 
 	if (identifier === '') {
-		error(start, 'invalid-css-identifier');
+		e.invalid_css_identifier(start);
 	}
 
 	return identifier;
diff --git a/packages/svelte/src/compiler/phases/1-parse/state/element.js b/packages/svelte/src/compiler/phases/1-parse/state/element.js
index bfaee9572d..134f322967 100644
--- a/packages/svelte/src/compiler/phases/1-parse/state/element.js
+++ b/packages/svelte/src/compiler/phases/1-parse/state/element.js
@@ -5,7 +5,7 @@ import read_expression from '../read/expression.js';
 import { read_script } from '../read/script.js';
 import read_style from '../read/style.js';
 import { closing_tag_omitted, decode_character_references } from '../utils/html.js';
-import { error } from '../../../errors.js';
+import * as e from '../../../errors.js';
 import { create_fragment } from '../utils/create.js';
 import { create_attribute } from '../../nodes.js';
 
@@ -104,19 +104,18 @@ export default function tag(parser) {
 				['svelte:options', 'svelte:window', 'svelte:body', 'svelte:document'].includes(name) &&
 				/** @type {import('#compiler').ElementLike} */ (parent).fragment.nodes.length
 			) {
-				error(
+				e.invalid_element_content(
 					/** @type {import('#compiler').ElementLike} */ (parent).fragment.nodes[0].start,
-					'invalid-element-content',
 					name
 				);
 			}
 		} else {
 			if (name in parser.meta_tags) {
-				error(start, 'duplicate-svelte-element', name);
+				e.duplicate_svelte_element(start, name);
 			}
 
 			if (parent.type !== 'Root') {
-				error(start, 'invalid-svelte-element-placement', name);
+				e.invalid_svelte_element_placement(start, name);
 			}
 
 			parser.meta_tags[name] = true;
@@ -168,7 +167,7 @@ export default function tag(parser) {
 
 	if (is_closing_tag) {
 		if (is_void(name)) {
-			error(start, 'invalid-void-content');
+			e.invalid_void_content(start);
 		}
 
 		parser.eat('>', true);
@@ -177,14 +176,9 @@ export default function tag(parser) {
 		while (/** @type {import('#compiler').RegularElement} */ (parent).name !== name) {
 			if (parent.type !== 'RegularElement') {
 				if (parser.last_auto_closed_tag && parser.last_auto_closed_tag.tag === name) {
-					error(
-						start,
-						'invalid-closing-tag-after-autoclose',
-						name,
-						parser.last_auto_closed_tag.reason
-					);
+					e.invalid_closing_tag_after_autoclose(start, name, parser.last_auto_closed_tag.reason);
 				} else {
-					error(start, 'invalid-closing-tag', name);
+					e.invalid_closing_tag(start, name);
 				}
 			}
 
@@ -225,7 +219,7 @@ export default function tag(parser) {
 	while ((attribute = read(parser))) {
 		if (attribute.type === 'Attribute' || attribute.type === 'BindDirective') {
 			if (unique_names.includes(attribute.name)) {
-				error(attribute.start, 'duplicate-attribute');
+				e.duplicate_attribute(attribute.start);
 				// <svelte:element bind:this this=..> is allowed
 			} else if (attribute.name !== 'this') {
 				unique_names.push(attribute.name);
@@ -242,7 +236,7 @@ export default function tag(parser) {
 			(attr) => attr.type === 'Attribute' && attr.name === 'this'
 		);
 		if (index === -1) {
-			error(start, 'missing-svelte-component-definition');
+			e.missing_svelte_component_definition(start);
 		}
 
 		const definition = /** @type {import('#compiler').Attribute} */ (
@@ -253,7 +247,7 @@ export default function tag(parser) {
 			definition.value.length !== 1 ||
 			definition.value[0].type === 'Text'
 		) {
-			error(definition.start, 'invalid-svelte-component-definition');
+			e.invalid_svelte_component_definition(definition.start);
 		}
 
 		element.expression = definition.value[0].expression;
@@ -265,14 +259,14 @@ export default function tag(parser) {
 			(attr) => attr.type === 'Attribute' && attr.name === 'this'
 		);
 		if (index === -1) {
-			error(start, 'missing-svelte-element-definition');
+			e.missing_svelte_element_definition(start);
 		}
 
 		const definition = /** @type {import('#compiler').Attribute} */ (
 			element.attributes.splice(index, 1)[0]
 		);
 		if (definition.value === true || definition.value.length !== 1) {
-			error(definition.start, 'invalid-svelte-element-definition');
+			e.invalid_svelte_element_definition(definition.start);
 		}
 		const chunk = definition.value[0];
 		element.tag =
@@ -311,17 +305,17 @@ export default function tag(parser) {
 			}
 
 			if (content.context === 'module') {
-				if (current.module) error(start, 'duplicate-script-element');
+				if (current.module) e.duplicate_script_element(start);
 				current.module = content;
 			} else {
-				if (current.instance) error(start, 'duplicate-script-element');
+				if (current.instance) e.duplicate_script_element(start);
 				current.instance = content;
 			}
 		} else {
 			const content = read_style(parser, start, element.attributes);
 			content.content.comment = prev_comment;
 
-			if (current.css) error(start, 'duplicate-style-element');
+			if (current.css) e.duplicate_style_element(start);
 			current.css = content;
 		}
 		return;
@@ -396,7 +390,7 @@ function read_tag_name(parser) {
 		}
 
 		if (!legal) {
-			error(start, 'invalid-self-placement');
+			e.invalid_self_placement(start);
 		}
 
 		return 'svelte:self';
@@ -412,12 +406,12 @@ function read_tag_name(parser) {
 	if (meta_tags.has(name)) return name;
 
 	if (name.startsWith('svelte:')) {
-		const match = fuzzymatch(name.slice(7), valid_meta_tags);
-		error(start, 'invalid-svelte-tag', valid_meta_tags, match);
+		const list = `${valid_meta_tags.slice(0, -1).join(', ')} or ${valid_meta_tags[valid_meta_tags.length - 1]}`;
+		e.invalid_svelte_tag(start, list);
 	}
 
 	if (!valid_tag_name.test(name)) {
-		error(start, 'invalid-tag-name');
+		e.invalid_tag_name(start);
 	}
 
 	return name;
@@ -445,7 +439,7 @@ function read_static_attribute(parser) {
 		parser.allow_whitespace();
 		let raw = parser.match_regex(regex_attribute_value);
 		if (!raw) {
-			error(parser.index, 'missing-attribute-value');
+			e.missing_attribute_value(parser.index);
 		}
 
 		parser.index += raw.length;
@@ -468,7 +462,7 @@ function read_static_attribute(parser) {
 	}
 
 	if (parser.match_regex(regex_starts_with_quote_characters)) {
-		error(parser.index, 'expected-token', '=');
+		e.expected_token(parser.index, '=');
 	}
 
 	return create_attribute(name, start, parser.index, value);
@@ -509,7 +503,7 @@ function read_attribute(parser) {
 			const name = parser.read_identifier();
 
 			if (name === null) {
-				error(start, 'empty-attribute-shorthand');
+				e.empty_attribute_shorthand(start);
 			}
 
 			parser.allow_whitespace();
@@ -554,14 +548,14 @@ function read_attribute(parser) {
 		value = read_attribute_value(parser);
 		end = parser.index;
 	} else if (parser.match_regex(regex_starts_with_quote_characters)) {
-		error(parser.index, 'expected-token', '=');
+		e.expected_token(parser.index, '=');
 	}
 
 	if (type) {
 		const [directive_name, ...modifiers] = name.slice(colon_index + 1).split('|');
 
 		if (directive_name === '') {
-			error(start + colon_index + 1, 'empty-directive-name', type);
+			e.empty_directive_name(start + colon_index + 1, type);
 		}
 
 		if (type === 'StyleDirective') {
@@ -586,7 +580,7 @@ function read_attribute(parser) {
 			const attribute_contains_text =
 				/** @type {any[]} */ (value).length > 1 || first_value.type === 'Text';
 			if (attribute_contains_text) {
-				error(/** @type {number} */ (first_value.start), 'invalid-directive-value');
+				e.invalid_directive_value(/** @type {number} */ (first_value.start));
 			} else {
 				expression = first_value.expression;
 			}
@@ -679,22 +673,22 @@ function read_attribute_value(parser) {
 			},
 			'in attribute value'
 		);
-	} catch (/** @type {any} e */ e) {
-		if (e.code === 'js-parse-error') {
+	} catch (/** @type {any} */ error) {
+		if (error.code === 'js_parse_error') {
 			// if the attribute value didn't close + self-closing tag
 			// eg: `<Component test={{a:1} />`
 			// acorn may throw a `Unterminated regular expression` because of `/>`
-			const pos = e.position?.[0];
+			const pos = error.position?.[0];
 			if (pos !== undefined && parser.template.slice(pos - 1, pos + 1) === '/>') {
 				parser.index = pos;
-				error(pos, 'unclosed-attribute-value', quote_mark || '}');
+				e.unclosed_attribute_value(pos, quote_mark || '}');
 			}
 		}
-		throw e;
+		throw error;
 	}
 
 	if (value.length === 0 && !quote_mark) {
-		error(parser.index, 'missing-attribute-value');
+		e.missing_attribute_value(parser.index);
 	}
 
 	if (quote_mark) parser.index += 1;
@@ -741,12 +735,12 @@ function read_sequence(parser, done, location) {
 				const index = parser.index - 1;
 				parser.eat('#');
 				const name = parser.read_until(/[^a-z]/);
-				error(index, 'invalid-block-placement', location, name);
+				e.invalid_block_placement(index, name, location);
 			} else if (parser.match('@')) {
 				const index = parser.index - 1;
 				parser.eat('@');
 				const name = parser.read_until(/[^a-z]/);
-				error(index, 'invalid-tag-placement', location, name);
+				e.invalid_tag_placement(index, name, location);
 			}
 
 			flush(parser.index - 1);
@@ -784,5 +778,5 @@ function read_sequence(parser, done, location) {
 		}
 	}
 
-	error(parser.template.length, 'unexpected-eof');
+	e.unexpected_eof(parser.template.length);
 }
diff --git a/packages/svelte/src/compiler/phases/1-parse/state/tag.js b/packages/svelte/src/compiler/phases/1-parse/state/tag.js
index 1c73427463..537e0b6b34 100644
--- a/packages/svelte/src/compiler/phases/1-parse/state/tag.js
+++ b/packages/svelte/src/compiler/phases/1-parse/state/tag.js
@@ -1,6 +1,6 @@
 import read_pattern from '../read/context.js';
 import read_expression from '../read/expression.js';
-import { error } from '../../../errors.js';
+import * as e from '../../../errors.js';
 import { create_fragment } from '../utils/create.js';
 import { walk } from 'zimmerframe';
 
@@ -147,7 +147,7 @@ function open(parser) {
 			parser.allow_whitespace();
 			index = parser.read_identifier();
 			if (!index) {
-				error(parser.index, 'expected-identifier');
+				e.expected_identifier(parser.index);
 			}
 
 			parser.allow_whitespace();
@@ -265,7 +265,7 @@ function open(parser) {
 		const name_end = parser.index;
 
 		if (name === null) {
-			error(parser.index, 'expected-identifier');
+			e.expected_identifier(parser.index);
 		}
 
 		parser.eat('(', true);
@@ -320,7 +320,7 @@ function open(parser) {
 		return;
 	}
 
-	error(parser.index, 'expected-block-type');
+	e.expected_block_type(parser.index);
 }
 
 /** @param {import('../index.js').Parser} parser */
@@ -330,8 +330,8 @@ function next(parser) {
 	const block = parser.current(); // TODO type should not be TemplateNode, that's much too broad
 
 	if (block.type === 'IfBlock') {
-		if (!parser.eat('else')) error(start, 'expected-token', '{:else} or {:else if}');
-		if (parser.eat('if')) error(start, 'invalid-elseif');
+		if (!parser.eat('else')) e.expected_token(start, '{:else} or {:else if}');
+		if (parser.eat('if')) e.invalid_elseif(start);
 
 		parser.allow_whitespace();
 
@@ -373,7 +373,7 @@ function next(parser) {
 	}
 
 	if (block.type === 'EachBlock') {
-		if (!parser.eat('else')) error(start, 'expected-token', '{:else}');
+		if (!parser.eat('else')) e.expected_token(start, '{:else}');
 
 		parser.allow_whitespace();
 		parser.eat('}', true);
@@ -389,7 +389,7 @@ function next(parser) {
 	if (block.type === 'AwaitBlock') {
 		if (parser.eat('then')) {
 			if (block.then) {
-				error(start, 'duplicate-block-part', '{:then}');
+				e.duplicate_block_part(start, '{:then}');
 			}
 
 			if (!parser.eat('}')) {
@@ -408,7 +408,7 @@ function next(parser) {
 
 		if (parser.eat('catch')) {
 			if (block.catch) {
-				error(start, 'duplicate-block-part', '{:catch}');
+				e.duplicate_block_part(start, '{:catch}');
 			}
 
 			if (!parser.eat('}')) {
@@ -425,10 +425,10 @@ function next(parser) {
 			return;
 		}
 
-		error(start, 'expected-token', '{:then ...} or {:catch ...}');
+		e.expected_token(start, '{:then ...} or {:catch ...}');
 	}
 
-	error(start, 'invalid-continuing-block-placement');
+	e.invalid_continuing_block_placement(start);
 }
 
 /** @param {import('../index.js').Parser} parser */
@@ -466,11 +466,11 @@ function close(parser) {
 
 		case 'RegularElement':
 			// TODO handle implicitly closed elements
-			error(start, 'unexpected-block-close');
+			e.unexpected_block_close(start);
 			break;
 
 		default:
-			error(start, 'unexpected-block-close');
+			e.unexpected_block_close(start);
 	}
 
 	parser.allow_whitespace();
@@ -522,7 +522,7 @@ function special(parser) {
 			identifiers.forEach(
 				/** @param {any} node */ (node) => {
 					if (node.type !== 'Identifier') {
-						error(/** @type {number} */ (node.start), 'invalid-debug');
+						e.invalid_debug(/** @type {number} */ (node.start));
 					}
 				}
 			);
@@ -583,7 +583,7 @@ function special(parser) {
 				expression.expression.type !== 'CallExpression' ||
 				!expression.expression.optional)
 		) {
-			error(expression, 'invalid-render-expression');
+			e.invalid_render_expression(expression);
 		}
 
 		parser.allow_whitespace();
diff --git a/packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js b/packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
index 38a62b9ca7..6f933ab55a 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
@@ -1,5 +1,5 @@
 import { walk } from 'zimmerframe';
-import { error } from '../../../errors.js';
+import * as e from '../../../errors.js';
 import { is_keyframes_node } from '../../css.js';
 import { merge } from '../../visitors.js';
 
@@ -98,31 +98,26 @@ const validation_visitors = {
 	Rule(node, context) {
 		if (node.metadata.is_global_block) {
 			if (node.prelude.children.length > 1) {
-				error(node.prelude, 'invalid-css-global-block-list');
+				e.invalid_css_global_block_list(node.prelude);
 			}
 
 			const complex_selector = node.prelude.children[0];
 			const relative_selector = complex_selector.children[complex_selector.children.length - 1];
 
 			if (relative_selector.selectors.length > 1) {
-				error(
-					relative_selector.selectors[relative_selector.selectors.length - 1],
-					'invalid-css-global-block-modifier'
+				e.invalid_css_global_block_modifier(
+					relative_selector.selectors[relative_selector.selectors.length - 1]
 				);
 			}
 
 			if (relative_selector.combinator && relative_selector.combinator.name !== ' ') {
-				error(
-					relative_selector,
-					'invalid-css-global-block-combinator',
-					relative_selector.combinator.name
-				);
+				e.invalid_css_global_block_combinator(relative_selector, relative_selector.combinator.name);
 			}
 
 			const declaration = node.block.children.find((child) => child.type === 'Declaration');
 
 			if (declaration) {
-				error(declaration, 'invalid-css-global-block-declaration');
+				e.invalid_css_global_block_declaration(declaration);
 			}
 		}
 
@@ -137,7 +132,7 @@ const validation_visitors = {
 			if (a !== b) {
 				for (let i = a; i <= b; i += 1) {
 					if (is_global(node.children[i])) {
-						error(node.children[i].selectors[0], 'invalid-css-global-placement');
+						e.invalid_css_global_placement(node.children[i].selectors[0]);
 					}
 				}
 			}
@@ -152,12 +147,12 @@ const validation_visitors = {
 					const child = selector.args?.children[0].children[0];
 					// ensure `:global(element)` to be at the first position in a compound selector
 					if (child?.selectors[0].type === 'TypeSelector' && i !== 0) {
-						error(selector, 'invalid-css-global-selector-list');
+						e.invalid_css_global_selector_list(selector);
 					}
 
 					// ensure `:global(.class)` is not followed by a type selector, eg: `:global(.class)element`
 					if (relative_selector.selectors[i + 1]?.type === 'TypeSelector') {
-						error(relative_selector.selectors[i + 1], 'invalid-css-type-selector-placement');
+						e.invalid_css_type_selector_placement(relative_selector.selectors[i + 1]);
 					}
 
 					// ensure `:global(...)`contains a single selector
@@ -167,7 +162,7 @@ const validation_visitors = {
 						selector.args.children.length > 1 &&
 						(node.children.length > 1 || relative_selector.selectors.length > 1)
 					) {
-						error(selector, 'invalid-css-global-selector');
+						e.invalid_css_global_selector(selector);
 					}
 				}
 			}
@@ -176,7 +171,7 @@ const validation_visitors = {
 	NestingSelector(node, context) {
 		const rule = /** @type {import('#compiler').Css.Rule} */ (context.state.rule);
 		if (!rule.metadata.parent_rule) {
-			error(node, 'invalid-nesting-selector');
+			e.invalid_nesting_selector(node);
 		}
 	}
 };
diff --git a/packages/svelte/src/compiler/phases/2-analyze/index.js b/packages/svelte/src/compiler/phases/2-analyze/index.js
index 37eb3a3c92..10091a7105 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/index.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/index.js
@@ -1,6 +1,6 @@
 import is_reference from 'is-reference';
 import { walk } from 'zimmerframe';
-import { error } from '../../errors.js';
+import * as e from '../../errors.js';
 import {
 	extract_identifiers,
 	extract_all_identifiers_from_expression,
@@ -229,7 +229,7 @@ export function analyze_module(ast, options) {
 	for (const [name, references] of scope.references) {
 		if (name[0] !== '$' || ReservedKeywords.includes(name)) continue;
 		if (name === '$' || name[1] === '$') {
-			error(references[0].node, 'illegal-global', name);
+			e.illegal_global(references[0].node, name);
 		}
 	}
 
@@ -281,7 +281,7 @@ export function analyze_component(root, source, options) {
 	for (const [name, references] of module.scope.references) {
 		if (name[0] !== '$' || ReservedKeywords.includes(name)) continue;
 		if (name === '$' || name[1] === '$') {
-			error(references[0].node, 'illegal-global', name);
+			e.illegal_global(references[0].node, name);
 		}
 
 		const store_name = name.slice(1);
@@ -321,12 +321,12 @@ export function analyze_component(root, source, options) {
 			}
 
 			if (is_nested_store_subscription_node) {
-				error(is_nested_store_subscription_node, 'illegal-store-subscription');
+				e.illegal_store_subscription(is_nested_store_subscription_node);
 			}
 
 			if (options.runes !== false) {
 				if (declaration === null && /[a-z]/.test(store_name[0])) {
-					error(references[0].node, 'illegal-global', name);
+					e.illegal_global(references[0].node, name);
 				} else if (declaration !== null && Runes.includes(/** @type {any} */ (name))) {
 					for (const { node, path } of references) {
 						if (path.at(-1)?.type === 'CallExpression') {
@@ -345,7 +345,7 @@ export function analyze_component(root, source, options) {
 						// const state = $state(0) is valid
 						get_rune(/** @type {import('estree').Node} */ (path.at(-1)), module.scope) === null
 					) {
-						error(node, 'illegal-subscription');
+						e.illegal_subscription(node);
 					}
 				}
 			}
@@ -413,12 +413,12 @@ export function analyze_component(root, source, options) {
 	if (analysis.runes) {
 		const props_refs = module.scope.references.get('$$props');
 		if (props_refs) {
-			error(props_refs[0].node, 'invalid-legacy-props');
+			e.invalid_legacy_props(props_refs[0].node);
 		}
 
 		const rest_props_refs = module.scope.references.get('$$restProps');
 		if (rest_props_refs) {
-			error(rest_props_refs[0].node, 'invalid-legacy-rest-props');
+			e.invalid_legacy_rest_props(rest_props_refs[0].node);
 		}
 
 		for (const { ast, scope, scopes } of [module, instance, template]) {
@@ -451,7 +451,7 @@ export function analyze_component(root, source, options) {
 							({ alias, name }) => (binding.prop_alias ?? binding.node.name) === (alias ?? name)
 						)
 					) {
-						error(binding.node, 'conflicting-property-name');
+						e.conflicting_property_name(binding.node);
 					}
 				}
 			}
@@ -504,7 +504,7 @@ export function analyze_component(root, source, options) {
 	}
 
 	if (analysis.uses_render_tags && (analysis.uses_slots || analysis.slot_names.size > 0)) {
-		error(analysis.slot_names.values().next().value, 'conflicting-slot-usage');
+		e.conflicting_slot_usage(analysis.slot_names.values().next().value);
 	}
 
 	// warn on any nonstate declarations that are a) reassigned and b) referenced in the template
@@ -1425,7 +1425,7 @@ function order_reactive_statements(unsorted_reactive_declarations) {
 	const cycle = check_graph_for_cycles(edges);
 	if (cycle?.length) {
 		const declaration = /** @type {Tuple[]} */ (lookup.get(cycle[0]))[0];
-		error(declaration[0], 'cyclical-reactive-declaration', cycle);
+		e.cyclical_reactive_declaration(declaration[0], cycle.join(' → '));
 	}
 
 	// We use a map and take advantage of the fact that the spec says insertion order is preserved when iterating
diff --git a/packages/svelte/src/compiler/phases/2-analyze/validation.js b/packages/svelte/src/compiler/phases/2-analyze/validation.js
index 0f6f1bf6dd..cd1aed4b2d 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/validation.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/validation.js
@@ -3,7 +3,7 @@ import {
 	interactive_elements,
 	is_tag_valid_with_parent
 } from '../../../constants.js';
-import { error } from '../../errors.js';
+import * as e from '../../errors.js';
 import {
 	extract_identifiers,
 	get_parent,
@@ -44,14 +44,14 @@ function validate_component(node, context) {
 			attribute.type !== 'OnDirective' &&
 			attribute.type !== 'BindDirective'
 		) {
-			error(attribute, 'invalid-component-directive');
+			e.invalid_component_directive(attribute);
 		}
 
 		if (
 			attribute.type === 'OnDirective' &&
 			(attribute.modifiers.length > 1 || attribute.modifiers.some((m) => m !== 'once'))
 		) {
-			error(attribute, 'invalid-event-modifier');
+			e.invalid_component_event_modifier(attribute);
 		}
 
 		if (attribute.type === 'Attribute') {
@@ -62,7 +62,7 @@ function validate_component(node, context) {
 					while (--i > 0) {
 						const char = context.state.analysis.source[i];
 						if (char === '(') break; // parenthesized sequence expressions are ok
-						if (char === '{') error(expression, 'invalid-sequence-expression');
+						if (char === '{') e.invalid_sequence_expression(expression);
 					}
 				}
 			}
@@ -93,8 +93,12 @@ const react_attributes = new Map([
  */
 function validate_element(node, context) {
 	let has_animate_directive = false;
-	let has_in_transition = false;
-	let has_out_transition = false;
+
+	/** @type {import('#compiler').TransitionDirective | null} */
+	let in_transition = null;
+
+	/** @type {import('#compiler').TransitionDirective | null} */
+	let out_transition = null;
 
 	for (const attribute of node.attributes) {
 		if (attribute.type === 'Attribute') {
@@ -107,18 +111,18 @@ function validate_element(node, context) {
 					while (--i > 0) {
 						const char = context.state.analysis.source[i];
 						if (char === '(') break; // parenthesized sequence expressions are ok
-						if (char === '{') error(expression, 'invalid-sequence-expression');
+						if (char === '{') e.invalid_sequence_expression(expression);
 					}
 				}
 			}
 
 			if (regex_illegal_attribute_character.test(attribute.name)) {
-				error(attribute, 'invalid-attribute-name', attribute.name);
+				e.invalid_attribute_name(attribute, attribute.name);
 			}
 
 			if (attribute.name.startsWith('on') && attribute.name.length > 2) {
 				if (!is_expression) {
-					error(attribute, 'invalid-event-attribute-value');
+					e.invalid_event_attribute_value(attribute);
 				}
 
 				const value = attribute.value[0].expression;
@@ -162,9 +166,9 @@ function validate_element(node, context) {
 		} else if (attribute.type === 'AnimateDirective') {
 			const parent = context.path.at(-2);
 			if (parent?.type !== 'EachBlock') {
-				error(attribute, 'invalid-animation', 'no-each');
+				e.animation_invalid_placement(attribute);
 			} else if (!parent.key) {
-				error(attribute, 'invalid-animation', 'each-key');
+				e.animation_missing_key(attribute);
 			} else if (
 				parent.body.nodes.filter(
 					(n) =>
@@ -173,34 +177,39 @@ function validate_element(node, context) {
 						(n.type !== 'Text' || n.data.trim() !== '')
 				).length > 1
 			) {
-				error(attribute, 'invalid-animation', 'child');
+				e.animation_invalid_placement(attribute);
 			}
 
 			if (has_animate_directive) {
-				error(attribute, 'duplicate-animation');
+				e.animation_duplicate(attribute);
 			} else {
 				has_animate_directive = true;
 			}
 		} else if (attribute.type === 'TransitionDirective') {
-			if ((attribute.outro && has_out_transition) || (attribute.intro && has_in_transition)) {
-				/** @param {boolean} _in @param {boolean} _out */
-				const type = (_in, _out) => (_in && _out ? 'transition' : _in ? 'in' : 'out');
-				error(
-					attribute,
-					'duplicate-transition',
-					type(has_in_transition, has_out_transition),
-					type(attribute.intro, attribute.outro)
-				);
+			const existing = /** @type {import('#compiler').TransitionDirective | null} */ (
+				(attribute.intro && in_transition) || (attribute.outro && out_transition)
+			);
+
+			if (existing) {
+				const a = existing.intro ? (existing.outro ? 'transition' : 'in') : 'out';
+				const b = attribute.intro ? (attribute.outro ? 'transition' : 'in') : 'out';
+
+				if (a === b) {
+					e.transition_duplicate(attribute, a);
+				} else {
+					e.transition_conflict(attribute, a, b);
+				}
 			}
 
-			has_in_transition = has_in_transition || attribute.intro;
-			has_out_transition = has_out_transition || attribute.outro;
+			if (attribute.intro) in_transition = attribute;
+			if (attribute.outro) out_transition = attribute;
 		} else if (attribute.type === 'OnDirective') {
 			let has_passive_modifier = false;
 			let conflicting_passive_modifier = '';
 			for (const modifier of attribute.modifiers) {
 				if (!EventModifiers.includes(modifier)) {
-					error(attribute, 'invalid-event-modifier', EventModifiers);
+					const list = `${EventModifiers.slice(0, -1).join(', ')} or ${EventModifiers.at(-1)}`;
+					e.invalid_event_modifier(attribute, list);
 				}
 				if (modifier === 'passive') {
 					has_passive_modifier = true;
@@ -208,12 +217,7 @@ function validate_element(node, context) {
 					conflicting_passive_modifier = modifier;
 				}
 				if (has_passive_modifier && conflicting_passive_modifier) {
-					error(
-						attribute,
-						'invalid-event-modifier-combination',
-						'passive',
-						conflicting_passive_modifier
-					);
+					e.invalid_event_modifier_combination(attribute, 'passive', conflicting_passive_modifier);
 				}
 			}
 		}
@@ -259,7 +263,7 @@ function validate_slot_attribute(context, attribute) {
 
 	if (owner) {
 		if (!is_text_attribute(attribute)) {
-			error(attribute, 'invalid-slot-attribute');
+			e.invalid_slot_attribute(attribute);
 		}
 
 		if (
@@ -268,13 +272,13 @@ function validate_slot_attribute(context, attribute) {
 			owner.type === 'SvelteSelf'
 		) {
 			if (owner !== context.path.at(-2)) {
-				error(attribute, 'invalid-slot-placement');
+				e.invalid_slot_placement(attribute);
 			}
 
 			const name = attribute.value[0].data;
 
 			if (context.state.component_slots.has(name)) {
-				error(attribute, 'duplicate-slot-name', name, owner.name);
+				e.duplicate_slot_name(attribute, name, owner.name);
 			}
 
 			context.state.component_slots.add(name);
@@ -291,12 +295,12 @@ function validate_slot_attribute(context, attribute) {
 						}
 					}
 
-					error(node, 'invalid-default-slot-content');
+					e.invalid_default_slot_content(node);
 				}
 			}
 		}
 	} else {
-		error(attribute, 'invalid-slot-placement');
+		e.invalid_slot_placement(attribute);
 	}
 }
 
@@ -327,7 +331,7 @@ const validation = {
 		const left = object(assignee);
 
 		if (left === null) {
-			error(node, 'invalid-binding-expression');
+			e.invalid_binding_expression(node);
 		}
 
 		const binding = context.state.scope.get(left.name);
@@ -347,25 +351,25 @@ const validation = {
 					binding.kind !== 'store_sub' &&
 					!binding.mutated)
 			) {
-				error(node.expression, 'invalid-binding-value');
+				e.invalid_binding_value(node.expression);
 			}
 
 			if (binding.kind === 'derived') {
-				error(node.expression, 'invalid-derived-binding');
+				e.invalid_binding(node.expression, 'derived state');
 			}
 
 			if (context.state.analysis.runes && binding.kind === 'each') {
-				error(node, 'invalid-each-assignment');
+				e.invalid_each_assignment(node);
 			}
 
 			if (binding.kind === 'snippet') {
-				error(node, 'invalid-snippet-assignment');
+				e.invalid_snippet_assignment(node);
 			}
 		}
 
 		if (node.name === 'group') {
 			if (!binding) {
-				error(node, 'INTERNAL', 'Cannot find declaration for bind:group');
+				throw new Error('Cannot find declaration for bind:group');
 			}
 		}
 
@@ -389,21 +393,14 @@ const validation = {
 			parent?.type === 'SvelteBody'
 		) {
 			if (context.state.options.namespace === 'foreign' && node.name !== 'this') {
-				error(
-					node,
-					'invalid-binding',
-					node.name,
-					undefined,
-					'. Foreign elements only support bind:this'
-				);
+				e.bind_invalid_detailed(node, node.name, 'Foreign elements only support `bind:this`');
 			}
 
 			if (node.name in binding_properties) {
 				const property = binding_properties[node.name];
 				if (property.valid_elements && !property.valid_elements.includes(parent.name)) {
-					error(
+					e.bind_invalid_target(
 						node,
-						'invalid-binding',
 						node.name,
 						property.valid_elements.map((valid_element) => `<${valid_element}>`).join(', ')
 					);
@@ -415,17 +412,17 @@ const validation = {
 					);
 					if (type && !is_text_attribute(type)) {
 						if (node.name !== 'value' || type.value === true) {
-							error(type, 'invalid-type-attribute');
+							e.invalid_type_attribute(type);
 						}
 						return; // bind:value can handle dynamic `type` attributes
 					}
 
 					if (node.name === 'checked' && type?.value[0].data !== 'checkbox') {
-						error(node, 'invalid-binding', node.name, '<input type="checkbox">');
+						e.bind_invalid_target(node, node.name, '<input type="checkbox">');
 					}
 
 					if (node.name === 'files' && type?.value[0].data !== 'file') {
-						error(node, 'invalid-binding', node.name, '<input type="file">');
+						e.bind_invalid_target(node, node.name, '<input type="file">');
 					}
 				}
 
@@ -438,14 +435,13 @@ const validation = {
 							a.value !== true
 					);
 					if (multiple) {
-						error(multiple, 'invalid-multiple-attribute');
+						e.invalid_multiple_attribute(multiple);
 					}
 				}
 
 				if (node.name === 'offsetWidth' && SVGElements.includes(parent.name)) {
-					error(
+					e.bind_invalid_target(
 						node,
-						'invalid-binding',
 						node.name,
 						`non-<svg> elements. Use 'clientWidth' for <svg> instead`
 					);
@@ -456,9 +452,9 @@ const validation = {
 						parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'contenteditable')
 					);
 					if (!contenteditable) {
-						error(node, 'missing-contenteditable-attribute');
+						e.missing_contenteditable_attribute(node);
 					} else if (!is_text_attribute(contenteditable) && contenteditable.value !== true) {
-						error(contenteditable, 'dynamic-contenteditable-attribute');
+						e.dynamic_contenteditable_attribute(contenteditable);
 					}
 				}
 			} else {
@@ -466,15 +462,15 @@ const validation = {
 				if (match) {
 					const property = binding_properties[match];
 					if (!property.valid_elements || property.valid_elements.includes(parent.name)) {
-						error(node, 'invalid-binding', node.name, undefined, ` (did you mean '${match}'?)`);
+						e.bind_invalid_detailed(node, node.name, `Did you mean '${match}'?`);
 					}
 				}
-				error(node, 'invalid-binding', node.name);
+				e.bind_invalid(node, node.name);
 			}
 		}
 	},
 	ExportDefaultDeclaration(node) {
-		error(node, 'default-export');
+		e.default_export(node);
 	},
 	ConstTag(node, context) {
 		const parent = context.path.at(-1);
@@ -491,7 +487,7 @@ const validation = {
 				((grand_parent?.type !== 'RegularElement' && grand_parent?.type !== 'SvelteElement') ||
 					!grand_parent.attributes.some((a) => a.type === 'Attribute' && a.name === 'slot')))
 		) {
-			error(node, 'invalid-const-placement');
+			e.invalid_const_placement(node);
 		}
 	},
 	ImportDeclaration(node, context) {
@@ -502,7 +498,7 @@ const validation = {
 						specifier.imported.name === 'beforeUpdate' ||
 						specifier.imported.name === 'afterUpdate'
 					) {
-						error(specifier, 'invalid-runes-mode-import', specifier.imported.name);
+						e.invalid_runes_mode_import(specifier, specifier.imported.name);
 					}
 				}
 			}
@@ -520,14 +516,14 @@ const validation = {
 				parent.type !== 'SvelteSelf' &&
 				parent.type !== 'SvelteFragment')
 		) {
-			error(node, 'invalid-let-directive-placement');
+			e.invalid_let_directive_placement(node);
 		}
 	},
 	RegularElement(node, context) {
 		if (node.name === 'textarea' && node.fragment.nodes.length > 0) {
 			for (const attribute of node.attributes) {
 				if (attribute.type === 'Attribute' && attribute.name === 'value') {
-					error(node, 'invalid-textarea-content');
+					e.invalid_textarea_content(node);
 				}
 			}
 		}
@@ -551,7 +547,7 @@ const validation = {
 
 		if (context.state.parent_element) {
 			if (!is_tag_valid_with_parent(node.name, context.state.parent_element)) {
-				error(node, 'invalid-node-placement', `<${node.name}>`, context.state.parent_element);
+				e.invalid_node_placement(node, `<${node.name}>`, context.state.parent_element);
 			}
 		}
 
@@ -563,7 +559,7 @@ const validation = {
 					parent.name === node.name &&
 					interactive_elements.has(parent.name)
 				) {
-					error(node, 'invalid-node-placement', `<${node.name}>`, parent.name);
+					e.invalid_node_placement(node, `<${node.name}>`, parent.name);
 				}
 			}
 		}
@@ -572,7 +568,7 @@ const validation = {
 			const path = context.path;
 			for (let parent of path) {
 				if (parent.type === 'RegularElement' && parent.name === 'p') {
-					error(node, 'invalid-node-placement', `<${node.name}>`, parent.name);
+					e.invalid_node_placement(node, `<${node.name}>`, parent.name);
 				}
 			}
 		}
@@ -603,7 +599,7 @@ const validation = {
 		const raw_args = unwrap_optional(node.expression).arguments;
 		for (const arg of raw_args) {
 			if (arg.type === 'SpreadElement') {
-				error(arg, 'invalid-render-spread-argument');
+				e.invalid_render_spread_argument(arg);
 			}
 		}
 
@@ -613,7 +609,7 @@ const validation = {
 			callee.property.type === 'Identifier' &&
 			['bind', 'apply', 'call'].includes(callee.property.name)
 		) {
-			error(node, 'invalid-render-call');
+			e.invalid_render_call(node);
 		}
 
 		const is_inside_textarea = context.path.find((n) => {
@@ -625,9 +621,8 @@ const validation = {
 			);
 		});
 		if (is_inside_textarea) {
-			error(
+			e.invalid_tag_placement(
 				node,
-				'invalid-tag-placement',
 				'inside <textarea> or <svelte:element this="textarea">',
 				'render'
 			);
@@ -667,19 +662,19 @@ const validation = {
 					(node) => node.type !== 'SnippetBlock' && (node.type !== 'Text' || node.data.trim())
 				)
 			) {
-				error(node, 'conflicting-children-snippet');
+				e.conflicting_children_snippet(node);
 			}
 		}
 	},
 	StyleDirective(node) {
 		if (node.modifiers.length > 1 || (node.modifiers.length && node.modifiers[0] !== 'important')) {
-			error(node, 'invalid-style-directive-modifier');
+			e.invalid_style_directive_modifier(node);
 		}
 	},
 	SvelteHead(node) {
 		const attribute = node.attributes[0];
 		if (attribute) {
-			error(attribute, 'illegal-svelte-head-attribute');
+			e.illegal_svelte_head_attribute(attribute);
 		}
 	},
 	SvelteElement(node, context) {
@@ -692,7 +687,7 @@ const validation = {
 	SvelteFragment(node, context) {
 		const parent = context.path.at(-2);
 		if (parent?.type !== 'Component' && parent?.type !== 'SvelteComponent') {
-			error(node, 'invalid-svelte-fragment-placement');
+			e.invalid_svelte_fragment_placement(node);
 		}
 
 		for (const attribute of node.attributes) {
@@ -701,7 +696,7 @@ const validation = {
 					validate_slot_attribute(context, attribute);
 				}
 			} else if (attribute.type !== 'LetDirective') {
-				error(attribute, 'invalid-svelte-fragment-attribute');
+				e.invalid_svelte_fragment_attribute(attribute);
 			}
 		}
 	},
@@ -710,15 +705,15 @@ const validation = {
 			if (attribute.type === 'Attribute') {
 				if (attribute.name === 'name') {
 					if (!is_text_attribute(attribute)) {
-						error(attribute, 'invalid-slot-name', false);
+						e.invalid_slot_name(attribute);
 					}
 					const slot_name = attribute.value[0].data;
 					if (slot_name === 'default') {
-						error(attribute, 'invalid-slot-name', true);
+						e.invalid_slot_name_default(attribute);
 					}
 				}
 			} else if (attribute.type !== 'SpreadAttribute' && attribute.type !== 'LetDirective') {
-				error(attribute, 'invalid-slot-element-attribute');
+				e.invalid_slot_element_attribute(attribute);
 			}
 		}
 	},
@@ -729,19 +724,19 @@ const validation = {
 		if (!node.parent) return;
 		if (context.state.parent_element && regex_not_whitespace.test(node.data)) {
 			if (!is_tag_valid_with_parent('#text', context.state.parent_element)) {
-				error(node, 'invalid-node-placement', 'Text node', context.state.parent_element);
+				e.invalid_node_placement(node, 'Text node', context.state.parent_element);
 			}
 		}
 	},
 	TitleElement(node) {
 		const attribute = node.attributes[0];
 		if (attribute) {
-			error(attribute, 'illegal-title-attribute');
+			e.illegal_title_attribute(attribute);
 		}
 
 		const child = node.fragment.nodes.find((n) => n.type !== 'Text' && n.type !== 'ExpressionTag');
 		if (child) {
-			error(child, 'invalid-title-content');
+			e.invalid_title_content(child);
 		}
 	},
 	UpdateExpression(node, context) {
@@ -751,7 +746,7 @@ const validation = {
 		if (!node.parent) return;
 		if (context.state.parent_element) {
 			if (!is_tag_valid_with_parent('#text', context.state.parent_element)) {
-				error(node, 'invalid-node-placement', '{expression}', context.state.parent_element);
+				e.invalid_node_placement(node, '{expression}', context.state.parent_element);
 			}
 		}
 	}
@@ -772,7 +767,7 @@ export const validation_legacy = merge(validation, a11y_validators, {
 		}
 
 		if (state.scope.get(callee.name)?.kind !== 'store_sub') {
-			error(node.init, 'invalid-rune-usage', callee.name);
+			e.invalid_rune_usage(node.init, callee.name);
 		}
 	},
 	AssignmentExpression(node, { state, path }) {
@@ -805,11 +800,11 @@ function validate_export(node, scope, name) {
 	if (!binding) return;
 
 	if (binding.kind === 'derived') {
-		error(node, 'invalid-derived-export');
+		e.invalid_derived_export(node);
 	}
 
 	if ((binding.kind === 'state' || binding.kind === 'frozen_state') && binding.reassigned) {
-		error(node, 'invalid-state-export');
+		e.invalid_state_export(node);
 	}
 }
 
@@ -827,7 +822,7 @@ function validate_call_expression(node, scope, path) {
 
 	if (rune === '$props') {
 		if (parent.type === 'VariableDeclarator') return;
-		error(node, 'invalid-props-location');
+		e.invalid_props_location(node);
 	}
 
 	if (rune === '$bindable') {
@@ -840,7 +835,7 @@ function validate_call_expression(node, scope, path) {
 				return;
 			}
 		}
-		error(node, 'invalid-bindable-location');
+		e.invalid_bindable_location(node);
 	}
 
 	if (
@@ -851,46 +846,46 @@ function validate_call_expression(node, scope, path) {
 	) {
 		if (parent.type === 'VariableDeclarator') return;
 		if (parent.type === 'PropertyDefinition' && !parent.static && !parent.computed) return;
-		error(node, 'invalid-state-location', rune);
+		e.invalid_state_location(node, rune);
 	}
 
 	if (rune === '$effect' || rune === '$effect.pre') {
 		if (parent.type !== 'ExpressionStatement') {
-			error(node, 'invalid-effect-location');
+			e.invalid_effect_location(node);
 		}
 
 		if (node.arguments.length !== 1) {
-			error(node, 'invalid-rune-args-length', rune, [1]);
+			e.invalid_rune_args_length(node, rune, 'exactly one argument');
 		}
 	}
 
 	if (rune === '$effect.active') {
 		if (node.arguments.length !== 0) {
-			error(node, 'invalid-rune-args-length', rune, [0]);
+			e.invalid_rune_args(node, rune);
 		}
 	}
 
 	if (rune === '$effect.root') {
 		if (node.arguments.length !== 1) {
-			error(node, 'invalid-rune-args-length', rune, [1]);
+			e.invalid_rune_args_length(node, rune, 'exactly one argument');
 		}
 	}
 
 	if (rune === '$inspect') {
 		if (node.arguments.length < 1) {
-			error(node, 'invalid-rune-args-length', rune, [1, 'more']);
+			e.invalid_rune_args_length(node, rune, 'one or more arguments');
 		}
 	}
 
 	if (rune === '$inspect().with') {
 		if (node.arguments.length !== 1) {
-			error(node, 'invalid-rune-args-length', rune, [1]);
+			e.invalid_rune_args_length(node, rune, 'exactly one argument');
 		}
 	}
 
 	if (rune === '$state.snapshot') {
 		if (node.arguments.length !== 1) {
-			error(node, 'invalid-rune-args-length', rune, [1]);
+			e.invalid_rune_args_length(node, rune, 'exactly one argument');
 		}
 	}
 }
@@ -906,7 +901,7 @@ function ensure_no_module_import_conflict(node, state) {
 			state.scope === state.analysis.instance.scope &&
 			state.analysis.module.scope.get(id.name)?.declaration_kind === 'import'
 		) {
-			error(node.id, 'illegal-variable-declaration');
+			e.illegal_variable_declaration(node.id);
 		}
 	}
 }
@@ -932,7 +927,7 @@ export const validation_runes_js = {
 	},
 	CallExpression(node, { state, path }) {
 		if (get_rune(node, state.scope) === '$host') {
-			error(node, 'invalid-host-location');
+			e.invalid_host_location(node);
 		}
 		validate_call_expression(node, state.scope, path);
 	},
@@ -945,13 +940,13 @@ export const validation_runes_js = {
 		const args = /** @type {import('estree').CallExpression} */ (init).arguments;
 
 		if ((rune === '$derived' || rune === '$derived.by') && args.length !== 1) {
-			error(node, 'invalid-rune-args-length', rune, [1]);
+			e.invalid_rune_args_length(node, rune, 'exactly one argument');
 		} else if (rune === '$state' && args.length > 1) {
-			error(node, 'invalid-rune-args-length', rune, [0, 1]);
+			e.invalid_rune_args_length(node, rune, 'zero or one arguments');
 		} else if (rune === '$props') {
-			error(node, 'invalid-props-location');
+			e.invalid_props_location(node);
 		} else if (rune === '$bindable') {
-			error(node, 'invalid-bindable-location');
+			e.invalid_bindable_location(node);
 		}
 	},
 	AssignmentExpression(node, { state }) {
@@ -1021,16 +1016,24 @@ function validate_no_const_assignment(node, argument, scope, is_binding) {
 	} else if (argument.type === 'Identifier') {
 		const binding = scope.get(argument.name);
 		if (binding?.declaration_kind === 'const' && binding.kind !== 'each') {
-			error(
-				node,
-				'invalid-const-assignment',
-				is_binding,
-				// This takes advantage of the fact that we don't assign initial for let directives and then/catch variables.
-				// If we start doing that, we need another property on the binding to differentiate, or give up on the more precise error message.
-				binding.kind !== 'state' &&
-					binding.kind !== 'frozen_state' &&
-					(binding.kind !== 'normal' || !binding.initial)
-			);
+			// e.invalid_const_assignment(
+			// 	node,
+			// 	is_binding,
+			// 	// This takes advantage of the fact that we don't assign initial for let directives and then/catch variables.
+			// 	// If we start doing that, we need another property on the binding to differentiate, or give up on the more precise error message.
+			// 	binding.kind !== 'state' &&
+			// 		binding.kind !== 'frozen_state' &&
+			// 		(binding.kind !== 'normal' || !binding.initial)
+			// );
+
+			// TODO have a more specific error message for assignments to things like `{:then foo}`
+			const thing = 'constant';
+
+			if (is_binding) {
+				e.invalid_binding(node, thing);
+			} else {
+				e.invalid_assignment(node, thing);
+			}
 		}
 	}
 }
@@ -1048,16 +1051,16 @@ function validate_assignment(node, argument, state) {
 
 		if (state.analysis.runes) {
 			if (binding?.kind === 'derived') {
-				error(node, 'invalid-derived-assignment');
+				e.invalid_assignment(node, 'derived state');
 			}
 
 			if (binding?.kind === 'each') {
-				error(node, 'invalid-each-assignment');
+				e.invalid_each_assignment(node);
 			}
 		}
 
 		if (binding?.kind === 'snippet') {
-			error(node, 'invalid-snippet-assignment');
+			e.invalid_snippet_assignment(node);
 		}
 	}
 
@@ -1073,7 +1076,7 @@ function validate_assignment(node, argument, state) {
 
 	if (object.type === 'ThisExpression' && property?.type === 'PrivateIdentifier') {
 		if (state.private_derived_state.includes(property.name)) {
-			error(node, 'invalid-derived-assignment');
+			e.invalid_assignment(node, 'derived state');
 		}
 	}
 }
@@ -1081,7 +1084,7 @@ function validate_assignment(node, argument, state) {
 export const validation_runes = merge(validation, a11y_validators, {
 	LabeledStatement(node, { path }) {
 		if (node.label.name !== '$' || path.at(-1)?.type !== 'Program') return;
-		error(node, 'invalid-legacy-reactive-statement');
+		e.invalid_legacy_reactive_statement(node);
 	},
 	ExportNamedDeclaration(node, { state, next }) {
 		if (state.ast_type === 'module') {
@@ -1099,7 +1102,7 @@ export const validation_runes = merge(validation, a11y_validators, {
 			if (node.declaration?.type !== 'VariableDeclaration') return;
 			if (node.declaration.kind !== 'let') return;
 			if (state.analysis.instance.scope !== state.scope) return;
-			error(node, 'invalid-legacy-export');
+			e.invalid_legacy_export(node);
 		}
 	},
 	ExportSpecifier(node, { state }) {
@@ -1110,12 +1113,12 @@ export const validation_runes = merge(validation, a11y_validators, {
 	CallExpression(node, { state, path }) {
 		const rune = get_rune(node, state.scope);
 		if (rune === '$bindable' && node.arguments.length > 1) {
-			error(node, 'invalid-rune-args-length', '$bindable', [0, 1]);
+			e.invalid_rune_args_length(node, '$bindable', 'zero or one arguments');
 		} else if (rune === '$host') {
 			if (node.arguments.length > 0) {
-				error(node, 'invalid-rune-args-length', '$host', [0]);
+				e.invalid_rune_args(node, '$host');
 			} else if (state.ast_type === 'module' || !state.analysis.custom_element) {
-				error(node, 'invalid-host-location');
+				e.invalid_host_location(node);
 			}
 		}
 
@@ -1127,7 +1130,7 @@ export const validation_runes = merge(validation, a11y_validators, {
 			context.type === 'Identifier' &&
 			(context.name === '$state' || context.name === '$derived')
 		) {
-			error(node, 'invalid-state-location', context.name);
+			e.invalid_state_location(node, context.name);
 		}
 		next({ ...state });
 	},
@@ -1148,39 +1151,39 @@ export const validation_runes = merge(validation, a11y_validators, {
 
 		// TODO some of this is duplicated with above, seems off
 		if ((rune === '$derived' || rune === '$derived.by') && args.length !== 1) {
-			error(node, 'invalid-rune-args-length', rune, [1]);
+			e.invalid_rune_args_length(node, rune, 'exactly one argument');
 		} else if (rune === '$state' && args.length > 1) {
-			error(node, 'invalid-rune-args-length', rune, [0, 1]);
+			e.invalid_rune_args_length(node, rune, 'zero or one arguments');
 		} else if (rune === '$props') {
 			if (state.has_props_rune) {
-				error(node, 'duplicate-props-rune');
+				e.duplicate_props_rune(node);
 			}
 
 			state.has_props_rune = true;
 
 			if (args.length > 0) {
-				error(node, 'invalid-rune-args-length', rune, [0]);
+				e.invalid_rune_args(node, rune);
 			}
 
 			if (node.id.type !== 'ObjectPattern') {
-				error(node, 'invalid-props-id');
+				e.invalid_props_id(node);
 			}
 
 			if (state.scope !== state.analysis.instance.scope) {
-				error(node, 'invalid-props-location');
+				e.invalid_props_location(node);
 			}
 
 			for (const property of node.id.properties) {
 				if (property.type === 'Property') {
 					if (property.computed) {
-						error(property, 'invalid-props-pattern');
+						e.invalid_props_pattern(property);
 					}
 
 					const value =
 						property.value.type === 'AssignmentPattern' ? property.value.left : property.value;
 
 					if (value.type !== 'Identifier') {
-						error(property, 'invalid-props-pattern');
+						e.invalid_props_pattern(property);
 					}
 				}
 			}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js b/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
index 70f981d3e6..2498f24a69 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
@@ -1,5 +1,4 @@
 import { walk } from 'zimmerframe';
-import { error } from '../../../errors.js';
 import * as b from '../../../utils/builders.js';
 import { set_scope } from '../../scope.js';
 import { template_visitors } from './visitors/template.js';
@@ -52,35 +51,41 @@ export function client_component(source, analysis, options) {
 		get before_init() {
 			/** @type {any[]} */
 			const a = [];
-			a.push = () =>
-				error(null, 'INTERNAL', 'before_init.push should not be called outside create_block');
+			a.push = () => {
+				throw new Error('before_init.push should not be called outside create_block');
+			};
 			return a;
 		},
 		get init() {
 			/** @type {any[]} */
 			const a = [];
-			a.push = () => error(null, 'INTERNAL', 'init.push should not be called outside create_block');
+			a.push = () => {
+				throw new Error('init.push should not be called outside create_block');
+			};
 			return a;
 		},
 		get update() {
 			/** @type {any[]} */
 			const a = [];
-			a.push = () =>
-				error(null, 'INTERNAL', 'update.push should not be called outside create_block');
+			a.push = () => {
+				throw new Error('update.push should not be called outside create_block');
+			};
 			return a;
 		},
 		get after_update() {
 			/** @type {any[]} */
 			const a = [];
-			a.push = () =>
-				error(null, 'INTERNAL', 'after_update.push should not be called outside create_block');
+			a.push = () => {
+				throw new Error('after_update.push should not be called outside create_block');
+			};
 			return a;
 		},
 		get template() {
 			/** @type {any[]} */
 			const a = [];
-			a.push = () =>
-				error(null, 'INTERNAL', 'template.push should not be called outside create_block');
+			a.push = () => {
+				throw new Error('template.push should not be called outside create_block');
+			};
 			return a;
 		},
 		legacy_reactive_statements: new Map(),
@@ -209,7 +214,7 @@ export function client_component(source, analysis, options) {
 	for (const [node] of analysis.reactive_statements) {
 		const statement = [...state.legacy_reactive_statements].find(([n]) => n === node);
 		if (statement === undefined) {
-			error(node, 'INTERNAL', 'Could not find reactive statement');
+			throw new Error('Could not find reactive statement');
 		}
 		instance.body.push(statement[1]);
 	}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/utils.js b/packages/svelte/src/compiler/phases/3-transform/client/utils.js
index 17e3fedc1d..481caf6561 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/utils.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/utils.js
@@ -5,7 +5,6 @@ import {
 	is_simple_expression,
 	object
 } from '../../../utils/ast.js';
-import { error } from '../../../errors.js';
 import {
 	PROPS_IS_LAZY_INITIAL,
 	PROPS_IS_IMMUTABLE,
@@ -185,7 +184,7 @@ export function serialize_set_binding(node, context, fallback, options) {
 	}
 
 	if (assignee.type !== 'Identifier' && assignee.type !== 'MemberExpression') {
-		error(node, 'INTERNAL', `Unexpected assignment type ${assignee.type}`);
+		throw new Error(`Unexpected assignment type ${assignee.type}`);
 	}
 
 	// Handle class private/public state assignment cases
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/template.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/template.js
index e9d3b519c7..9c7706a17c 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/template.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/template.js
@@ -16,7 +16,6 @@ import {
 import { DOMProperties, PassiveEvents, VoidElements } from '../../../constants.js';
 import { is_custom_element_node, is_element_node } from '../../../nodes.js';
 import * as b from '../../../../utils/builders.js';
-import { error } from '../../../../errors.js';
 import {
 	with_loc,
 	function_visitor,
@@ -1776,10 +1775,10 @@ export const template_visitors = {
 		);
 	},
 	ClassDirective(node, { state, next }) {
-		error(node, 'INTERNAL', 'Node should have been handled elsewhere');
+		throw new Error('Node should have been handled elsewhere');
 	},
 	StyleDirective(node, { state, next }) {
-		error(node, 'INTERNAL', 'Node should have been handled elsewhere');
+		throw new Error('Node should have been handled elsewhere');
 	},
 	TransitionDirective(node, { state, visit }) {
 		let flags = node.modifiers.includes('global') ? TRANSITION_GLOBAL : 0;
@@ -2775,7 +2774,7 @@ export const template_visitors = {
 				}
 
 				default:
-					error(node, 'INTERNAL', 'unknown binding ' + node.name);
+					throw new Error('unknown binding ' + node.name);
 			}
 		}
 
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/transform-server.js b/packages/svelte/src/compiler/phases/3-transform/server/transform-server.js
index 4f631b8c70..2f5ed1d4aa 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/transform-server.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/transform-server.js
@@ -22,7 +22,6 @@ import {
 	transform_inspect_rune
 } from '../utils.js';
 import { create_attribute, is_custom_element_node, is_element_node } from '../../nodes.js';
-import { error } from '../../../errors.js';
 import { binding_properties } from '../../bindings.js';
 import { regex_starts_with_newline, regex_whitespaces_strict } from '../../patterns.js';
 import {
@@ -419,7 +418,7 @@ function serialize_set_binding(node, context, fallback) {
 	}
 
 	if (node.left.type !== 'Identifier' && node.left.type !== 'MemberExpression') {
-		error(node, 'INTERNAL', `Unexpected assignment type ${node.left.type}`);
+		throw new Error(`Unexpected assignment type ${node.left.type}`);
 	}
 
 	let left = node.left;
@@ -1311,10 +1310,10 @@ const template_visitors = {
 		state.template.push(block_close);
 	},
 	ClassDirective(node) {
-		error(node, 'INTERNAL', 'Node should have been handled elsewhere');
+		throw new Error('Node should have been handled elsewhere');
 	},
 	StyleDirective(node) {
-		error(node, 'INTERNAL', 'Node should have been handled elsewhere');
+		throw new Error('Node should have been handled elsewhere');
 	},
 	RegularElement(node, context) {
 		const metadata = {
@@ -2106,14 +2105,17 @@ export function server_component(analysis, options) {
 		get init() {
 			/** @type {any[]} */
 			const a = [];
-			a.push = () => error(null, 'INTERNAL', 'init.push should not be called outside create_block');
+			a.push = () => {
+				throw new Error('init.push should not be called outside create_block');
+			};
 			return a;
 		},
 		get template() {
 			/** @type {any[]} */
 			const a = [];
-			a.push = () =>
-				error(null, 'INTERNAL', 'template.push should not be called outside create_block');
+			a.push = () => {
+				throw new Error('template.push should not be called outside create_block');
+			};
 			return a;
 		},
 		metadata: {
@@ -2181,7 +2183,7 @@ export function server_component(analysis, options) {
 	for (const [node] of analysis.reactive_statements) {
 		const statement = [...state.legacy_reactive_statements].find(([n]) => n === node);
 		if (statement === undefined) {
-			error(node, 'INTERNAL', 'Could not find reactive statement');
+			throw new Error('Could not find reactive statement');
 		}
 
 		if (
diff --git a/packages/svelte/src/compiler/phases/scope.js b/packages/svelte/src/compiler/phases/scope.js
index cfc2f0bb44..d815ff88fd 100644
--- a/packages/svelte/src/compiler/phases/scope.js
+++ b/packages/svelte/src/compiler/phases/scope.js
@@ -2,7 +2,7 @@ import is_reference from 'is-reference';
 import { walk } from 'zimmerframe';
 import { is_element_node } from './nodes.js';
 import * as b from '../utils/builders.js';
-import { error } from '../errors.js';
+import * as e from '../errors.js';
 import { extract_identifiers, extract_identifiers_from_destructuring } from '../utils/ast.js';
 import { JsKeywords, Runes } from './constants.js';
 
@@ -70,7 +70,7 @@ export class Scope {
 	 */
 	declare(node, kind, declaration_kind, initial = null) {
 		if (node.name === '$') {
-			error(node, 'invalid-dollar-binding');
+			e.invalid_dollar_binding(node);
 		}
 
 		if (
@@ -80,7 +80,7 @@ export class Scope {
 			declaration_kind !== 'rest_param' &&
 			this.function_depth <= 1
 		) {
-			error(node, 'invalid-dollar-prefix');
+			e.invalid_dollar_prefix(node);
 		}
 
 		if (this.parent) {
@@ -95,7 +95,7 @@ export class Scope {
 
 		if (this.declarations.has(node.name)) {
 			// This also errors on var/function types, but that's arguably a good thing
-			error(node, 'duplicate-declaration', node.name);
+			e.duplicate_declaration(node, node.name);
 		}
 
 		/** @type {import('#compiler').Binding} */
@@ -166,7 +166,7 @@ export class Scope {
 	get_bindings(node) {
 		const bindings = this.declarators.get(node);
 		if (!bindings) {
-			error(node, 'INTERNAL', 'No binding found for declarator');
+			throw new Error('No binding found for declarator');
 		}
 		return bindings;
 	}
@@ -767,7 +767,7 @@ export function get_rune(node, scope) {
 
 	joined = n.name + joined;
 
-	if (joined === '$derived.call') error(node, 'invalid-derived-call');
+	if (joined === '$derived.call') e.invalid_derived_call(node);
 	if (!Runes.includes(/** @type {any} */ (joined))) return null;
 
 	const binding = scope.get(n.name);
diff --git a/packages/svelte/src/compiler/utils/assert.js b/packages/svelte/src/compiler/utils/assert.js
index ac1cc2bd47..b6dc6bf90c 100644
--- a/packages/svelte/src/compiler/utils/assert.js
+++ b/packages/svelte/src/compiler/utils/assert.js
@@ -1,12 +1,10 @@
-import { error } from '../errors.js';
-
 /**
  * @template T
  * @param {T} value
  * @returns {asserts value is NonNullable<T>}
  */
 export function ok(value) {
-	if (!value) error(null, 'INTERNAL', 'Assertion failed');
+	if (!value) throw new Error('Assertion failed');
 }
 
 /**
@@ -16,5 +14,5 @@ export function ok(value) {
  * @returns {asserts actual is T}
  */
 export function equal(actual, expected) {
-	if (actual !== expected) error(null, 'INTERNAL', 'Assertion failed');
+	if (actual !== expected) throw new Error('Assertion failed');
 }
diff --git a/packages/svelte/src/compiler/validate-options.js b/packages/svelte/src/compiler/validate-options.js
index 6c12a43e2b..d9b0e9b1c3 100644
--- a/packages/svelte/src/compiler/validate-options.js
+++ b/packages/svelte/src/compiler/validate-options.js
@@ -1,4 +1,4 @@
-import { error } from './errors.js';
+import * as e from './errors.js';
 
 /**
  * @template [Input=any]
@@ -141,7 +141,7 @@ export const validate_component_options =
 function removed(msg) {
 	return (input) => {
 		if (input !== undefined) {
-			error(null, 'removed-compiler-option', msg);
+			e.removed_compiler_option(null, msg);
 		}
 		return /** @type {any} */ (undefined);
 	};
@@ -200,9 +200,8 @@ function object(children, allow_unknown = false) {
 				if (allow_unknown) {
 					output[key] = input[key];
 				} else {
-					error(
+					e.invalid_compiler_option(
 						null,
-						'invalid-compiler-option',
 						`Unexpected option ${keypath ? `${keypath}.${key}` : key}`
 					);
 				}
@@ -307,5 +306,5 @@ function fun(fallback) {
 
 /** @param {string} msg */
 function throw_error(msg) {
-	error(null, 'invalid-compiler-option', msg);
+	e.invalid_compiler_option(null, msg);
 }
diff --git a/packages/svelte/tests/compiler-errors/samples/attribute-empty/_config.js b/packages/svelte/tests/compiler-errors/samples/attribute-empty/_config.js
index 248fc1107e..9c29f505ee 100644
--- a/packages/svelte/tests/compiler-errors/samples/attribute-empty/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/attribute-empty/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'missing-attribute-value',
+		code: 'missing_attribute_value',
 		message: 'Expected attribute value',
 		position: [12, 12]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/attribute-sequence-expression-2/_config.js b/packages/svelte/tests/compiler-errors/samples/attribute-sequence-expression-2/_config.js
index 5fc3e7b5fa..e655d40aae 100644
--- a/packages/svelte/tests/compiler-errors/samples/attribute-sequence-expression-2/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/attribute-sequence-expression-2/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-sequence-expression',
+		code: 'invalid_sequence_expression',
 		message:
 			'Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses',
 		position: [124, 131]
diff --git a/packages/svelte/tests/compiler-errors/samples/attribute-sequence-expression/_config.js b/packages/svelte/tests/compiler-errors/samples/attribute-sequence-expression/_config.js
index 79ddec267b..15549974d3 100644
--- a/packages/svelte/tests/compiler-errors/samples/attribute-sequence-expression/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/attribute-sequence-expression/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-sequence-expression',
+		code: 'invalid_sequence_expression',
 		message:
 			'Sequence expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses',
 		position: [163, 170]
diff --git a/packages/svelte/tests/compiler-errors/samples/attribute-unique-binding/_config.js b/packages/svelte/tests/compiler-errors/samples/attribute-unique-binding/_config.js
index e933cebbf5..5fb31858b7 100644
--- a/packages/svelte/tests/compiler-errors/samples/attribute-unique-binding/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/attribute-unique-binding/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-attribute',
+		code: 'duplicate_attribute',
 		message: 'Attributes need to be unique',
 		position: [17, 17]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/attribute-unique-shorthand/_config.js b/packages/svelte/tests/compiler-errors/samples/attribute-unique-shorthand/_config.js
index e933cebbf5..5fb31858b7 100644
--- a/packages/svelte/tests/compiler-errors/samples/attribute-unique-shorthand/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/attribute-unique-shorthand/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-attribute',
+		code: 'duplicate_attribute',
 		message: 'Attributes need to be unique',
 		position: [17, 17]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/attribute-unique/_config.js b/packages/svelte/tests/compiler-errors/samples/attribute-unique/_config.js
index e933cebbf5..5fb31858b7 100644
--- a/packages/svelte/tests/compiler-errors/samples/attribute-unique/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/attribute-unique/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-attribute',
+		code: 'duplicate_attribute',
 		message: 'Attributes need to be unique',
 		position: [17, 17]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/catch-before-closing/_config.js b/packages/svelte/tests/compiler-errors/samples/catch-before-closing/_config.js
index 1a50076da4..52786af6d8 100644
--- a/packages/svelte/tests/compiler-errors/samples/catch-before-closing/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/catch-before-closing/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'expected-token',
+		code: 'expected_token',
 		message: 'Expected token {:else}',
 		position: [35, 35]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/catch-without-await/_config.js b/packages/svelte/tests/compiler-errors/samples/catch-without-await/_config.js
index 64c85f85c9..b24874f1b4 100644
--- a/packages/svelte/tests/compiler-errors/samples/catch-without-await/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/catch-without-await/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-continuing-block-placement',
+		code: 'invalid_continuing_block_placement',
 		message:
 			'{:...} block is invalid at this position (did you forget to close the preceeding element or block?)',
 		position: [1, 1]
diff --git a/packages/svelte/tests/compiler-errors/samples/class-state-field-static/_config.js b/packages/svelte/tests/compiler-errors/samples/class-state-field-static/_config.js
index dca19b4606..d212e197f0 100644
--- a/packages/svelte/tests/compiler-errors/samples/class-state-field-static/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/class-state-field-static/_config.js
@@ -2,8 +2,9 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-state-location',
-		message: '$state(...) can only be used as a variable declaration initializer or a class field',
+		code: 'invalid_state_location',
+		message:
+			'`$state(...)` can only be used as a variable declaration initializer or a class field',
 		position: [33, 41]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/comment-unclosed/_config.js b/packages/svelte/tests/compiler-errors/samples/comment-unclosed/_config.js
index 7c00375ad6..38bc06f415 100644
--- a/packages/svelte/tests/compiler-errors/samples/comment-unclosed/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/comment-unclosed/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'unexpected-eof',
-		message: 'Unexpected end of input (expected -->)',
+		code: 'expected_token',
+		message: 'Expected token -->',
 		position: [24, 24]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-2/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-2/_config.js
index 0085693908..2dafcd66b1 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-2/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-2/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-slot-name',
+		code: 'duplicate_slot_name',
 		message: "Duplicate slot name 'foo' in <Nested>"
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-3/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-3/_config.js
index 0085693908..2dafcd66b1 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-3/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-3/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-slot-name',
+		code: 'duplicate_slot_name',
 		message: "Duplicate slot name 'foo' in <Nested>"
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-4/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-4/_config.js
index 78e10808bd..1a8d68c564 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-4/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-4/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-default-slot-content',
+		code: 'invalid_default_slot_content',
 		message: 'Found default slot content alongside an explicit slot="default"'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-5/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-5/_config.js
index 0085693908..2dafcd66b1 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-5/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-5/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-slot-name',
+		code: 'duplicate_slot_name',
 		message: "Duplicate slot name 'foo' in <Nested>"
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-6/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-6/_config.js
index 0085693908..2dafcd66b1 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-6/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error-6/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-slot-name',
+		code: 'duplicate_slot_name',
 		message: "Duplicate slot name 'foo' in <Nested>"
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error/_config.js
index 0085693908..2dafcd66b1 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-duplicate-error/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-slot-name',
+		code: 'duplicate_slot_name',
 		message: "Duplicate slot name 'foo' in <Nested>"
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error-2/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error-2/_config.js
index 69c2adb23c..727e0c8bda 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error-2/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error-2/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-slot-placement',
+		code: 'invalid_slot_placement',
 		message:
 			"Element with a slot='...' attribute must be a child of a component or a descendant of a custom element"
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error-3/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error-3/_config.js
index 69c2adb23c..727e0c8bda 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error-3/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error-3/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-slot-placement',
+		code: 'invalid_slot_placement',
 		message:
 			"Element with a slot='...' attribute must be a child of a component or a descendant of a custom element"
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error/_config.js b/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error/_config.js
index 69c2adb23c..727e0c8bda 100644
--- a/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/component-slot-nested-error/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-slot-placement',
+		code: 'invalid_slot_placement',
 		message:
 			"Element with a slot='...' attribute must be a child of a component or a descendant of a custom element"
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/css-global-block-combinator/_config.js b/packages/svelte/tests/compiler-errors/samples/css-global-block-combinator/_config.js
index 6a11aa63ec..77baf5a87e 100644
--- a/packages/svelte/tests/compiler-errors/samples/css-global-block-combinator/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/css-global-block-combinator/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-css-global-block-combinator',
+		code: 'invalid_css_global_block_combinator',
 		message: 'A :global {...} block cannot follow a > combinator',
 		position: [12, 21]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/css-global-block-declaration/_config.js b/packages/svelte/tests/compiler-errors/samples/css-global-block-declaration/_config.js
index 7b637ca42e..5d2a52465f 100644
--- a/packages/svelte/tests/compiler-errors/samples/css-global-block-declaration/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/css-global-block-declaration/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-css-global-block-declaration',
+		code: 'invalid_css_global_block_declaration',
 		message: 'A :global {...} block can only contain rules, not declarations',
 		position: [24, 34]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/css-global-block-modifier/_config.js b/packages/svelte/tests/compiler-errors/samples/css-global-block-modifier/_config.js
index 9e7cac667f..63b20e7e36 100644
--- a/packages/svelte/tests/compiler-errors/samples/css-global-block-modifier/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/css-global-block-modifier/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-css-global-block-modifier',
+		code: 'invalid_css_global_block_modifier',
 		message: 'A :global {...} block cannot modify an existing selector',
 		position: [14, 21]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/css-global-block-multiple/_config.js b/packages/svelte/tests/compiler-errors/samples/css-global-block-multiple/_config.js
index 8021a9c677..bb189b05f5 100644
--- a/packages/svelte/tests/compiler-errors/samples/css-global-block-multiple/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/css-global-block-multiple/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-css-global-block-list',
+		code: 'invalid_css_global_block_list',
 		message: 'A :global {...} block cannot be part of a selector list with more than one item',
 		position: [9, 31]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/css/_config.js b/packages/svelte/tests/compiler-errors/samples/css/_config.js
index 9705cde6b5..74ef4c9c6c 100644
--- a/packages/svelte/tests/compiler-errors/samples/css/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/css/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-css-identifier',
+		code: 'invalid_css_identifier',
 		message: 'Expected a valid CSS identifier',
 		position: [25, 25]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/dollar-binding-declaration/_config.js b/packages/svelte/tests/compiler-errors/samples/dollar-binding-declaration/_config.js
index a49d35d090..7141ff1efd 100644
--- a/packages/svelte/tests/compiler-errors/samples/dollar-binding-declaration/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/dollar-binding-declaration/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-dollar-binding',
+		code: 'invalid_dollar_binding',
 		message: 'The $ name is reserved, and cannot be used for variables and imports'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/dollar-binding-global-js/_config.js b/packages/svelte/tests/compiler-errors/samples/dollar-binding-global-js/_config.js
index 666b798323..ae86ca8d6b 100644
--- a/packages/svelte/tests/compiler-errors/samples/dollar-binding-global-js/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/dollar-binding-global-js/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-global',
+		code: 'illegal_global',
 		message:
-			'$ is an illegal variable name. To reference a global variable called $, use globalThis.$'
+			'`$` is an illegal variable name. To reference a global variable called `$`, use `globalThis.$`'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/dollar-binding-global/_config.js b/packages/svelte/tests/compiler-errors/samples/dollar-binding-global/_config.js
index 666b798323..ae86ca8d6b 100644
--- a/packages/svelte/tests/compiler-errors/samples/dollar-binding-global/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/dollar-binding-global/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-global',
+		code: 'illegal_global',
 		message:
-			'$ is an illegal variable name. To reference a global variable called $, use globalThis.$'
+			'`$` is an illegal variable name. To reference a global variable called `$`, use `globalThis.$`'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/dollar-binding-import/_config.js b/packages/svelte/tests/compiler-errors/samples/dollar-binding-import/_config.js
index a49d35d090..7141ff1efd 100644
--- a/packages/svelte/tests/compiler-errors/samples/dollar-binding-import/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/dollar-binding-import/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-dollar-binding',
+		code: 'invalid_dollar_binding',
 		message: 'The $ name is reserved, and cannot be used for variables and imports'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/dynamic-element-binding-invalid/_config.js b/packages/svelte/tests/compiler-errors/samples/dynamic-element-binding-invalid/_config.js
index 6934ea4c55..4bb3edc27b 100644
--- a/packages/svelte/tests/compiler-errors/samples/dynamic-element-binding-invalid/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/dynamic-element-binding-invalid/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-binding',
-		message: "'value' binding can only be used with <input>, <textarea>, <select>"
+		code: 'bind_invalid_target',
+		message: '`bind:value` can only be used with <input>, <textarea>, <select>'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/else-before-closing-2/_config.js b/packages/svelte/tests/compiler-errors/samples/else-before-closing-2/_config.js
index dc9aff145c..54ef1afa7b 100644
--- a/packages/svelte/tests/compiler-errors/samples/else-before-closing-2/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/else-before-closing-2/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'expected-token',
+		code: 'expected_token',
 		message: 'Expected token {:then ...} or {:catch ...}',
 		position: [24, 24]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/else-before-closing-3/_config.js b/packages/svelte/tests/compiler-errors/samples/else-before-closing-3/_config.js
index 80a2a136db..c052f05a18 100644
--- a/packages/svelte/tests/compiler-errors/samples/else-before-closing-3/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/else-before-closing-3/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-continuing-block-placement',
+		code: 'invalid_continuing_block_placement',
 		message:
 			'{:...} block is invalid at this position (did you forget to close the preceeding element or block?)',
 		position: [6, 6]
diff --git a/packages/svelte/tests/compiler-errors/samples/else-before-closing/_config.js b/packages/svelte/tests/compiler-errors/samples/else-before-closing/_config.js
index 87c1296f49..6883152c09 100644
--- a/packages/svelte/tests/compiler-errors/samples/else-before-closing/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/else-before-closing/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-continuing-block-placement',
+		code: 'invalid_continuing_block_placement',
 		message:
 			'{:...} block is invalid at this position (did you forget to close the preceeding element or block?)',
 		position: [18, 18]
diff --git a/packages/svelte/tests/compiler-errors/samples/else-if-before-closing-2/_config.js b/packages/svelte/tests/compiler-errors/samples/else-if-before-closing-2/_config.js
index 4b4059cf3b..d2ab9b9090 100644
--- a/packages/svelte/tests/compiler-errors/samples/else-if-before-closing-2/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/else-if-before-closing-2/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-continuing-block-placement',
+		code: 'invalid_continuing_block_placement',
 		message:
 			'{:...} block is invalid at this position (did you forget to close the preceeding element or block?)',
 		position: [17, 17]
diff --git a/packages/svelte/tests/compiler-errors/samples/else-if-before-closing/_config.js b/packages/svelte/tests/compiler-errors/samples/else-if-before-closing/_config.js
index ae20d2da8c..da19e5e806 100644
--- a/packages/svelte/tests/compiler-errors/samples/else-if-before-closing/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/else-if-before-closing/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'expected-token',
+		code: 'expected_token',
 		message: 'Expected token {:then ...} or {:catch ...}',
 		position: [26, 26]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/else-if-without-if/_config.js b/packages/svelte/tests/compiler-errors/samples/else-if-without-if/_config.js
index 04d8342f20..706e610cba 100644
--- a/packages/svelte/tests/compiler-errors/samples/else-if-without-if/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/else-if-without-if/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'expected-token',
+		code: 'expected_token',
 		message: 'Expected token {:then ...} or {:catch ...}',
 		position: [27, 27]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/empty-attribute-shorthand/_config.js b/packages/svelte/tests/compiler-errors/samples/empty-attribute-shorthand/_config.js
index 5c6855f41b..fd20583e57 100644
--- a/packages/svelte/tests/compiler-errors/samples/empty-attribute-shorthand/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/empty-attribute-shorthand/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'empty-attribute-shorthand',
+		code: 'empty_attribute_shorthand',
 		message: 'Attribute shorthand cannot be empty',
 		position: [6, 6]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/empty-classname-binding/_config.js b/packages/svelte/tests/compiler-errors/samples/empty-classname-binding/_config.js
index bd1d1d7682..087c2e55d9 100644
--- a/packages/svelte/tests/compiler-errors/samples/empty-classname-binding/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/empty-classname-binding/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'empty-directive-name',
+		code: 'empty_directive_name',
 		message: 'ClassDirective name cannot be empty',
 		position: [10, 10]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/empty-directive-name/_config.js b/packages/svelte/tests/compiler-errors/samples/empty-directive-name/_config.js
index 48a0eb32c4..22338ec818 100644
--- a/packages/svelte/tests/compiler-errors/samples/empty-directive-name/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/empty-directive-name/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'empty-directive-name',
+		code: 'empty_directive_name',
 		message: 'UseDirective name cannot be empty',
 		position: [8, 8]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/export-derived-state/_config.js b/packages/svelte/tests/compiler-errors/samples/export-derived-state/_config.js
index fd70495836..9e77a92f52 100644
--- a/packages/svelte/tests/compiler-errors/samples/export-derived-state/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/export-derived-state/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-derived-export',
+		code: 'invalid_derived_export',
 		message:
 			'Cannot export derived state from a module. To expose the current derived value, export a function returning its value',
 		position: [24, 66]
diff --git a/packages/svelte/tests/compiler-errors/samples/export-state-module/_config.js b/packages/svelte/tests/compiler-errors/samples/export-state-module/_config.js
index f1bad80670..3cc26ce501 100644
--- a/packages/svelte/tests/compiler-errors/samples/export-state-module/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/export-state-module/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-state-export',
+		code: 'invalid_state_export',
 		message:
 			"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",
 		position: [76, 114]
diff --git a/packages/svelte/tests/compiler-errors/samples/export-state/_config.js b/packages/svelte/tests/compiler-errors/samples/export-state/_config.js
index 1f7bd0f767..94d31700f2 100644
--- a/packages/svelte/tests/compiler-errors/samples/export-state/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/export-state/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-state-export',
+		code: 'invalid_state_export',
 		message:
 			"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",
 		position: [46, 86]
diff --git a/packages/svelte/tests/compiler-errors/samples/illegal-expression/_config.js b/packages/svelte/tests/compiler-errors/samples/illegal-expression/_config.js
index 887f11e882..bef5afd00d 100644
--- a/packages/svelte/tests/compiler-errors/samples/illegal-expression/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/illegal-expression/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'js-parse-error',
+		code: 'js_parse_error',
 		message: 'Assigning to rvalue',
 		position: [1, 1]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/invalid-snippet-binding/_config.js b/packages/svelte/tests/compiler-errors/samples/invalid-snippet-binding/_config.js
index a507812928..b0ee9ddfd4 100644
--- a/packages/svelte/tests/compiler-errors/samples/invalid-snippet-binding/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/invalid-snippet-binding/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-snippet-assignment',
+		code: 'invalid_snippet_assignment',
 		message: 'Cannot reassign or bind to snippet parameter'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/invalid-snippet-mutation/_config.js b/packages/svelte/tests/compiler-errors/samples/invalid-snippet-mutation/_config.js
index a507812928..b0ee9ddfd4 100644
--- a/packages/svelte/tests/compiler-errors/samples/invalid-snippet-mutation/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/invalid-snippet-mutation/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-snippet-assignment',
+		code: 'invalid_snippet_assignment',
 		message: 'Cannot reassign or bind to snippet parameter'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/legacy-no-const-assignment/_config.js b/packages/svelte/tests/compiler-errors/samples/legacy-no-const-assignment/_config.js
index f2503be0e3..247cc5b09f 100644
--- a/packages/svelte/tests/compiler-errors/samples/legacy-no-const-assignment/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/legacy-no-const-assignment/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-const-assignment',
-		message: 'Invalid assignment to const variable'
+		code: 'invalid_assignment',
+		message: 'Cannot assign to constant'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/legacy-no-const-update/_config.js b/packages/svelte/tests/compiler-errors/samples/legacy-no-const-update/_config.js
index f2503be0e3..247cc5b09f 100644
--- a/packages/svelte/tests/compiler-errors/samples/legacy-no-const-update/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/legacy-no-const-update/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-const-assignment',
-		message: 'Invalid assignment to const variable'
+		code: 'invalid_assignment',
+		message: 'Cannot assign to constant'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/multiple-styles/_config.js b/packages/svelte/tests/compiler-errors/samples/multiple-styles/_config.js
index 50cf2583af..f42fd1af86 100644
--- a/packages/svelte/tests/compiler-errors/samples/multiple-styles/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/multiple-styles/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-style-element',
-		message: 'A component can have a single top-level <style> element',
+		code: 'duplicate_style_element',
+		message: 'A component can have a single top-level `<style>` element',
 		position: [58, 58]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/options-children/_config.js b/packages/svelte/tests/compiler-errors/samples/options-children/_config.js
index d08406c499..5ec5f02752 100644
--- a/packages/svelte/tests/compiler-errors/samples/options-children/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/options-children/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-element-content',
+		code: 'invalid_element_content',
 		message: '<svelte:options> cannot have children',
 		position: [16, 16]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/raw-mustaches-whitespace/_config.js b/packages/svelte/tests/compiler-errors/samples/raw-mustaches-whitespace/_config.js
index 67d197780e..06adb4706c 100644
--- a/packages/svelte/tests/compiler-errors/samples/raw-mustaches-whitespace/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/raw-mustaches-whitespace/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'missing-whitespace',
+		code: 'missing_whitespace',
 		message: 'Expected whitespace',
 		position: [6, 6]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/render-tag-invalid-call/_config.js b/packages/svelte/tests/compiler-errors/samples/render-tag-invalid-call/_config.js
index 47bd37699c..f1380710e2 100644
--- a/packages/svelte/tests/compiler-errors/samples/render-tag-invalid-call/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/render-tag-invalid-call/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-render-call',
+		code: 'invalid_render_call',
 		message: 'Calling a snippet function using apply, bind or call is not allowed'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-before-after-update/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-before-after-update/_config.js
index d597478bb2..7b2f863d7c 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-before-after-update/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-before-after-update/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-runes-mode-import',
+		code: 'invalid_runes_mode_import',
 		message: 'beforeUpdate cannot be used in runes mode'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-duplicate-props/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-duplicate-props/_config.js
index d2a4eab786..9620704d61 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-duplicate-props/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-duplicate-props/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-props-rune',
-		message: 'Cannot use $props() more than once'
+		code: 'duplicate_props_rune',
+		message: 'Cannot use `$props()` more than once'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-export-let/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-export-let/_config.js
index 800bdbe853..50cfed6032 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-export-let/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-export-let/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-legacy-export',
+		code: 'invalid_legacy_export',
 		message: 'Cannot use `export let` in runes mode — use $props instead'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-export-named-state/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-export-named-state/_config.js
index fb1be5730b..22f2f6596a 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-export-named-state/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-export-named-state/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-state-export',
+		code: 'invalid_state_export',
 		message:
 			"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",
 		position: [28, 53]
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-invalid-each-binding/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-invalid-each-binding/_config.js
index 55eb0280ae..e60f4e86e7 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-invalid-each-binding/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-invalid-each-binding/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-each-assignment',
+		code: 'invalid_each_assignment',
 		message:
-			"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')"
+			'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`)'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-invalid-each-mutation/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-invalid-each-mutation/_config.js
index 55eb0280ae..e60f4e86e7 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-invalid-each-mutation/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-invalid-each-mutation/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-each-assignment',
+		code: 'invalid_each_assignment',
 		message:
-			"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')"
+			'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`)'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-const-assignment/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-const-assignment/_config.js
index f2503be0e3..247cc5b09f 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-const-assignment/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-const-assignment/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-const-assignment',
-		message: 'Invalid assignment to const variable'
+		code: 'invalid_assignment',
+		message: 'Cannot assign to constant'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-const-update/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-const-update/_config.js
index f2503be0e3..247cc5b09f 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-const-update/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-const-update/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-const-assignment',
-		message: 'Invalid assignment to const variable'
+		code: 'invalid_assignment',
+		message: 'Cannot assign to constant'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-assignment/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-assignment/_config.js
index 6e40da1a81..1fae570f91 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-assignment/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-assignment/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-derived-assignment',
-		message: 'Invalid assignment to derived state'
+		code: 'invalid_assignment',
+		message: 'Cannot assign to derived state'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-binding/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-binding/_config.js
index 3a27b1f9bd..b2f418e384 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-binding/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-binding/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-derived-binding',
-		message: 'Invalid binding to derived state'
+		code: 'invalid_binding',
+		message: 'Cannot bind to derived state'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-state-field-assignment/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-state-field-assignment/_config.js
index 6e40da1a81..1fae570f91 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-state-field-assignment/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-state-field-assignment/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-derived-assignment',
-		message: 'Invalid assignment to derived state'
+		code: 'invalid_assignment',
+		message: 'Cannot assign to derived state'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-state-field-update/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-state-field-update/_config.js
index 6e40da1a81..1fae570f91 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-state-field-update/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-state-field-update/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-derived-assignment',
-		message: 'Invalid assignment to derived state'
+		code: 'invalid_assignment',
+		message: 'Cannot assign to derived state'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-update/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-update/_config.js
index 6e40da1a81..1fae570f91 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-derived-update/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-derived-update/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-derived-assignment',
-		message: 'Invalid assignment to derived state'
+		code: 'invalid_assignment',
+		message: 'Cannot assign to derived state'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-no-rune-each/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-no-rune-each/_config.js
index 9089b6acca..00edfe51b3 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-no-rune-each/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-no-rune-each/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-state-location',
-		message: '$state(...) can only be used as a variable declaration initializer or a class field'
+		code: 'invalid_state_location',
+		message: '`$state(...)` can only be used as a variable declaration initializer or a class field'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-prop-export-conflict/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-prop-export-conflict/_config.js
index a6e4a4c018..cfd4f2cb67 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-prop-export-conflict/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-prop-export-conflict/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'conflicting-property-name',
+		code: 'conflicting_property_name',
 		message: 'Cannot have a property and a component export with the same name'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-bindable-args/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-bindable-args/_config.js
index 0d1d0e0709..1024076a6a 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-bindable-args/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-bindable-args/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-rune-args-length',
-		message: '$bindable can only be called with 0 or 1 arguments'
+		code: 'invalid_rune_args_length',
+		message: '`$bindable` must be called with zero or one arguments'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-bindable-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-bindable-placement/_config.js
index bc92ee9ced..76d48b43be 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-bindable-placement/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-bindable-placement/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-bindable-location',
-		message: '$bindable() can only be used inside a $props() declaration'
+		code: 'invalid_bindable_location',
+		message: '`$bindable()` can only be used inside a `$props()` declaration'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-args/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-args/_config.js
index 7a37736485..4b9ad2c572 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-args/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-args/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-rune-args-length',
-		message: '$derived can only be called with 1 argument'
+		code: 'invalid_rune_args_length',
+		message: '`$derived` must be called with exactly one argument'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-placement/_config.js
index 73c8bf1299..5bde7150ec 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-placement/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-derived-placement/_config.js
@@ -2,7 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-state-location',
-		message: '$derived(...) can only be used as a variable declaration initializer or a class field'
+		code: 'invalid_state_location',
+		message:
+			'`$derived(...)` can only be used as a variable declaration initializer or a class field'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-effect-args/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-effect-args/_config.js
index 3ebcd022a9..ed08b7682a 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-effect-args/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-effect-args/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-rune-args-length',
-		message: '$effect can only be called with 1 argument'
+		code: 'invalid_rune_args_length',
+		message: '`$effect` must be called with exactly one argument'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-effect-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-effect-placement/_config.js
index 529fe44137..b8c4ad0c05 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-effect-placement/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-effect-placement/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-effect-location',
-		message: '$effect() can only be used as an expression statement'
+		code: 'invalid_effect_location',
+		message: '`$effect()` can only be used as an expression statement'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-host-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-host-placement/_config.js
index f848528c6c..37c34a7384 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-host-placement/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-host-placement/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-host-location',
-		message: '$host() can only be used inside custom element component instances'
+		code: 'invalid_host_location',
+		message: '`$host()` can only be used inside custom element component instances'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-args/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-args/_config.js
index c37b3486bd..eb6bc22ed5 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-args/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-args/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-rune-args-length',
-		message: '$props can only be called with 0 arguments'
+		code: 'invalid_rune_args',
+		message: '`$props` cannot be called with arguments'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/_config.js
index 0067f4f986..ebf5040fff 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-props-placement/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-props-location',
+		code: 'invalid_props_location',
 		message:
-			'$props() can only be used at the top level of components as a variable declaration initializer'
+			'`$props()` can only be used at the top level of components as a variable declaration initializer'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-args/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-args/_config.js
index 2d995aa0c1..30fd430140 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-args/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-args/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-rune-args-length',
-		message: '$state can only be called with 0 or 1 arguments'
+		code: 'invalid_rune_args_length',
+		message: '`$state` must be called with zero or one arguments'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-placement/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-placement/_config.js
index 9089b6acca..00edfe51b3 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-placement/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-placement/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-state-location',
-		message: '$state(...) can only be used as a variable declaration initializer or a class field'
+		code: 'invalid_state_location',
+		message: '`$state(...)` can only be used as a variable declaration initializer or a class field'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-snapshot-args/_config.js b/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-snapshot-args/_config.js
index c701cfac7e..ab7ce7b201 100644
--- a/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-snapshot-args/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/runes-wrong-state-snapshot-args/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-rune-args-length',
-		message: '$state.snapshot can only be called with 1 argument'
+		code: 'invalid_rune_args_length',
+		message: '`$state.snapshot` must be called with exactly one argument'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/script-unclosed-eof/_config.js b/packages/svelte/tests/compiler-errors/samples/script-unclosed-eof/_config.js
index c8b496e41e..5c2c74eb54 100644
--- a/packages/svelte/tests/compiler-errors/samples/script-unclosed-eof/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/script-unclosed-eof/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'unexpected-eof',
+		code: 'unexpected_eof',
 		message: 'Unexpected end of input',
 		position: [32, 32]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/script-unclosed/_config.js b/packages/svelte/tests/compiler-errors/samples/script-unclosed/_config.js
index 30c59d6f28..04ec9db510 100644
--- a/packages/svelte/tests/compiler-errors/samples/script-unclosed/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/script-unclosed/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'unclosed-element',
-		message: '<script> was left open',
+		code: 'unclosed_element',
+		message: '`<script>` was left open',
 		position: [32, 32]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/self-reference/_config.js b/packages/svelte/tests/compiler-errors/samples/self-reference/_config.js
index 8148e18332..be27484ce6 100644
--- a/packages/svelte/tests/compiler-errors/samples/self-reference/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/self-reference/_config.js
@@ -2,9 +2,9 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-self-placement',
+		code: 'invalid_self_placement',
 		message:
-			'<svelte:self> components can only exist inside {#if} blocks, {#each} blocks, {#snippet} blocks or slots passed to components',
+			'`<svelte:self>` components can only exist inside {#if} blocks, {#each} blocks, {#snippet} blocks or slots passed to components',
 		position: [1, 1]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/slot-conflicting-with-render-tag/_config.js b/packages/svelte/tests/compiler-errors/samples/slot-conflicting-with-render-tag/_config.js
index c027d4fd5b..d85305d319 100644
--- a/packages/svelte/tests/compiler-errors/samples/slot-conflicting-with-render-tag/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/slot-conflicting-with-render-tag/_config.js
@@ -2,9 +2,9 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'conflicting-slot-usage',
+		code: 'conflicting_slot_usage',
 		message:
-			'Cannot use <slot> syntax and {@render ...} tags in the same component. Migrate towards {@render ...} tags completely.',
+			'Cannot use `<slot>` syntax and `{@render ...}` tags in the same component. Migrate towards `{@render ...}` tags completely.',
 		position: [71, 84]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/snippet-children-conflict/_config.js b/packages/svelte/tests/compiler-errors/samples/snippet-children-conflict/_config.js
index 3fd2caaeda..747c75ad3a 100644
--- a/packages/svelte/tests/compiler-errors/samples/snippet-children-conflict/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/snippet-children-conflict/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'conflicting-children-snippet',
+		code: 'conflicting_children_snippet',
 		message:
 			'Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block',
 		position: [320, 353]
diff --git a/packages/svelte/tests/compiler-errors/samples/store-autosub-context-module/_config.js b/packages/svelte/tests/compiler-errors/samples/store-autosub-context-module/_config.js
index 526d292530..5f45a792bf 100644
--- a/packages/svelte/tests/compiler-errors/samples/store-autosub-context-module/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/store-autosub-context-module/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-subscription',
-		message: 'Cannot reference store value inside <script context="module">',
+		code: 'illegal_subscription',
+		message: 'Cannot reference store value inside `<script context="module">`',
 		position: [164, 168]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/store-contextual/_config.js b/packages/svelte/tests/compiler-errors/samples/store-contextual/_config.js
index 2a7d0fa0ec..6a49672737 100644
--- a/packages/svelte/tests/compiler-errors/samples/store-contextual/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/store-contextual/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-store-subscription',
+		code: 'illegal_store_subscription',
 		message: 'Cannot subscribe to stores that are not declared at the top level of the component'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/store-global-disallowed/_config.js b/packages/svelte/tests/compiler-errors/samples/store-global-disallowed/_config.js
index 94a461f3aa..649aeffd37 100644
--- a/packages/svelte/tests/compiler-errors/samples/store-global-disallowed/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/store-global-disallowed/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-global',
+		code: 'illegal_global',
 		message:
-			'$foo is an illegal variable name. To reference a global variable called $foo, use globalThis.$foo'
+			'`$foo` is an illegal variable name. To reference a global variable called `$foo`, use `globalThis.$foo`'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/store-prevent-user-declarations/_config.js b/packages/svelte/tests/compiler-errors/samples/store-prevent-user-declarations/_config.js
index 97bc9d4c3d..d2ef4fa288 100644
--- a/packages/svelte/tests/compiler-errors/samples/store-prevent-user-declarations/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/store-prevent-user-declarations/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-dollar-prefix',
+		code: 'invalid_dollar_prefix',
 		message: 'The $ prefix is reserved, and cannot be used for variables and imports'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/store-shadow-scope-2/_config.js b/packages/svelte/tests/compiler-errors/samples/store-shadow-scope-2/_config.js
index f320abac21..85112aa728 100644
--- a/packages/svelte/tests/compiler-errors/samples/store-shadow-scope-2/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/store-shadow-scope-2/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-store-subscription',
+		code: 'illegal_store_subscription',
 		message: 'Cannot subscribe to stores that are not declared at the top level of the component',
 		position: [142, 147]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/store-shadow-scope-3/_config.js b/packages/svelte/tests/compiler-errors/samples/store-shadow-scope-3/_config.js
index 74e25f3bf1..dea59242b9 100644
--- a/packages/svelte/tests/compiler-errors/samples/store-shadow-scope-3/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/store-shadow-scope-3/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-store-subscription',
+		code: 'illegal_store_subscription',
 		message: 'Cannot subscribe to stores that are not declared at the top level of the component',
 		position: [167, 172]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/store-shadow-scope/_config.js b/packages/svelte/tests/compiler-errors/samples/store-shadow-scope/_config.js
index 2a7d0fa0ec..6a49672737 100644
--- a/packages/svelte/tests/compiler-errors/samples/store-shadow-scope/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/store-shadow-scope/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-store-subscription',
+		code: 'illegal_store_subscription',
 		message: 'Cannot subscribe to stores that are not declared at the top level of the component'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/store-template-expression-scope/_config.js b/packages/svelte/tests/compiler-errors/samples/store-template-expression-scope/_config.js
index 2a7d0fa0ec..6a49672737 100644
--- a/packages/svelte/tests/compiler-errors/samples/store-template-expression-scope/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/store-template-expression-scope/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'illegal-store-subscription',
+		code: 'illegal_store_subscription',
 		message: 'Cannot subscribe to stores that are not declared at the top level of the component'
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/style-unclosed-eof/_config.js b/packages/svelte/tests/compiler-errors/samples/style-unclosed-eof/_config.js
index 8d27a7297d..e915428ca6 100644
--- a/packages/svelte/tests/compiler-errors/samples/style-unclosed-eof/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/style-unclosed-eof/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'expected-token',
+		code: 'expected_token',
 		message: 'Expected token </style',
 		position: [31, 31]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/style-unclosed/_config.js b/packages/svelte/tests/compiler-errors/samples/style-unclosed/_config.js
index 602f196039..294867d7f5 100644
--- a/packages/svelte/tests/compiler-errors/samples/style-unclosed/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/style-unclosed/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-css-identifier',
+		code: 'invalid_css_identifier',
 		message: 'Expected a valid CSS identifier',
 		position: [9, 9]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/svelte-selfdestructive/_config.js b/packages/svelte/tests/compiler-errors/samples/svelte-selfdestructive/_config.js
index b88609ffe9..f5ff354027 100644
--- a/packages/svelte/tests/compiler-errors/samples/svelte-selfdestructive/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/svelte-selfdestructive/_config.js
@@ -2,9 +2,9 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-svelte-tag',
+		code: 'invalid_svelte_tag',
 		message:
-			'Valid <svelte:...> tag names are svelte:head, svelte:options, svelte:window, svelte:document, svelte:body, svelte:element, svelte:component, svelte:self or svelte:fragment',
+			'Valid `<svelte:...>` tag names are svelte:head, svelte:options, svelte:window, svelte:document, svelte:body, svelte:element, svelte:component, svelte:self or svelte:fragment',
 		position: [10, 10]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/then-before-closing/_config.js b/packages/svelte/tests/compiler-errors/samples/then-before-closing/_config.js
index 7c1ea02cc1..cef6538067 100644
--- a/packages/svelte/tests/compiler-errors/samples/then-before-closing/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/then-before-closing/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-continuing-block-placement',
+		code: 'invalid_continuing_block_placement',
 		message:
 			'{:...} block is invalid at this position (did you forget to close the preceeding element or block?)',
 		position: [21, 21]
diff --git a/packages/svelte/tests/compiler-errors/samples/then-without-await/_config.js b/packages/svelte/tests/compiler-errors/samples/then-without-await/_config.js
index 64c85f85c9..b24874f1b4 100644
--- a/packages/svelte/tests/compiler-errors/samples/then-without-await/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/then-without-await/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-continuing-block-placement',
+		code: 'invalid_continuing_block_placement',
 		message:
 			'{:...} block is invalid at this position (did you forget to close the preceeding element or block?)',
 		position: [1, 1]
diff --git a/packages/svelte/tests/compiler-errors/samples/unclosed-attribute-self-close-tag/_config.js b/packages/svelte/tests/compiler-errors/samples/unclosed-attribute-self-close-tag/_config.js
index 2f4ec8835f..5a33a0c237 100644
--- a/packages/svelte/tests/compiler-errors/samples/unclosed-attribute-self-close-tag/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/unclosed-attribute-self-close-tag/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'unclosed-attribute-value',
+		code: 'unclosed_attribute_value',
 		message: 'Expected closing } character',
 		position: [19, 19]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-b/_config.js b/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-b/_config.js
index e69ada8861..25dbf88c64 100644
--- a/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-b/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-b/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'unexpected-eof',
+		code: 'unexpected_eof',
 		message: 'Unexpected end of input',
 		position: [2, 2]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-c/_config.js b/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-c/_config.js
index 47a1b49f03..edaeb89e40 100644
--- a/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-c/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-c/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'unexpected-eof',
+		code: 'unexpected_eof',
 		message: 'Unexpected end of input',
 		position: [1, 1]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-d/_config.js b/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-d/_config.js
index b10de772d3..5099013e16 100644
--- a/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-d/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input-d/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'unclosed-block',
+		code: 'unclosed_block',
 		message: 'Block was left open',
 		position: [0, 1]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input/_config.js b/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input/_config.js
index 8ff85b7243..6ab0c7f716 100644
--- a/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/unexpected-end-of-input/_config.js
@@ -2,8 +2,8 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'unclosed-element',
-		message: '<div> was left open',
+		code: 'unclosed_element',
+		message: '`<div>` was left open',
 		position: [0, 1]
 	}
 });
diff --git a/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag-autoclose-2/_config.js b/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag-autoclose-2/_config.js
index e0b8622711..824db2ae2e 100644
--- a/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag-autoclose-2/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag-autoclose-2/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-closing-tag',
+		code: 'invalid_closing_tag',
 		message: '</p> attempted to close an element that was not open',
 		position: [38, 38]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag-autoclose/_config.js b/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag-autoclose/_config.js
index 38731fed64..bfd76bff4f 100644
--- a/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag-autoclose/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag-autoclose/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-closing-tag-after-autoclose',
+		code: 'invalid_closing_tag_after_autoclose',
 		message:
 			'</p> attempted to close element that was already automatically closed by <pre> (cannot nest <pre> inside <p>)',
 		position: [24, 24]
diff --git a/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag/_config.js b/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag/_config.js
index dd6995d832..6609a11e42 100644
--- a/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/unmatched-closing-tag/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-closing-tag',
+		code: 'invalid_closing_tag',
 		message: '</div> attempted to close an element that was not open',
 		position: [0, 0]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/void-closing/_config.js b/packages/svelte/tests/compiler-errors/samples/void-closing/_config.js
index 704d8c6029..360fcec971 100644
--- a/packages/svelte/tests/compiler-errors/samples/void-closing/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/void-closing/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-void-content',
+		code: 'invalid_void_content',
 		message: 'Void elements cannot have children or closing tags',
 		position: [23, 23]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/window-children/_config.js b/packages/svelte/tests/compiler-errors/samples/window-children/_config.js
index 33b57bf5f6..a788c01ad5 100644
--- a/packages/svelte/tests/compiler-errors/samples/window-children/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/window-children/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-element-content',
+		code: 'invalid_element_content',
 		message: '<svelte:window> cannot have children',
 		position: [15, 15]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/window-duplicate/_config.js b/packages/svelte/tests/compiler-errors/samples/window-duplicate/_config.js
index 9c068c0297..fed30e9475 100644
--- a/packages/svelte/tests/compiler-errors/samples/window-duplicate/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/window-duplicate/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'duplicate-svelte-element',
+		code: 'duplicate_svelte_element',
 		message: 'A component can only have one <svelte:window> element',
 		position: [17, 17]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/window-inside-block/_config.js b/packages/svelte/tests/compiler-errors/samples/window-inside-block/_config.js
index 698c3813e6..36bda11a77 100644
--- a/packages/svelte/tests/compiler-errors/samples/window-inside-block/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/window-inside-block/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-svelte-element-placement',
+		code: 'invalid_svelte_element_placement',
 		message: '<svelte:window> tags cannot be inside elements or blocks',
 		position: [11, 11]
 	}
diff --git a/packages/svelte/tests/compiler-errors/samples/window-inside-element/_config.js b/packages/svelte/tests/compiler-errors/samples/window-inside-element/_config.js
index 04aba56e54..844353ac1b 100644
--- a/packages/svelte/tests/compiler-errors/samples/window-inside-element/_config.js
+++ b/packages/svelte/tests/compiler-errors/samples/window-inside-element/_config.js
@@ -2,7 +2,7 @@ import { test } from '../../test';
 
 export default test({
 	error: {
-		code: 'invalid-svelte-element-placement',
+		code: 'invalid_svelte_element_placement',
 		message: '<svelte:window> tags cannot be inside elements or blocks',
 		position: [7, 7]
 	}
diff --git a/packages/svelte/tests/validator/samples/action-on-component/errors.json b/packages/svelte/tests/validator/samples/action-on-component/errors.json
index 6516cf9108..f190f2282f 100644
--- a/packages/svelte/tests/validator/samples/action-on-component/errors.json
+++ b/packages/svelte/tests/validator/samples/action-on-component/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-component-directive",
+		"code": "invalid_component_directive",
 		"message": "This type of directive is not valid on components",
 		"start": {
 			"line": 7,
diff --git a/packages/svelte/tests/validator/samples/animation-duplicate/errors.json b/packages/svelte/tests/validator/samples/animation-duplicate/errors.json
index 2a1ba6b5ac..03229646be 100644
--- a/packages/svelte/tests/validator/samples/animation-duplicate/errors.json
+++ b/packages/svelte/tests/validator/samples/animation-duplicate/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "duplicate-animation",
+		"code": "animation_duplicate",
 		"message": "An element can only have one 'animate' directive",
 		"start": {
 			"line": 7,
diff --git a/packages/svelte/tests/validator/samples/animation-not-in-each/errors.json b/packages/svelte/tests/validator/samples/animation-not-in-each/errors.json
index d296c8994d..2b5f73585d 100644
--- a/packages/svelte/tests/validator/samples/animation-not-in-each/errors.json
+++ b/packages/svelte/tests/validator/samples/animation-not-in-each/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-animation",
-		"message": "An element that uses the animate directive must be the immediate child of a keyed each block",
+		"code": "animation_invalid_placement",
+		"message": "An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block",
 		"start": {
 			"line": 5,
 			"column": 5
diff --git a/packages/svelte/tests/validator/samples/animation-not-in-keyed-each/errors.json b/packages/svelte/tests/validator/samples/animation-not-in-keyed-each/errors.json
index 709ad5e196..945376a1b1 100644
--- a/packages/svelte/tests/validator/samples/animation-not-in-keyed-each/errors.json
+++ b/packages/svelte/tests/validator/samples/animation-not-in-keyed-each/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-animation",
-		"message": "An element that uses the animate directive must be used inside a keyed each block. Did you forget to add a key to your each block?",
+		"code": "animation_missing_key",
+		"message": "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?",
 		"start": {
 			"line": 6,
 			"column": 6
diff --git a/packages/svelte/tests/validator/samples/animation-on-component/errors.json b/packages/svelte/tests/validator/samples/animation-on-component/errors.json
index eabf72bb02..f904517a89 100644
--- a/packages/svelte/tests/validator/samples/animation-on-component/errors.json
+++ b/packages/svelte/tests/validator/samples/animation-on-component/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-component-directive",
+		"code": "invalid_component_directive",
 		"message": "This type of directive is not valid on components",
 		"start": {
 			"line": 7,
diff --git a/packages/svelte/tests/validator/samples/animation-siblings/errors.json b/packages/svelte/tests/validator/samples/animation-siblings/errors.json
index 709f7006ce..b6412ebca4 100644
--- a/packages/svelte/tests/validator/samples/animation-siblings/errors.json
+++ b/packages/svelte/tests/validator/samples/animation-siblings/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-animation",
-		"message": "An element that uses the animate directive must be the sole child of a keyed each block",
+		"code": "animation_invalid_placement",
+		"message": "An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block",
 		"start": {
 			"line": 6,
 			"column": 6
diff --git a/packages/svelte/tests/validator/samples/assignment-to-const-2/errors.json b/packages/svelte/tests/validator/samples/assignment-to-const-2/errors.json
index 1b74f51563..e4b6b6b329 100644
--- a/packages/svelte/tests/validator/samples/assignment-to-const-2/errors.json
+++ b/packages/svelte/tests/validator/samples/assignment-to-const-2/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid assignment to const variable",
+		"code": "invalid_assignment",
+		"message": "Cannot assign to constant",
 		"start": {
 			"line": 13,
 			"column": 24
diff --git a/packages/svelte/tests/validator/samples/assignment-to-const-3/errors.json b/packages/svelte/tests/validator/samples/assignment-to-const-3/errors.json
index b00dd32495..7c92566f1f 100644
--- a/packages/svelte/tests/validator/samples/assignment-to-const-3/errors.json
+++ b/packages/svelte/tests/validator/samples/assignment-to-const-3/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid assignment to const variable",
+		"code": "invalid_assignment",
+		"message": "Cannot assign to constant",
 		"start": {
 			"line": 14,
 			"column": 3
diff --git a/packages/svelte/tests/validator/samples/assignment-to-const-4/errors.json b/packages/svelte/tests/validator/samples/assignment-to-const-4/errors.json
index 1fcfaf2406..e714e99a38 100644
--- a/packages/svelte/tests/validator/samples/assignment-to-const-4/errors.json
+++ b/packages/svelte/tests/validator/samples/assignment-to-const-4/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid assignment to const variable",
+		"code": "invalid_assignment",
+		"message": "Cannot assign to constant",
 		"start": {
 			"line": 17,
 			"column": 2
diff --git a/packages/svelte/tests/validator/samples/assignment-to-const-5/errors.json b/packages/svelte/tests/validator/samples/assignment-to-const-5/errors.json
index 9bff01645a..41002cd83e 100644
--- a/packages/svelte/tests/validator/samples/assignment-to-const-5/errors.json
+++ b/packages/svelte/tests/validator/samples/assignment-to-const-5/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid assignment to const variable",
+		"code": "invalid_assignment",
+		"message": "Cannot assign to constant",
 		"start": {
 			"line": 3,
 			"column": 1
diff --git a/packages/svelte/tests/validator/samples/assignment-to-const-7/errors.json b/packages/svelte/tests/validator/samples/assignment-to-const-7/errors.json
index 02e5503b16..01c1aefb7e 100644
--- a/packages/svelte/tests/validator/samples/assignment-to-const-7/errors.json
+++ b/packages/svelte/tests/validator/samples/assignment-to-const-7/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid assignment to const variable",
+		"code": "invalid_assignment",
+		"message": "Cannot assign to constant",
 		"start": {
 			"line": 3,
 			"column": 1
diff --git a/packages/svelte/tests/validator/samples/assignment-to-const/errors.json b/packages/svelte/tests/validator/samples/assignment-to-const/errors.json
index 88d6b728b9..6963a3737b 100644
--- a/packages/svelte/tests/validator/samples/assignment-to-const/errors.json
+++ b/packages/svelte/tests/validator/samples/assignment-to-const/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid assignment to const variable",
+		"code": "invalid_assignment",
+		"message": "Cannot assign to constant",
 		"start": {
 			"line": 16,
 			"column": 2
diff --git a/packages/svelte/tests/validator/samples/attribute-expected-equals/errors.json b/packages/svelte/tests/validator/samples/attribute-expected-equals/errors.json
index deb2331622..f3b90628ab 100644
--- a/packages/svelte/tests/validator/samples/attribute-expected-equals/errors.json
+++ b/packages/svelte/tests/validator/samples/attribute-expected-equals/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "expected-token",
+		"code": "expected_token",
 		"message": "Expected token =",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/attribute-invalid-name-2/errors.json b/packages/svelte/tests/validator/samples/attribute-invalid-name-2/errors.json
index 0e4afb3009..f99b36ff36 100644
--- a/packages/svelte/tests/validator/samples/attribute-invalid-name-2/errors.json
+++ b/packages/svelte/tests/validator/samples/attribute-invalid-name-2/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-attribute-name",
+		"code": "invalid_attribute_name",
 		"message": "'3aa' is not a valid attribute name",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/attribute-invalid-name-3/errors.json b/packages/svelte/tests/validator/samples/attribute-invalid-name-3/errors.json
index c13a5c5b90..7c49600412 100644
--- a/packages/svelte/tests/validator/samples/attribute-invalid-name-3/errors.json
+++ b/packages/svelte/tests/validator/samples/attribute-invalid-name-3/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-attribute-name",
+		"code": "invalid_attribute_name",
 		"message": "'a*a' is not a valid attribute name",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/attribute-invalid-name-4/errors.json b/packages/svelte/tests/validator/samples/attribute-invalid-name-4/errors.json
index 4cccb34b28..693c080dd1 100644
--- a/packages/svelte/tests/validator/samples/attribute-invalid-name-4/errors.json
+++ b/packages/svelte/tests/validator/samples/attribute-invalid-name-4/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-attribute-name",
+		"code": "invalid_attribute_name",
 		"message": "'-a' is not a valid attribute name",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/attribute-invalid-name-5/errors.json b/packages/svelte/tests/validator/samples/attribute-invalid-name-5/errors.json
index b99bb946ae..4a5b59bbe8 100644
--- a/packages/svelte/tests/validator/samples/attribute-invalid-name-5/errors.json
+++ b/packages/svelte/tests/validator/samples/attribute-invalid-name-5/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-attribute-name",
+		"code": "invalid_attribute_name",
 		"message": "'a;' is not a valid attribute name",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/attribute-invalid-name/errors.json b/packages/svelte/tests/validator/samples/attribute-invalid-name/errors.json
index 5b674a6f7d..6e9e2dc0f1 100644
--- a/packages/svelte/tests/validator/samples/attribute-invalid-name/errors.json
+++ b/packages/svelte/tests/validator/samples/attribute-invalid-name/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-attribute-name",
+		"code": "invalid_attribute_name",
 		"message": "'}' is not a valid attribute name",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/binding-await-catch/errors.json b/packages/svelte/tests/validator/samples/binding-await-catch/errors.json
index 8cdef47534..4da88c4576 100644
--- a/packages/svelte/tests/validator/samples/binding-await-catch/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-await-catch/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid binding to const variable ($derived values, let: directives, :then/:catch variables and @const declarations count as const)",
-		"start": { "line": 6, "column": 9 },
-		"end": { "line": 6, "column": 27 }
+		"code": "invalid_binding",
+		"message": "Cannot bind to constant",
+		"start": {
+			"line": 6,
+			"column": 9
+		},
+		"end": {
+			"line": 6,
+			"column": 27
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/binding-await-then-2/errors.json b/packages/svelte/tests/validator/samples/binding-await-then-2/errors.json
index 050d02f42b..a5c222822c 100644
--- a/packages/svelte/tests/validator/samples/binding-await-then-2/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-await-then-2/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid binding to const variable ($derived values, let: directives, :then/:catch variables and @const declarations count as const)",
-		"start": { "line": 6, "column": 9 },
-		"end": { "line": 6, "column": 19 }
+		"code": "invalid_binding",
+		"message": "Cannot bind to constant",
+		"start": {
+			"line": 6,
+			"column": 9
+		},
+		"end": {
+			"line": 6,
+			"column": 19
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/binding-await-then/errors.json b/packages/svelte/tests/validator/samples/binding-await-then/errors.json
index ec6467441e..69675cf0e7 100644
--- a/packages/svelte/tests/validator/samples/binding-await-then/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-await-then/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid binding to const variable ($derived values, let: directives, :then/:catch variables and @const declarations count as const)",
-		"start": { "line": 5, "column": 9 },
-		"end": { "line": 5, "column": 19 }
+		"code": "invalid_binding",
+		"message": "Cannot bind to constant",
+		"start": {
+			"line": 5,
+			"column": 9
+		},
+		"end": {
+			"line": 5,
+			"column": 19
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/binding-const/errors.json b/packages/svelte/tests/validator/samples/binding-const/errors.json
index cf3522eef1..d2f8b1a8b3 100644
--- a/packages/svelte/tests/validator/samples/binding-const/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-const/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid binding to const variable",
+		"code": "invalid_binding",
+		"message": "Cannot bind to constant",
 		"start": {
 			"line": 5,
 			"column": 7
diff --git a/packages/svelte/tests/validator/samples/binding-dimensions-svg/errors.json b/packages/svelte/tests/validator/samples/binding-dimensions-svg/errors.json
index b1969bfd5f..4d3819453c 100644
--- a/packages/svelte/tests/validator/samples/binding-dimensions-svg/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-dimensions-svg/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-binding",
-		"message": "'offsetWidth' binding can only be used with non-<svg> elements. Use 'clientWidth' for <svg> instead",
+		"code": "bind_invalid_target",
+		"message": "`bind:offsetWidth` can only be used with non-<svg> elements. Use 'clientWidth' for <svg> instead",
 		"start": {
 			"line": 5,
 			"column": 5
diff --git a/packages/svelte/tests/validator/samples/binding-input-checked/errors.json b/packages/svelte/tests/validator/samples/binding-input-checked/errors.json
index 50abdd6df9..574b25e06f 100644
--- a/packages/svelte/tests/validator/samples/binding-input-checked/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-input-checked/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-binding",
-		"message": "'checked' binding can only be used with <input type=\"checkbox\">",
+		"code": "bind_invalid_target",
+		"message": "`bind:checked` can only be used with <input type=\"checkbox\">",
 		"start": {
 			"line": 5,
 			"column": 7
diff --git a/packages/svelte/tests/validator/samples/binding-input-type-boolean/errors.json b/packages/svelte/tests/validator/samples/binding-input-type-boolean/errors.json
index 6a4807a7b1..87a3f6f8ea 100644
--- a/packages/svelte/tests/validator/samples/binding-input-type-boolean/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-input-type-boolean/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-type-attribute",
+		"code": "invalid_type_attribute",
 		"message": "'type' attribute must be a static text value if input uses two-way binding",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/binding-invalid-foreign-namespace/errors.json b/packages/svelte/tests/validator/samples/binding-invalid-foreign-namespace/errors.json
index 7b6d4f51db..de997e5394 100644
--- a/packages/svelte/tests/validator/samples/binding-invalid-foreign-namespace/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-invalid-foreign-namespace/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-binding",
-		"message": "'value' is not a valid binding. Foreign elements only support bind:this",
+		"code": "bind_invalid_detailed",
+		"message": "`bind:value` is not a valid binding. Foreign elements only support `bind:this`",
 		"start": {
 			"line": 6,
 			"column": 7
diff --git a/packages/svelte/tests/validator/samples/binding-invalid-on-element-2/errors.json b/packages/svelte/tests/validator/samples/binding-invalid-on-element-2/errors.json
index c379a94d5a..92111a4ec2 100644
--- a/packages/svelte/tests/validator/samples/binding-invalid-on-element-2/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-invalid-on-element-2/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-binding",
-		"message": "'open' binding can only be used with <details>",
+		"code": "bind_invalid_target",
+		"message": "`bind:open` can only be used with <details>",
 		"start": {
 			"line": 5,
 			"column": 5
diff --git a/packages/svelte/tests/validator/samples/binding-invalid-on-element/errors.json b/packages/svelte/tests/validator/samples/binding-invalid-on-element/errors.json
index 9898ad8fa5..6626afc1d0 100644
--- a/packages/svelte/tests/validator/samples/binding-invalid-on-element/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-invalid-on-element/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-binding",
-		"message": "'value' binding can only be used with <input>, <textarea>, <select>",
+		"code": "bind_invalid_target",
+		"message": "`bind:value` can only be used with <input>, <textarea>, <select>",
 		"start": {
 			"line": 5,
 			"column": 5
diff --git a/packages/svelte/tests/validator/samples/binding-invalid-value-global/errors.json b/packages/svelte/tests/validator/samples/binding-invalid-value-global/errors.json
index cff83b012e..82e86887bd 100644
--- a/packages/svelte/tests/validator/samples/binding-invalid-value-global/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-invalid-value-global/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-binding-value",
+		"code": "invalid_binding_value",
 		"message": "Can only bind to state or props",
 		"start": {
 			"line": 4,
diff --git a/packages/svelte/tests/validator/samples/binding-invalid-value/errors.json b/packages/svelte/tests/validator/samples/binding-invalid-value/errors.json
index a6e53e4e36..34026c52ac 100644
--- a/packages/svelte/tests/validator/samples/binding-invalid-value/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-invalid-value/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-binding-value",
+		"code": "invalid_binding_value",
 		"message": "Can only bind to state or props",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/binding-invalid/errors.json b/packages/svelte/tests/validator/samples/binding-invalid/errors.json
index fdd0ada258..9e0e455eaf 100644
--- a/packages/svelte/tests/validator/samples/binding-invalid/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-invalid/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-binding",
-		"message": "'whatever' is not a valid binding",
+		"code": "bind_invalid",
+		"message": "`bind:whatever` is not a valid binding",
 		"start": {
 			"line": 5,
 			"column": 5
diff --git a/packages/svelte/tests/validator/samples/binding-let/errors.json b/packages/svelte/tests/validator/samples/binding-let/errors.json
index c6c734cf91..88e038bba5 100644
--- a/packages/svelte/tests/validator/samples/binding-let/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-let/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid binding to const variable ($derived values, let: directives, :then/:catch variables and @const declarations count as const)",
+		"code": "invalid_binding",
+		"message": "Cannot bind to constant",
 		"start": {
 			"line": 6,
 			"column": 8
diff --git a/packages/svelte/tests/validator/samples/binding-select-multiple-dynamic/errors.json b/packages/svelte/tests/validator/samples/binding-select-multiple-dynamic/errors.json
index 95ab7f91d4..b280929333 100644
--- a/packages/svelte/tests/validator/samples/binding-select-multiple-dynamic/errors.json
+++ b/packages/svelte/tests/validator/samples/binding-select-multiple-dynamic/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-multiple-attribute",
+		"code": "invalid_multiple_attribute",
 		"message": "'multiple' attribute must be static if select uses two-way binding",
 		"start": {
 			"line": 6,
diff --git a/packages/svelte/tests/validator/samples/component-event-modifiers-invalid/errors.json b/packages/svelte/tests/validator/samples/component-event-modifiers-invalid/errors.json
index 3edd0059a3..14288a1385 100644
--- a/packages/svelte/tests/validator/samples/component-event-modifiers-invalid/errors.json
+++ b/packages/svelte/tests/validator/samples/component-event-modifiers-invalid/errors.json
@@ -1,7 +1,7 @@
 [
 	{
 		"message": "Event modifiers other than 'once' can only be used on DOM elements",
-		"code": "invalid-event-modifier",
+		"code": "invalid_component_event_modifier",
 		"start": {
 			"line": 6,
 			"column": 8
diff --git a/packages/svelte/tests/validator/samples/component-invalid-style-directive/errors.json b/packages/svelte/tests/validator/samples/component-invalid-style-directive/errors.json
index 6c37a888ff..3eeb050cdb 100644
--- a/packages/svelte/tests/validator/samples/component-invalid-style-directive/errors.json
+++ b/packages/svelte/tests/validator/samples/component-invalid-style-directive/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-component-directive",
+		"code": "invalid_component_directive",
 		"message": "This type of directive is not valid on components",
-		"start": { "line": 7, "column": 19 },
-		"end": { "line": 7, "column": 36 }
+		"start": {
+			"line": 7,
+			"column": 19
+		},
+		"end": {
+			"line": 7,
+			"column": 36
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/component-slot-default-reserved/errors.json b/packages/svelte/tests/validator/samples/component-slot-default-reserved/errors.json
index 5347d4737f..190c4d81a2 100644
--- a/packages/svelte/tests/validator/samples/component-slot-default-reserved/errors.json
+++ b/packages/svelte/tests/validator/samples/component-slot-default-reserved/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-slot-name",
-		"message": "default is a reserved word — it cannot be used as a slot name",
+		"code": "invalid_slot_name_default",
+		"message": "`default` is a reserved word — it cannot be used as a slot name",
 		"start": {
 			"line": 1,
 			"column": 6
diff --git a/packages/svelte/tests/validator/samples/component-slot-dynamic-attribute/errors.json b/packages/svelte/tests/validator/samples/component-slot-dynamic-attribute/errors.json
index 9194e8aa9b..238bd48d90 100644
--- a/packages/svelte/tests/validator/samples/component-slot-dynamic-attribute/errors.json
+++ b/packages/svelte/tests/validator/samples/component-slot-dynamic-attribute/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-slot-attribute",
+		"code": "invalid_slot_attribute",
 		"message": "slot attribute must be a static value",
 		"start": {
 			"line": 6,
diff --git a/packages/svelte/tests/validator/samples/component-slot-dynamic/errors.json b/packages/svelte/tests/validator/samples/component-slot-dynamic/errors.json
index 963cb1f40d..0c08ef2dad 100644
--- a/packages/svelte/tests/validator/samples/component-slot-dynamic/errors.json
+++ b/packages/svelte/tests/validator/samples/component-slot-dynamic/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-slot-name",
+		"code": "invalid_slot_name",
 		"message": "slot attribute must be a static value",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/component-slotted-custom-element-2/errors.json b/packages/svelte/tests/validator/samples/component-slotted-custom-element-2/errors.json
index da10838a69..63960b846b 100644
--- a/packages/svelte/tests/validator/samples/component-slotted-custom-element-2/errors.json
+++ b/packages/svelte/tests/validator/samples/component-slotted-custom-element-2/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-slot-placement",
+		"code": "invalid_slot_placement",
 		"message": "Element with a slot='...' attribute must be a child of a component or a descendant of a custom element",
-		"start": { "line": 10, "column": 9 },
-		"end": { "line": 10, "column": 19 }
+		"start": {
+			"line": 10,
+			"column": 9
+		},
+		"end": {
+			"line": 10,
+			"column": 19
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/component-slotted-each-block/errors.json b/packages/svelte/tests/validator/samples/component-slotted-each-block/errors.json
index 12d2407540..b04ef9e4aa 100644
--- a/packages/svelte/tests/validator/samples/component-slotted-each-block/errors.json
+++ b/packages/svelte/tests/validator/samples/component-slotted-each-block/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-slot-placement",
+		"code": "invalid_slot_placement",
 		"message": "Element with a slot='...' attribute must be a child of a component or a descendant of a custom element",
 		"start": {
 			"line": 7,
diff --git a/packages/svelte/tests/validator/samples/component-slotted-if-block/errors.json b/packages/svelte/tests/validator/samples/component-slotted-if-block/errors.json
index 12d2407540..b04ef9e4aa 100644
--- a/packages/svelte/tests/validator/samples/component-slotted-if-block/errors.json
+++ b/packages/svelte/tests/validator/samples/component-slotted-if-block/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-slot-placement",
+		"code": "invalid_slot_placement",
 		"message": "Element with a slot='...' attribute must be a child of a component or a descendant of a custom element",
 		"start": {
 			"line": 7,
diff --git a/packages/svelte/tests/validator/samples/const-tag-conflict-1/errors.json b/packages/svelte/tests/validator/samples/const-tag-conflict-1/errors.json
index 78beca08c7..07c6cbadca 100644
--- a/packages/svelte/tests/validator/samples/const-tag-conflict-1/errors.json
+++ b/packages/svelte/tests/validator/samples/const-tag-conflict-1/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "duplicate-declaration",
-		"message": "'a' has already been declared",
-		"start": { "line": 7, "column": 10 },
-		"end": { "line": 7, "column": 11 }
+		"code": "duplicate_declaration",
+		"message": "`a` has already been declared",
+		"start": {
+			"line": 7,
+			"column": 10
+		},
+		"end": {
+			"line": 7,
+			"column": 11
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/const-tag-conflict-2/errors.json b/packages/svelte/tests/validator/samples/const-tag-conflict-2/errors.json
index dc3c1322c7..543f2a0217 100644
--- a/packages/svelte/tests/validator/samples/const-tag-conflict-2/errors.json
+++ b/packages/svelte/tests/validator/samples/const-tag-conflict-2/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "duplicate-declaration",
-		"message": "'item' has already been declared",
-		"start": { "line": 6, "column": 10 },
-		"end": { "line": 6, "column": 14 }
+		"code": "duplicate_declaration",
+		"message": "`item` has already been declared",
+		"start": {
+			"line": 6,
+			"column": 10
+		},
+		"end": {
+			"line": 6,
+			"column": 14
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/const-tag-placement-1/errors.json b/packages/svelte/tests/validator/samples/const-tag-placement-1/errors.json
index 66ff86663f..4db0868c16 100644
--- a/packages/svelte/tests/validator/samples/const-tag-placement-1/errors.json
+++ b/packages/svelte/tests/validator/samples/const-tag-placement-1/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-const-placement",
+		"code": "invalid_const_placement",
 		"message": "{@const} must be the immediate child of {#snippet}, {#if}, {:else if}, {:else}, {#each}, {:then}, {:catch}, <svelte:fragment> or <Component>",
-		"start": { "line": 5, "column": 0 },
-		"end": { "line": 5, "column": 18 }
+		"start": {
+			"line": 5,
+			"column": 0
+		},
+		"end": {
+			"line": 5,
+			"column": 18
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/const-tag-placement-2/errors.json b/packages/svelte/tests/validator/samples/const-tag-placement-2/errors.json
index 6c14fdbaf7..33b24f369e 100644
--- a/packages/svelte/tests/validator/samples/const-tag-placement-2/errors.json
+++ b/packages/svelte/tests/validator/samples/const-tag-placement-2/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-const-placement",
+		"code": "invalid_const_placement",
 		"message": "{@const} must be the immediate child of {#snippet}, {#if}, {:else if}, {:else}, {#each}, {:then}, {:catch}, <svelte:fragment> or <Component>",
-		"start": { "line": 7, "column": 4 },
-		"end": { "line": 7, "column": 18 }
+		"start": {
+			"line": 7,
+			"column": 4
+		},
+		"end": {
+			"line": 7,
+			"column": 18
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/const-tag-readonly-1/errors.json b/packages/svelte/tests/validator/samples/const-tag-readonly-1/errors.json
index abe738f6cf..42f9deb4df 100644
--- a/packages/svelte/tests/validator/samples/const-tag-readonly-1/errors.json
+++ b/packages/svelte/tests/validator/samples/const-tag-readonly-1/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid assignment to const variable ($derived values, let: directives, :then/:catch variables and @const declarations count as const)",
-		"start": { "line": 7, "column": 26 },
-		"end": { "line": 7, "column": 30 }
+		"code": "invalid_assignment",
+		"message": "Cannot assign to constant",
+		"start": {
+			"line": 7,
+			"column": 26
+		},
+		"end": {
+			"line": 7,
+			"column": 30
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/const-tag-readonly-2/errors.json b/packages/svelte/tests/validator/samples/const-tag-readonly-2/errors.json
index a8c60a8b56..9f0d1d51e8 100644
--- a/packages/svelte/tests/validator/samples/const-tag-readonly-2/errors.json
+++ b/packages/svelte/tests/validator/samples/const-tag-readonly-2/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-const-assignment",
-		"message": "Invalid binding to const variable ($derived values, let: directives, :then/:catch variables and @const declarations count as const)",
-		"start": { "line": 7, "column": 9 },
-		"end": { "line": 7, "column": 23 }
+		"code": "invalid_binding",
+		"message": "Cannot bind to constant",
+		"start": {
+			"line": 7,
+			"column": 9
+		},
+		"end": {
+			"line": 7,
+			"column": 23
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/contenteditable-dynamic/errors.json b/packages/svelte/tests/validator/samples/contenteditable-dynamic/errors.json
index 27cc3e98c7..285a6f921d 100644
--- a/packages/svelte/tests/validator/samples/contenteditable-dynamic/errors.json
+++ b/packages/svelte/tests/validator/samples/contenteditable-dynamic/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "dynamic-contenteditable-attribute",
+		"code": "dynamic_contenteditable_attribute",
 		"message": "'contenteditable' attribute cannot be dynamic if element uses two-way binding",
 		"start": {
 			"line": 11,
diff --git a/packages/svelte/tests/validator/samples/contenteditable-missing/errors.json b/packages/svelte/tests/validator/samples/contenteditable-missing/errors.json
index 24a072dac8..616c45021b 100644
--- a/packages/svelte/tests/validator/samples/contenteditable-missing/errors.json
+++ b/packages/svelte/tests/validator/samples/contenteditable-missing/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "missing-contenteditable-attribute",
+		"code": "missing_contenteditable_attribute",
 		"message": "'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings",
 		"start": {
 			"line": 4,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-1/errors.json b/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-1/errors.json
index d49bf7437a..eccbf62094 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-1/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-1/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-selector",
+		"code": "invalid_css_selector",
 		"message": "Invalid selector",
 		"start": {
 			"line": 10,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-2/errors.json b/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-2/errors.json
index 2fdf3e96d1..37cfb99c87 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-2/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-2/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-selector",
+		"code": "invalid_css_selector",
 		"message": "Invalid selector",
 		"start": {
 			"line": 8,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-3/errors.json b/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-3/errors.json
index b355260623..74fd26a692 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-3/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-3/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-selector",
+		"code": "invalid_css_selector",
 		"message": "Invalid selector",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-4/errors.json b/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-4/errors.json
index aab0a130c7..24f83fee73 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-4/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-combinator-selector-4/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-selector",
+		"code": "invalid_css_selector",
 		"message": "Invalid selector",
 		"start": {
 			"line": 4,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-placement-2/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-placement-2/errors.json
index 1d359c01b3..1a11759e43 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-placement-2/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-placement-2/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-placement",
+		"code": "invalid_css_global_placement",
 		"message": ":global(...) can be at the start or end of a selector sequence, but not in the middle",
 		"start": {
 			"line": 8,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-placement-3/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-placement-3/errors.json
index 53e24d8d81..14fe638188 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-placement-3/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-placement-3/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-placement",
+		"code": "invalid_css_global_placement",
 		"message": ":global(...) can be at the start or end of a selector sequence, but not in the middle",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-placement-4/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-placement-4/errors.json
index fcc96361dd..539d91fb4d 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-placement-4/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-placement-4/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector-list",
+		"code": "invalid_css_global_selector_list",
 		"message": ":global(...) must not contain type or universal selectors when used in a compound selector",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-placement-5/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-placement-5/errors.json
index fbbdefb60e..a3a6a13b77 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-placement-5/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-placement-5/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector-list",
+		"code": "invalid_css_global_selector_list",
 		"message": ":global(...) must not contain type or universal selectors when used in a compound selector",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-placement-6/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-placement-6/errors.json
index 2b03fa8c2b..008a8ec266 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-placement-6/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-placement-6/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector-list",
+		"code": "invalid_css_global_selector_list",
 		"message": ":global(...) must not contain type or universal selectors when used in a compound selector",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-placement/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-placement/errors.json
index 7ba32a53fb..a2c76f2366 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-placement/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-placement/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-placement",
+		"code": "invalid_css_global_placement",
 		"message": ":global(...) can be at the start or end of a selector sequence, but not in the middle",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-selector-2/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-selector-2/errors.json
index 36b3ec4753..e6952aca16 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-selector-2/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-selector-2/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector",
+		"code": "invalid_css_global_selector",
 		"message": ":global(...) must contain exactly one selector",
 		"start": {
 			"line": 11,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-selector-3/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-selector-3/errors.json
index f4a75dcb17..5eaaee69d3 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-selector-3/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-selector-3/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector",
+		"code": "invalid_css_global_selector",
 		"message": ":global(...) must contain exactly one selector",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-selector-4/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-selector-4/errors.json
index a6ae2d595b..d3f84026d6 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-selector-4/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-selector-4/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector",
+		"code": "invalid_css_global_selector",
 		"message": ":global(...) must contain exactly one selector",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-selector-5/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-selector-5/errors.json
index 5ac729aa23..06ad62ef10 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-selector-5/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-selector-5/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector",
+		"code": "invalid_css_global_selector",
 		"message": ":global(...) must contain exactly one selector",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-selector-6/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-selector-6/errors.json
index 5ac729aa23..06ad62ef10 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-selector-6/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-selector-6/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector",
+		"code": "invalid_css_global_selector",
 		"message": ":global(...) must contain exactly one selector",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-selector-list/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-selector-list/errors.json
index 25399f6369..41fc6235e2 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-selector-list/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-selector-list/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector-list",
+		"code": "invalid_css_global_selector_list",
 		"message": ":global(...) must not contain type or universal selectors when used in a compound selector",
 		"start": {
 			"line": 20,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-global-selector/errors.json b/packages/svelte/tests/validator/samples/css-invalid-global-selector/errors.json
index 40bae7d4d7..50dfec051b 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-global-selector/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-global-selector/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-global-selector",
+		"code": "invalid_css_global_selector",
 		"message": ":global(...) must contain exactly one selector",
 		"start": {
 			"line": 11,
diff --git a/packages/svelte/tests/validator/samples/css-invalid-type-selector-placement/errors.json b/packages/svelte/tests/validator/samples/css-invalid-type-selector-placement/errors.json
index f58f92d6ee..d5a2602fb6 100644
--- a/packages/svelte/tests/validator/samples/css-invalid-type-selector-placement/errors.json
+++ b/packages/svelte/tests/validator/samples/css-invalid-type-selector-placement/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-type-selector-placement",
+		"code": "invalid_css_type_selector_placement",
 		"message": ":global(...) must not be followed with a type selector",
 		"start": {
 			"line": 17,
diff --git a/packages/svelte/tests/validator/samples/css-mismatched-quotes/errors.json b/packages/svelte/tests/validator/samples/css-mismatched-quotes/errors.json
index 6919f50ce9..cf5ade9b0e 100644
--- a/packages/svelte/tests/validator/samples/css-mismatched-quotes/errors.json
+++ b/packages/svelte/tests/validator/samples/css-mismatched-quotes/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "unexpected-eof",
+		"code": "unexpected_eof",
 		"message": "Unexpected end of input",
 		"start": {
 			"line": 7,
diff --git a/packages/svelte/tests/validator/samples/debug-invalid-args/errors.json b/packages/svelte/tests/validator/samples/debug-invalid-args/errors.json
index b21af2c438..40d459912c 100644
--- a/packages/svelte/tests/validator/samples/debug-invalid-args/errors.json
+++ b/packages/svelte/tests/validator/samples/debug-invalid-args/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-debug",
+		"code": "invalid_debug",
 		"message": "{@debug ...} arguments must be identifiers, not arbitrary expressions",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/default-export-anonymous-class/errors.json b/packages/svelte/tests/validator/samples/default-export-anonymous-class/errors.json
index 064c5a4f5a..4615556188 100644
--- a/packages/svelte/tests/validator/samples/default-export-anonymous-class/errors.json
+++ b/packages/svelte/tests/validator/samples/default-export-anonymous-class/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "default-export",
+		"code": "default_export",
 		"message": "A component cannot have a default export",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/default-export-anonymous-function/errors.json b/packages/svelte/tests/validator/samples/default-export-anonymous-function/errors.json
index 7e20c7c9d4..652aff0e54 100644
--- a/packages/svelte/tests/validator/samples/default-export-anonymous-function/errors.json
+++ b/packages/svelte/tests/validator/samples/default-export-anonymous-function/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "default-export",
+		"code": "default_export",
 		"message": "A component cannot have a default export",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/default-export/errors.json b/packages/svelte/tests/validator/samples/default-export/errors.json
index 6131408037..5b786d2222 100644
--- a/packages/svelte/tests/validator/samples/default-export/errors.json
+++ b/packages/svelte/tests/validator/samples/default-export/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "default-export",
+		"code": "default_export",
 		"message": "A component cannot have a default export",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/directive-non-expression/errors.json b/packages/svelte/tests/validator/samples/directive-non-expression/errors.json
index 4d36ab28b3..f7a825454e 100644
--- a/packages/svelte/tests/validator/samples/directive-non-expression/errors.json
+++ b/packages/svelte/tests/validator/samples/directive-non-expression/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-directive-value",
+		"code": "invalid_directive_value",
 		"message": "Directive value must be a JavaScript expression enclosed in curly braces",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/dollar-dollar-global-in-markup/errors.json b/packages/svelte/tests/validator/samples/dollar-dollar-global-in-markup/errors.json
index 5624217e87..630f8c5ea2 100644
--- a/packages/svelte/tests/validator/samples/dollar-dollar-global-in-markup/errors.json
+++ b/packages/svelte/tests/validator/samples/dollar-dollar-global-in-markup/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "illegal-global",
-		"message": "$$billsyall is an illegal variable name. To reference a global variable called $$billsyall, use globalThis.$$billsyall",
+		"code": "illegal_global",
+		"message": "`$$billsyall` is an illegal variable name. To reference a global variable called `$$billsyall`, use `globalThis.$$billsyall`",
 		"start": {
 			"line": 1,
 			"column": 1
diff --git a/packages/svelte/tests/validator/samples/dollar-dollar-global-in-script/errors.json b/packages/svelte/tests/validator/samples/dollar-dollar-global-in-script/errors.json
index fac768b195..5876bcae80 100644
--- a/packages/svelte/tests/validator/samples/dollar-dollar-global-in-script/errors.json
+++ b/packages/svelte/tests/validator/samples/dollar-dollar-global-in-script/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "illegal-global",
-		"message": "$$billsyall is an illegal variable name. To reference a global variable called $$billsyall, use globalThis.$$billsyall",
+		"code": "illegal_global",
+		"message": "`$$billsyall` is an illegal variable name. To reference a global variable called `$$billsyall`, use `globalThis.$$billsyall`",
 		"start": {
 			"line": 2,
 			"column": 1
diff --git a/packages/svelte/tests/validator/samples/dollar-global-in-markup/errors.json b/packages/svelte/tests/validator/samples/dollar-global-in-markup/errors.json
index 847dacbca8..1623518ca0 100644
--- a/packages/svelte/tests/validator/samples/dollar-global-in-markup/errors.json
+++ b/packages/svelte/tests/validator/samples/dollar-global-in-markup/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "illegal-global",
-		"message": "$ is an illegal variable name. To reference a global variable called $, use globalThis.$",
+		"code": "illegal_global",
+		"message": "`$` is an illegal variable name. To reference a global variable called `$`, use `globalThis.$`",
 		"start": {
 			"line": 1,
 			"column": 1
diff --git a/packages/svelte/tests/validator/samples/dollar-global-in-script/errors.json b/packages/svelte/tests/validator/samples/dollar-global-in-script/errors.json
index b924a535d8..5d33dc3d83 100644
--- a/packages/svelte/tests/validator/samples/dollar-global-in-script/errors.json
+++ b/packages/svelte/tests/validator/samples/dollar-global-in-script/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "illegal-global",
-		"message": "$ is an illegal variable name. To reference a global variable called $, use globalThis.$",
+		"code": "illegal_global",
+		"message": "`$` is an illegal variable name. To reference a global variable called `$`, use `globalThis.$`",
 		"start": {
 			"line": 2,
 			"column": 1
diff --git a/packages/svelte/tests/validator/samples/dynamic-element-invalid-tag/errors.json b/packages/svelte/tests/validator/samples/dynamic-element-invalid-tag/errors.json
index 752d26e1b3..ccd34029d2 100644
--- a/packages/svelte/tests/validator/samples/dynamic-element-invalid-tag/errors.json
+++ b/packages/svelte/tests/validator/samples/dynamic-element-invalid-tag/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-svelte-element-definition",
+		"code": "invalid_svelte_element_definition",
 		"message": "Invalid element definition — must be an {expression}",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/dynamic-element-missing-tag/errors.json b/packages/svelte/tests/validator/samples/dynamic-element-missing-tag/errors.json
index 58c8af5c66..d31bd1964c 100644
--- a/packages/svelte/tests/validator/samples/dynamic-element-missing-tag/errors.json
+++ b/packages/svelte/tests/validator/samples/dynamic-element-missing-tag/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "missing-svelte-element-definition",
-		"message": "<svelte:element> must have a 'this' attribute",
+		"code": "missing_svelte_element_definition",
+		"message": "`<svelte:element>` must have a 'this' attribute",
 		"start": {
 			"line": 2,
 			"column": 1
diff --git a/packages/svelte/tests/validator/samples/dynamic-element-this/errors.json b/packages/svelte/tests/validator/samples/dynamic-element-this/errors.json
index 4efad529ff..78ee8835be 100644
--- a/packages/svelte/tests/validator/samples/dynamic-element-this/errors.json
+++ b/packages/svelte/tests/validator/samples/dynamic-element-this/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "unexpected-reserved-word",
+		"code": "unexpected_reserved_word",
 		"message": "'this' is a reserved word in JavaScript and cannot be used here",
 		"start": {
 			"line": 2,
diff --git a/packages/svelte/tests/validator/samples/each-block-destructured-object-rest-comma-after/errors.json b/packages/svelte/tests/validator/samples/each-block-destructured-object-rest-comma-after/errors.json
index 13c3d150db..62494b230e 100644
--- a/packages/svelte/tests/validator/samples/each-block-destructured-object-rest-comma-after/errors.json
+++ b/packages/svelte/tests/validator/samples/each-block-destructured-object-rest-comma-after/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "js-parse-error",
+		"code": "js_parse_error",
 		"message": "Comma is not permitted after the rest element",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/each-block-invalid-context-destructured-object/errors.json b/packages/svelte/tests/validator/samples/each-block-invalid-context-destructured-object/errors.json
index 3cb3bbe0db..7800f62247 100644
--- a/packages/svelte/tests/validator/samples/each-block-invalid-context-destructured-object/errors.json
+++ b/packages/svelte/tests/validator/samples/each-block-invalid-context-destructured-object/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "js-parse-error",
+		"code": "js_parse_error",
 		"message": "Unexpected keyword 'case'",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/each-block-invalid-context-destructured/errors.json b/packages/svelte/tests/validator/samples/each-block-invalid-context-destructured/errors.json
index 888bc761ac..42c0eb3883 100644
--- a/packages/svelte/tests/validator/samples/each-block-invalid-context-destructured/errors.json
+++ b/packages/svelte/tests/validator/samples/each-block-invalid-context-destructured/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "js-parse-error",
+		"code": "js_parse_error",
 		"message": "Unexpected token",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/each-block-invalid-context/errors.json b/packages/svelte/tests/validator/samples/each-block-invalid-context/errors.json
index 72c68836a3..7b6d28004b 100644
--- a/packages/svelte/tests/validator/samples/each-block-invalid-context/errors.json
+++ b/packages/svelte/tests/validator/samples/each-block-invalid-context/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "unexpected-reserved-word",
+		"code": "unexpected_reserved_word",
 		"message": "'case' is a reserved word in JavaScript and cannot be used here",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/event-attribute/errors.json b/packages/svelte/tests/validator/samples/event-attribute/errors.json
index 28a8f9f11a..7204ea671b 100644
--- a/packages/svelte/tests/validator/samples/event-attribute/errors.json
+++ b/packages/svelte/tests/validator/samples/event-attribute/errors.json
@@ -1,7 +1,7 @@
 [
 	{
 		"message": "Event attribute must be a JavaScript expression, not a string",
-		"code": "invalid-event-attribute-value",
+		"code": "invalid_event_attribute_value",
 		"start": {
 			"line": 4,
 			"column": 8
diff --git a/packages/svelte/tests/validator/samples/event-modifiers-invalid-nonpassive/errors.json b/packages/svelte/tests/validator/samples/event-modifiers-invalid-nonpassive/errors.json
index 0230959777..c53951cb67 100644
--- a/packages/svelte/tests/validator/samples/event-modifiers-invalid-nonpassive/errors.json
+++ b/packages/svelte/tests/validator/samples/event-modifiers-invalid-nonpassive/errors.json
@@ -1,7 +1,7 @@
 [
 	{
 		"message": "The 'passive' and 'nonpassive' modifiers cannot be used together",
-		"code": "invalid-event-modifier-combination",
+		"code": "invalid_event_modifier_combination",
 		"start": {
 			"line": 1,
 			"column": 5
diff --git a/packages/svelte/tests/validator/samples/event-modifiers-invalid-passive/errors.json b/packages/svelte/tests/validator/samples/event-modifiers-invalid-passive/errors.json
index db8289791a..d1def4dcb3 100644
--- a/packages/svelte/tests/validator/samples/event-modifiers-invalid-passive/errors.json
+++ b/packages/svelte/tests/validator/samples/event-modifiers-invalid-passive/errors.json
@@ -1,7 +1,7 @@
 [
 	{
 		"message": "The 'passive' and 'preventDefault' modifiers cannot be used together",
-		"code": "invalid-event-modifier-combination",
+		"code": "invalid_event_modifier_combination",
 		"start": {
 			"line": 1,
 			"column": 5
diff --git a/packages/svelte/tests/validator/samples/event-modifiers-invalid/errors.json b/packages/svelte/tests/validator/samples/event-modifiers-invalid/errors.json
index b398cea5e4..178a5b5543 100644
--- a/packages/svelte/tests/validator/samples/event-modifiers-invalid/errors.json
+++ b/packages/svelte/tests/validator/samples/event-modifiers-invalid/errors.json
@@ -1,7 +1,7 @@
 [
 	{
 		"message": "Valid event modifiers are preventDefault, stopPropagation, stopImmediatePropagation, capture, once, passive, nonpassive, self or trusted",
-		"code": "invalid-event-modifier",
+		"code": "invalid_event_modifier",
 		"start": {
 			"line": 1,
 			"column": 8
diff --git a/packages/svelte/tests/validator/samples/html-block-in-attribute/errors.json b/packages/svelte/tests/validator/samples/html-block-in-attribute/errors.json
index 6c7237f030..5eedfb8971 100644
--- a/packages/svelte/tests/validator/samples/html-block-in-attribute/errors.json
+++ b/packages/svelte/tests/validator/samples/html-block-in-attribute/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-tag-placement",
+		"code": "invalid_tag_placement",
 		"message": "{@html ...} tag cannot be in attribute value",
-		"start": { "line": 1, "column": 12 },
-		"end": { "line": 1, "column": 12 }
+		"start": {
+			"line": 1,
+			"column": 12
+		},
+		"end": {
+			"line": 1,
+			"column": 12
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/html-block-in-textarea/errors.json b/packages/svelte/tests/validator/samples/html-block-in-textarea/errors.json
index 8d98066d55..c0e5d0e66a 100644
--- a/packages/svelte/tests/validator/samples/html-block-in-textarea/errors.json
+++ b/packages/svelte/tests/validator/samples/html-block-in-textarea/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-tag-placement",
+		"code": "invalid_tag_placement",
 		"message": "{@html ...} tag cannot be inside <textarea>",
-		"start": { "line": 2, "column": 1 },
-		"end": { "line": 2, "column": 1 }
+		"start": {
+			"line": 2,
+			"column": 1
+		},
+		"end": {
+			"line": 2,
+			"column": 1
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/illegal-variable-declaration/errors.json b/packages/svelte/tests/validator/samples/illegal-variable-declaration/errors.json
index 788784d1d8..d55986ec5a 100644
--- a/packages/svelte/tests/validator/samples/illegal-variable-declaration/errors.json
+++ b/packages/svelte/tests/validator/samples/illegal-variable-declaration/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "illegal-variable-declaration",
-		"message": "Cannot declare same variable name which is imported inside <script context=\"module\">",
+		"code": "illegal_variable_declaration",
+		"message": "Cannot declare same variable name which is imported inside `<script context=\"module\">`",
 		"start": {
 			"line": 12,
 			"column": 5
diff --git a/packages/svelte/tests/validator/samples/invalid-empty-css-declaration/errors.json b/packages/svelte/tests/validator/samples/invalid-empty-css-declaration/errors.json
index 2ceb3a3694..299cb2fff5 100644
--- a/packages/svelte/tests/validator/samples/invalid-empty-css-declaration/errors.json
+++ b/packages/svelte/tests/validator/samples/invalid-empty-css-declaration/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-css-declaration",
+		"code": "invalid_css_declaration",
 		"message": "Declaration cannot be empty",
 		"start": {
 			"line": 5,
diff --git a/packages/svelte/tests/validator/samples/invalid-node-placement-2/errors.json b/packages/svelte/tests/validator/samples/invalid-node-placement-2/errors.json
index fdd8af19c2..99fce66db0 100644
--- a/packages/svelte/tests/validator/samples/invalid-node-placement-2/errors.json
+++ b/packages/svelte/tests/validator/samples/invalid-node-placement-2/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-node-placement",
+		"code": "invalid_node_placement",
 		"message": "<div> is invalid inside <p>",
 		"start": {
 			"line": 4,
diff --git a/packages/svelte/tests/validator/samples/invalid-node-placement/errors.json b/packages/svelte/tests/validator/samples/invalid-node-placement/errors.json
index 259b8f613b..1b43c778ee 100644
--- a/packages/svelte/tests/validator/samples/invalid-node-placement/errors.json
+++ b/packages/svelte/tests/validator/samples/invalid-node-placement/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-node-placement",
+		"code": "invalid_node_placement",
 		"message": "<a> is invalid inside <a>",
 		"start": {
 			"line": 4,
diff --git a/packages/svelte/tests/validator/samples/let-directive/errors.json b/packages/svelte/tests/validator/samples/let-directive/errors.json
index bb239bafa7..5e4138812e 100644
--- a/packages/svelte/tests/validator/samples/let-directive/errors.json
+++ b/packages/svelte/tests/validator/samples/let-directive/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-let-directive-placement",
-		"message": "let directive at invalid position",
-		"start": { "line": 6, "column": 15 },
-		"end": { "line": 6, "column": 20 }
+		"code": "invalid_let_directive_placement",
+		"message": "`let:` directive at invalid position",
+		"start": {
+			"line": 6,
+			"column": 15
+		},
+		"end": {
+			"line": 6,
+			"column": 20
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/logic-block-in-attribute/errors.json b/packages/svelte/tests/validator/samples/logic-block-in-attribute/errors.json
index 883fc0e479..c1169837ea 100644
--- a/packages/svelte/tests/validator/samples/logic-block-in-attribute/errors.json
+++ b/packages/svelte/tests/validator/samples/logic-block-in-attribute/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-block-placement",
+		"code": "invalid_block_placement",
 		"message": "{#if ...} block cannot be in attribute value",
-		"start": { "line": 1, "column": 12 },
-		"end": { "line": 1, "column": 12 }
+		"start": {
+			"line": 1,
+			"column": 12
+		},
+		"end": {
+			"line": 1,
+			"column": 12
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/logic-block-in-textarea/errors.json b/packages/svelte/tests/validator/samples/logic-block-in-textarea/errors.json
index a371f9b76b..e9f8a9decf 100644
--- a/packages/svelte/tests/validator/samples/logic-block-in-textarea/errors.json
+++ b/packages/svelte/tests/validator/samples/logic-block-in-textarea/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-block-placement",
+		"code": "invalid_block_placement",
 		"message": "{#each ...} block cannot be inside <textarea>",
-		"start": { "line": 2, "column": 1 },
-		"end": { "line": 2, "column": 1 }
+		"start": {
+			"line": 2,
+			"column": 1
+		},
+		"end": {
+			"line": 2,
+			"column": 1
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/multiple-script-default-context/errors.json b/packages/svelte/tests/validator/samples/multiple-script-default-context/errors.json
index 58eb092928..ab06795527 100644
--- a/packages/svelte/tests/validator/samples/multiple-script-default-context/errors.json
+++ b/packages/svelte/tests/validator/samples/multiple-script-default-context/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-script-element",
-		"message": "A component can have a single top-level <script> element and/or a single top-level <script context=\"module\"> element",
+		"code": "duplicate_script_element",
+		"message": "A component can have a single top-level `<script>` element and/or a single top-level `<script context=\"module\">` element",
 		"start": {
 			"line": 5,
 			"column": 0
diff --git a/packages/svelte/tests/validator/samples/multiple-script-module-context/errors.json b/packages/svelte/tests/validator/samples/multiple-script-module-context/errors.json
index 58eb092928..ab06795527 100644
--- a/packages/svelte/tests/validator/samples/multiple-script-module-context/errors.json
+++ b/packages/svelte/tests/validator/samples/multiple-script-module-context/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-script-element",
-		"message": "A component can have a single top-level <script> element and/or a single top-level <script context=\"module\"> element",
+		"code": "duplicate_script_element",
+		"message": "A component can have a single top-level `<script>` element and/or a single top-level `<script context=\"module\">` element",
 		"start": {
 			"line": 5,
 			"column": 0
diff --git a/packages/svelte/tests/validator/samples/namespace-invalid/errors.json b/packages/svelte/tests/validator/samples/namespace-invalid/errors.json
index 7081b9da27..e381545dc0 100644
--- a/packages/svelte/tests/validator/samples/namespace-invalid/errors.json
+++ b/packages/svelte/tests/validator/samples/namespace-invalid/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-svelte-option-namespace",
-		"message": "Unsupported <svelte:option> value for \"namespace\". Valid values are \"html\", \"svg\" or \"foreign\".",
+		"code": "invalid_svelte_option_namespace",
+		"message": "Unsupported `<svelte:option>` value for \"namespace\". Valid values are \"html\", \"svg\" or \"foreign\"",
 		"start": {
 			"line": 1,
 			"column": 16
diff --git a/packages/svelte/tests/validator/samples/namespace-non-literal/errors.json b/packages/svelte/tests/validator/samples/namespace-non-literal/errors.json
index 30c7ea279e..f8b2c75f05 100644
--- a/packages/svelte/tests/validator/samples/namespace-non-literal/errors.json
+++ b/packages/svelte/tests/validator/samples/namespace-non-literal/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-svelte-option-namespace",
-		"message": "Unsupported <svelte:option> value for \"namespace\". Valid values are \"html\", \"svg\" or \"foreign\".",
+		"code": "invalid_svelte_option_namespace",
+		"message": "Unsupported `<svelte:option>` value for \"namespace\". Valid values are \"html\", \"svg\" or \"foreign\"",
 		"start": {
 			"line": 1,
 			"column": 16
diff --git a/packages/svelte/tests/validator/samples/reactive-declaration-cyclical/errors.json b/packages/svelte/tests/validator/samples/reactive-declaration-cyclical/errors.json
index b4e3161be6..26fbd26534 100644
--- a/packages/svelte/tests/validator/samples/reactive-declaration-cyclical/errors.json
+++ b/packages/svelte/tests/validator/samples/reactive-declaration-cyclical/errors.json
@@ -1,8 +1,14 @@
 [
 	{
 		"message": "Cyclical dependency detected: a → b → a",
-		"code": "cyclical-reactive-declaration",
-		"start": { "line": 5, "column": 1 },
-		"end": { "line": 5, "column": 14 }
+		"code": "cyclical_reactive_declaration",
+		"start": {
+			"line": 5,
+			"column": 1
+		},
+		"end": {
+			"line": 5,
+			"column": 14
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/script-invalid-context/errors.json b/packages/svelte/tests/validator/samples/script-invalid-context/errors.json
index d7a502a2f7..173958d6c6 100644
--- a/packages/svelte/tests/validator/samples/script-invalid-context/errors.json
+++ b/packages/svelte/tests/validator/samples/script-invalid-context/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-script-context",
+		"code": "invalid_script_context",
 		"message": "If the context attribute is supplied, its value must be \"module\"",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/slot-attribute-invalid/errors.json b/packages/svelte/tests/validator/samples/slot-attribute-invalid/errors.json
index a5a3855787..e421039874 100644
--- a/packages/svelte/tests/validator/samples/slot-attribute-invalid/errors.json
+++ b/packages/svelte/tests/validator/samples/slot-attribute-invalid/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-slot-placement",
+		"code": "invalid_slot_placement",
 		"message": "Element with a slot='...' attribute must be a child of a component or a descendant of a custom element",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/style-directive-modifiers-invalid/errors.json b/packages/svelte/tests/validator/samples/style-directive-modifiers-invalid/errors.json
index ba88102f40..3d1373e8cd 100644
--- a/packages/svelte/tests/validator/samples/style-directive-modifiers-invalid/errors.json
+++ b/packages/svelte/tests/validator/samples/style-directive-modifiers-invalid/errors.json
@@ -1,7 +1,7 @@
 [
 	{
 		"message": "Invalid 'style:' modifier. Valid modifiers are: 'important'",
-		"code": "invalid-style-directive-modifier",
+		"code": "invalid_style_directive_modifier",
 		"start": {
 			"line": 1,
 			"column": 8
diff --git a/packages/svelte/tests/validator/samples/svelte-fragment-placement-2/errors.json b/packages/svelte/tests/validator/samples/svelte-fragment-placement-2/errors.json
index 955d756a6d..cf34adc56b 100644
--- a/packages/svelte/tests/validator/samples/svelte-fragment-placement-2/errors.json
+++ b/packages/svelte/tests/validator/samples/svelte-fragment-placement-2/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-svelte-fragment-placement",
-		"message": "<svelte:fragment> must be the direct child of a component",
-		"start": { "line": 5, "column": 0 },
-		"end": { "line": 7, "column": 18 }
+		"code": "invalid_svelte_fragment_placement",
+		"message": "`<svelte:fragment>` must be the direct child of a component",
+		"start": {
+			"line": 5,
+			"column": 0
+		},
+		"end": {
+			"line": 7,
+			"column": 18
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/svelte-fragment-placement/errors.json b/packages/svelte/tests/validator/samples/svelte-fragment-placement/errors.json
index 2ad4c8390f..195b0fca19 100644
--- a/packages/svelte/tests/validator/samples/svelte-fragment-placement/errors.json
+++ b/packages/svelte/tests/validator/samples/svelte-fragment-placement/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "invalid-svelte-fragment-placement",
-		"message": "<svelte:fragment> must be the direct child of a component",
-		"start": { "line": 7, "column": 2 },
-		"end": { "line": 9, "column": 20 }
+		"code": "invalid_svelte_fragment_placement",
+		"message": "`<svelte:fragment>` must be the direct child of a component",
+		"start": {
+			"line": 7,
+			"column": 2
+		},
+		"end": {
+			"line": 9,
+			"column": 20
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/svelte-head-attributes/errors.json b/packages/svelte/tests/validator/samples/svelte-head-attributes/errors.json
index 026ba121ab..f230f20788 100644
--- a/packages/svelte/tests/validator/samples/svelte-head-attributes/errors.json
+++ b/packages/svelte/tests/validator/samples/svelte-head-attributes/errors.json
@@ -1,8 +1,14 @@
 [
 	{
-		"code": "illegal-svelte-head-attribute",
-		"message": "<svelte:head> cannot have attributes nor directives",
-		"start": { "line": 1, "column": 13 },
-		"end": { "line": 1, "column": 14 }
+		"code": "illegal_svelte_head_attribute",
+		"message": "`<svelte:head>` cannot have attributes nor directives",
+		"start": {
+			"line": 1,
+			"column": 13
+		},
+		"end": {
+			"line": 1,
+			"column": 14
+		}
 	}
 ]
diff --git a/packages/svelte/tests/validator/samples/tag-invalid/errors.json b/packages/svelte/tests/validator/samples/tag-invalid/errors.json
index 7fc929b226..84d7f49de6 100644
--- a/packages/svelte/tests/validator/samples/tag-invalid/errors.json
+++ b/packages/svelte/tests/validator/samples/tag-invalid/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-tag-property",
-		"message": "tag name must be two or more words joined by the \"-\" character",
+		"code": "invalid_tag_property",
+		"message": "Tag name must be two or more words joined by the \"-\" character",
 		"start": {
 			"line": 1,
 			"column": 16
diff --git a/packages/svelte/tests/validator/samples/tag-non-string/errors.json b/packages/svelte/tests/validator/samples/tag-non-string/errors.json
index 46c98b70d5..0a41e50b9d 100644
--- a/packages/svelte/tests/validator/samples/tag-non-string/errors.json
+++ b/packages/svelte/tests/validator/samples/tag-non-string/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-svelte-option-customElement",
+		"code": "invalid_svelte_option_customElement",
 		"message": "\"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: .. } } }",
 		"start": {
 			"line": 1,
diff --git a/packages/svelte/tests/validator/samples/textarea-value-children/errors.json b/packages/svelte/tests/validator/samples/textarea-value-children/errors.json
index c4aed6b426..e2ea3e48fc 100644
--- a/packages/svelte/tests/validator/samples/textarea-value-children/errors.json
+++ b/packages/svelte/tests/validator/samples/textarea-value-children/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-textarea-content",
-		"message": "A <textarea> can have either a value attribute or (equivalently) child content, but not both",
+		"code": "invalid_textarea_content",
+		"message": "A `<textarea>` can have either a value attribute or (equivalently) child content, but not both",
 		"start": {
 			"line": 1,
 			"column": 0
diff --git a/packages/svelte/tests/validator/samples/title-no-attributes/errors.json b/packages/svelte/tests/validator/samples/title-no-attributes/errors.json
index 3f0410a6b0..85768c1fa9 100644
--- a/packages/svelte/tests/validator/samples/title-no-attributes/errors.json
+++ b/packages/svelte/tests/validator/samples/title-no-attributes/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "illegal-title-attribute",
-		"message": "<title> cannot have attributes nor directives",
+		"code": "illegal_title_attribute",
+		"message": "`<title>` cannot have attributes nor directives",
 		"start": {
 			"line": 2,
 			"column": 8
diff --git a/packages/svelte/tests/validator/samples/title-no-children/errors.json b/packages/svelte/tests/validator/samples/title-no-children/errors.json
index 9d7a7667a1..6a4d2475e1 100644
--- a/packages/svelte/tests/validator/samples/title-no-children/errors.json
+++ b/packages/svelte/tests/validator/samples/title-no-children/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-title-content",
-		"message": "<title> can only contain text and {tags}",
+		"code": "invalid_title_content",
+		"message": "`<title>` can only contain text and {tags}",
 		"start": {
 			"line": 2,
 			"column": 11
diff --git a/packages/svelte/tests/validator/samples/transition-duplicate-in-transition/errors.json b/packages/svelte/tests/validator/samples/transition-duplicate-in-transition/errors.json
index 2af6bfca8b..f4d13f4f54 100644
--- a/packages/svelte/tests/validator/samples/transition-duplicate-in-transition/errors.json
+++ b/packages/svelte/tests/validator/samples/transition-duplicate-in-transition/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-transition",
-		"message": "An element cannot have both an 'in' directive and a 'transition' directive",
+		"code": "transition_conflict",
+		"message": "Cannot use `in:` alongside existing `transition:` directive",
 		"start": {
 			"line": 6,
 			"column": 12
diff --git a/packages/svelte/tests/validator/samples/transition-duplicate-in/errors.json b/packages/svelte/tests/validator/samples/transition-duplicate-in/errors.json
index eba48be226..1f1690d256 100644
--- a/packages/svelte/tests/validator/samples/transition-duplicate-in/errors.json
+++ b/packages/svelte/tests/validator/samples/transition-duplicate-in/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-transition",
-		"message": "An element can only have one 'in' directive",
+		"code": "transition_duplicate",
+		"message": "Cannot use multiple `in:` directives on a single element",
 		"start": {
 			"line": 6,
 			"column": 12
diff --git a/packages/svelte/tests/validator/samples/transition-duplicate-out-transition/errors.json b/packages/svelte/tests/validator/samples/transition-duplicate-out-transition/errors.json
index cb1a474216..16e4e09e8d 100644
--- a/packages/svelte/tests/validator/samples/transition-duplicate-out-transition/errors.json
+++ b/packages/svelte/tests/validator/samples/transition-duplicate-out-transition/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-transition",
-		"message": "An element cannot have both an 'out' directive and a 'transition' directive",
+		"code": "transition_conflict",
+		"message": "Cannot use `out:` alongside existing `transition:` directive",
 		"start": {
 			"line": 6,
 			"column": 13
diff --git a/packages/svelte/tests/validator/samples/transition-duplicate-out/errors.json b/packages/svelte/tests/validator/samples/transition-duplicate-out/errors.json
index 34c57ab1b8..1dd1acde96 100644
--- a/packages/svelte/tests/validator/samples/transition-duplicate-out/errors.json
+++ b/packages/svelte/tests/validator/samples/transition-duplicate-out/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-transition",
-		"message": "An element can only have one 'out' directive",
+		"code": "transition_duplicate",
+		"message": "Cannot use multiple `out:` directives on a single element",
 		"start": {
 			"line": 6,
 			"column": 13
diff --git a/packages/svelte/tests/validator/samples/transition-duplicate-transition-in/errors.json b/packages/svelte/tests/validator/samples/transition-duplicate-transition-in/errors.json
index c88dd30d16..89c6414100 100644
--- a/packages/svelte/tests/validator/samples/transition-duplicate-transition-in/errors.json
+++ b/packages/svelte/tests/validator/samples/transition-duplicate-transition-in/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-transition",
-		"message": "An element cannot have both a 'transition' directive and an 'in' directive",
+		"code": "transition_conflict",
+		"message": "Cannot use `transition:` alongside existing `in:` directive",
 		"start": {
 			"line": 6,
 			"column": 20
diff --git a/packages/svelte/tests/validator/samples/transition-duplicate-transition-out/errors.json b/packages/svelte/tests/validator/samples/transition-duplicate-transition-out/errors.json
index 8c1a2a2706..3f0cbc0eee 100644
--- a/packages/svelte/tests/validator/samples/transition-duplicate-transition-out/errors.json
+++ b/packages/svelte/tests/validator/samples/transition-duplicate-transition-out/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-transition",
-		"message": "An element cannot have both a 'transition' directive and an 'out' directive",
+		"code": "transition_conflict",
+		"message": "Cannot use `transition:` alongside existing `out:` directive",
 		"start": {
 			"line": 6,
 			"column": 20
diff --git a/packages/svelte/tests/validator/samples/transition-duplicate-transition/errors.json b/packages/svelte/tests/validator/samples/transition-duplicate-transition/errors.json
index 1c93b5cb87..6e9d2f900a 100644
--- a/packages/svelte/tests/validator/samples/transition-duplicate-transition/errors.json
+++ b/packages/svelte/tests/validator/samples/transition-duplicate-transition/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "duplicate-transition",
-		"message": "An element can only have one 'transition' directive",
+		"code": "transition_duplicate",
+		"message": "Cannot use multiple `transition:` directives on a single element",
 		"start": {
 			"line": 6,
 			"column": 20
diff --git a/packages/svelte/tests/validator/samples/transition-on-component/errors.json b/packages/svelte/tests/validator/samples/transition-on-component/errors.json
index 7b2403bee6..52155a1480 100644
--- a/packages/svelte/tests/validator/samples/transition-on-component/errors.json
+++ b/packages/svelte/tests/validator/samples/transition-on-component/errors.json
@@ -1,6 +1,6 @@
 [
 	{
-		"code": "invalid-component-directive",
+		"code": "invalid_component_directive",
 		"message": "This type of directive is not valid on components",
 		"start": {
 			"line": 7,
diff --git a/packages/svelte/tests/validator/samples/window-binding-invalid-innerwidth/errors.json b/packages/svelte/tests/validator/samples/window-binding-invalid-innerwidth/errors.json
index 7f7a7eb6f9..99a1c892d3 100644
--- a/packages/svelte/tests/validator/samples/window-binding-invalid-innerwidth/errors.json
+++ b/packages/svelte/tests/validator/samples/window-binding-invalid-innerwidth/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-binding",
-		"message": "'innerwidth' is not a valid binding (did you mean 'innerWidth'?)",
+		"code": "bind_invalid_detailed",
+		"message": "`bind:innerwidth` is not a valid binding. Did you mean 'innerWidth'?",
 		"start": {
 			"line": 5,
 			"column": 15
diff --git a/packages/svelte/tests/validator/samples/window-binding-invalid/errors.json b/packages/svelte/tests/validator/samples/window-binding-invalid/errors.json
index dc1fadfc08..fc6c219444 100644
--- a/packages/svelte/tests/validator/samples/window-binding-invalid/errors.json
+++ b/packages/svelte/tests/validator/samples/window-binding-invalid/errors.json
@@ -1,7 +1,7 @@
 [
 	{
-		"code": "invalid-binding",
-		"message": "'potato' is not a valid binding",
+		"code": "bind_invalid",
+		"message": "`bind:potato` is not a valid binding",
 		"start": {
 			"line": 5,
 			"column": 15