From 36ed1a78be6b532eb794166bbc2157abd21f9c4d Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 1 Sep 2026 12:12:59 +0100
Subject: [PATCH 1/5] chore: use message-box for message processing

---
 packages/svelte/package.json                  |   1 +
 .../svelte/scripts/process-messages/index.js  | 353 +------
 .../templates/client-errors.js                |   8 +-
 .../templates/client-warnings.js              |   8 +-
 .../templates/compile-errors.js               |   8 +-
 .../templates/compile-warnings.js             |   8 +-
 .../templates/server-errors.js                |   8 +-
 .../templates/server-warnings.js              |   8 +-
 .../templates/shared-errors.js                |   8 +-
 .../templates/shared-warnings.js              |   8 +-
 packages/svelte/src/compiler/errors.js        | 981 ++++++++++--------
 .../src/compiler/phases/1-parse/acorn.js      |   2 +-
 .../src/compiler/phases/1-parse/index.js      |   6 +-
 .../compiler/phases/1-parse/read/options.js   |  10 +-
 .../compiler/phases/1-parse/read/script.js    |   6 +-
 .../phases/1-parse/remove_typescript_nodes.js |  19 +-
 .../compiler/phases/1-parse/state/element.js  |  33 +-
 .../src/compiler/phases/1-parse/state/tag.js  |  10 +-
 .../compiler/phases/1-parse/utils/bracket.js  |   2 +-
 .../phases/2-analyze/css/css-analyze.js       |   2 +-
 .../compiler/phases/2-analyze/css/css-warn.js |   2 +-
 .../src/compiler/phases/2-analyze/index.js    |  25 +-
 .../phases/2-analyze/visitors/AwaitBlock.js   |   4 +-
 .../2-analyze/visitors/BindDirective.js       |  48 +-
 .../2-analyze/visitors/CallExpression.js      |  36 +-
 .../phases/2-analyze/visitors/ClassBody.js    |  10 +-
 .../2-analyze/visitors/DeclarationTag.js      |   2 +-
 .../phases/2-analyze/visitors/EachBlock.js    |   2 +-
 .../2-analyze/visitors/ExpressionTag.js       |   2 +-
 .../phases/2-analyze/visitors/Identifier.js   |  12 +-
 .../2-analyze/visitors/ImportDeclaration.js   |   2 +-
 .../phases/2-analyze/visitors/OnDirective.js  |   2 +-
 .../2-analyze/visitors/RegularElement.js      |  12 +-
 .../phases/2-analyze/visitors/SnippetBlock.js |   4 +-
 .../2-analyze/visitors/SvelteDocument.js      |   2 +-
 .../phases/2-analyze/visitors/SvelteSelf.js   |   2 +-
 .../phases/2-analyze/visitors/SvelteWindow.js |   2 +-
 .../phases/2-analyze/visitors/Text.js         |   2 +-
 .../2-analyze/visitors/VariableDeclarator.js  |   2 +-
 .../2-analyze/visitors/shared/a11y/index.js   | 114 +-
 .../2-analyze/visitors/shared/attribute.js    |   2 +-
 .../2-analyze/visitors/shared/element.js      |  22 +-
 .../visitors/shared/special-element.js        |   2 +-
 .../phases/2-analyze/visitors/shared/utils.js |  13 +-
 .../src/compiler/phases/3-transform/utils.js  |   2 +-
 packages/svelte/src/compiler/phases/scope.js  |   2 +-
 .../compiler/utils/extract_svelte_ignore.js   |   4 +-
 .../svelte/src/compiler/validate-options.js   |   6 +-
 packages/svelte/src/compiler/warnings.js      | 497 ++++-----
 packages/svelte/src/index-client.js           |  16 +-
 packages/svelte/src/index-server.js           |   8 +-
 .../svelte/src/internal/client/dev/assign.js  |   5 +-
 .../src/internal/client/dev/console-log.js    |   2 +-
 .../src/internal/client/dev/equality.js       |  10 +-
 .../svelte/src/internal/client/dev/legacy.js  |   7 +-
 .../src/internal/client/dev/ownership.js      |  14 +-
 .../src/internal/client/dom/blocks/each.js    |   6 +-
 .../src/internal/client/dom/blocks/html.js    |   3 +-
 .../client/dom/elements/attributes.js         |   8 +-
 .../internal/client/dom/elements/events.js    |   2 +-
 packages/svelte/src/internal/client/errors.js | 292 +++---
 .../svelte/src/internal/client/hydratable.js  |   6 +-
 .../src/internal/client/reactivity/batch.js   |   2 +-
 .../internal/client/reactivity/deriveds.js    |   5 +-
 .../src/internal/client/reactivity/effects.js |   4 +-
 .../src/internal/client/reactivity/props.js   |   4 +-
 .../svelte/src/internal/client/runtime.js     |   2 +-
 .../svelte/src/internal/client/validate.js    |   2 +-
 .../svelte/src/internal/client/warnings.js    | 249 +++--
 packages/svelte/src/internal/server/errors.js |  98 +-
 .../svelte/src/internal/server/hydratable.js  |  10 +-
 packages/svelte/src/internal/server/index.js  |   2 +-
 .../svelte/src/internal/server/renderer.js    |   5 +-
 .../svelte/src/internal/server/warnings.js    |  19 +-
 packages/svelte/src/internal/shared/clone.js  |   2 +-
 .../svelte/src/internal/shared/context.js     |   2 +-
 packages/svelte/src/internal/shared/dev.js    |   2 +-
 packages/svelte/src/internal/shared/errors.js |  96 +-
 .../svelte/src/internal/shared/validate.js    |   4 +-
 .../svelte/src/internal/shared/warnings.js    |  30 +-
 packages/svelte/src/legacy/legacy-client.js   |   4 +-
 packages/svelte/src/transition/index.js       |   2 +-
 pnpm-lock.yaml                                |   8 +
 83 files changed, 1557 insertions(+), 1700 deletions(-)

diff --git a/packages/svelte/package.json b/packages/svelte/package.json
index 53e5516bf6..3596345da6 100644
--- a/packages/svelte/package.json
+++ b/packages/svelte/package.json
@@ -157,6 +157,7 @@
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-virtual": "^3.0.2",
+    "@sveltejs/message-box": "^1.1.0",
     "@types/aria-query": "^5.0.4",
     "@types/node": "^20.11.5",
     "@types/trusted-types": "^2.0.7",
diff --git a/packages/svelte/scripts/process-messages/index.js b/packages/svelte/scripts/process-messages/index.js
index c8d7418db4..ef817b8f7d 100644
--- a/packages/svelte/scripts/process-messages/index.js
+++ b/packages/svelte/scripts/process-messages/index.js
@@ -1,21 +1,16 @@
-/** @import { Node } from 'esrap/languages/ts' */
-/** @import * as ESTree from 'estree' */
-/** @import { AST } from 'svelte/compiler' */
+/** @import { Message } from '@sveltejs/message-box' */
 
 // @ts-check
 import process from 'node:process';
 import fs from 'node:fs';
-import * as acorn from 'acorn';
-import { walk } from 'zimmerframe';
-import * as esrap from 'esrap';
-import ts from 'esrap/languages/ts';
+import { parse, render } from '@sveltejs/message-box';
 
 const DIR = '../../documentation/docs/98-reference/.generated';
 
 const watch = process.argv.includes('-w');
 
 function run() {
-	/** @type {Record<string, Record<string, { messages: string[], details: string | null }>>} */
+	/** @type {Record<string, Record<string, Message>>} */
 	const messages = {};
 	const seen = new Set();
 
@@ -34,35 +29,22 @@ function run() {
 				.readFileSync(`messages/${category}/${file}`, 'utf-8')
 				.replace(/\r\n/g, '\n');
 
-			const sorted = [];
-
-			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}`);
-				}
-
-				sorted.push({ code, _ });
-
-				const sections = text.trim().split('\n\n');
-				const details = [];
-
-				while (!sections[sections.length - 1].startsWith('> ')) {
-					details.unshift(/** @type {string} */ (sections.pop()));
-				}
-
-				if (sections.length === 0) {
-					throw new Error('No message text');
+			for (const message of parse(markdown)) {
+				if (seen.has(message.code)) {
+					throw new Error(`Duplicate message code ${category}/${message.code}`);
 				}
 
-				seen.add(code);
-				messages[category][code] = {
-					messages: sections.map((section) => section.replace(/^> /gm, '').replace(/^>\n/gm, '\n')),
-					details: details.join('\n\n')
-				};
+				seen.add(message.code);
+				messages[category][message.code] = message;
 			}
 
+			const sorted = Array.from(
+				markdown.matchAll(/## ([\w]+)\n\n([^]+?)(?=$|\n\n## )/g),
+				([_, code]) => ({
+					code,
+					_
+				})
+			);
 			sorted.sort((a, b) => (a.code < b.code ? -1 : 1));
 
 			fs.writeFileSync(
@@ -75,11 +57,8 @@ function run() {
 			`${DIR}/${category}.md`,
 			'<!-- This file is generated by scripts/process-messages/index.js. Do not edit! -->\n\n' +
 				Object.entries(messages[category])
-					.map(([code, { messages, details }]) => {
-						const chunks = [
-							`### ${code}`,
-							...messages.map((message) => '```\n' + message + '\n```')
-						];
+					.map(([code, { variants, details }]) => {
+						const chunks = [`### ${code}`, ...variants.map(({ text }) => '```\n' + text + '\n```')];
 
 						if (details) {
 							chunks.push(details);
@@ -101,296 +80,28 @@ function run() {
 		const source = fs
 			.readFileSync(new URL(`./templates/${name}.js`, import.meta.url), 'utf-8')
 			.replace(/\r\n/g, '\n');
+		const marker = '/**\n * DESCRIPTION';
+		const index = source.lastIndexOf(marker);
 
-		/** @type {AST.JSComment[]} */
-		const comments = [];
-
-		let ast = /** @type {ESTree.Node} */ (
-			/** @type {unknown} */ (
-				acorn.parse(source, {
-					ecmaVersion: 'latest',
-					sourceType: 'module',
-					locations: true,
-					onComment: comments
-				})
-			)
-		);
-
-		comments.forEach((comment) => {
-			if (comment.type === 'Block') {
-				comment.value = comment.value.replace(/^\t+/gm, '');
-			}
-		});
-
-		ast = walk(ast, null, {
-			Identifier(node, context) {
-				if (node.name === 'CODES') {
-					/** @type {ESTree.ArrayExpression} */
-					const array = {
-						type: 'ArrayExpression',
-						elements: Object.keys(messages[name]).map((code) => ({
-							type: 'Literal',
-							value: code
-						}))
-					};
-
-					return array;
-				}
-			}
-		});
-
-		const body = /** @type {ESTree.Program} */ (ast).body;
+		if (index === -1) throw new Error(`missing message template in ${name}.js`);
 
 		const category = messages[name];
-
-		// find the `export function CODE` node
-		const index = 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 = body[index];
-		body.splice(index, 1);
-
-		const jsdoc = /** @type {AST.JSComment} */ (
-			comments.findLast((comment) => comment.start < /** @type {number} */ (template_node.start))
-		);
-
-		const printed = esrap.print(
-			/** @type {Node} */ (ast),
-			ts({
-				comments: comments.filter((comment) => comment !== jsdoc)
-			})
-		);
-
-		for (const code in category) {
-			const { messages } = category[code];
-			/** @type {string[]} */
-			const vars = [];
-
-			const group = messages.map((text, i) => {
-				for (const match of text.matchAll(/%(\w+)%/g)) {
-					const name = match[1];
-					if (!vars.includes(name)) {
-						vars.push(match[1]);
-					}
-				}
-
-				return {
-					text,
-					vars: vars.slice()
-				};
-			});
-
-			/** @type {ESTree.Expression} */
-			let message = { type: 'Literal', value: '' };
-			let prev_vars;
-
-			for (let i = 0; i < group.length; i += 1) {
-				const { text, vars } = group[i];
-
-				if (vars.length === 0) {
-					message = {
-						type: 'Literal',
-						value: text
-					};
-					prev_vars = vars;
-					continue;
-				}
-
-				const parts = text.split(/(%\w+%)/);
-
-				/** @type {ESTree.Expression[]} */
-				const expressions = [];
-
-				/** @type {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)
-						});
-					}
-				}
-
-				/** @type {ESTree.Expression} */
-				const expression = {
-					type: 'TemplateLiteral',
-					expressions,
-					quasis
-				};
-
-				if (prev_vars) {
-					if (vars.length === prev_vars.length) {
-						throw new Error('Message overloads must have new parameters');
-					}
-
-					message = {
-						type: 'ConditionalExpression',
-						test: {
-							type: 'Identifier',
-							name: vars[prev_vars.length]
-						},
-						consequent: expression,
-						alternate: message
-					};
-				} else {
-					message = expression;
-				}
-
-				prev_vars = vars;
-			}
-
-			const clone = /** @type {ESTree.Statement} */ (
-				walk(/** @type {ESTree.Node} */ (template_node), null, {
-					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 {ESTree.FunctionDeclaration} */ ({
-							.../** @type {ESTree.FunctionDeclaration} */ (context.next()),
-							params,
-							id: {
-								...node.id,
-								name: code
-							}
-						});
-					},
-					TemplateLiteral(node, context) {
-						/** @type {ESTree.TemplateElement} */
-						let quasi = {
-							type: 'TemplateElement',
-							value: {
-								...node.quasis[0].value
-							},
-							tail: node.quasis[0].tail
-						};
-
-						/** @type {ESTree.TemplateLiteral} */
-						let out = {
-							type: 'TemplateLiteral',
-							quasis: [quasi],
-							expressions: []
-						};
-
-						for (let i = 0; i < node.expressions.length; i += 1) {
-							const q = structuredClone(node.quasis[i + 1]);
-							const e = node.expressions[i];
-
-							if (e.type === 'Literal' && e.value === 'CODE') {
-								quasi.value.raw += code + q.value.raw;
-								continue;
-							}
-
-							if (e.type === 'Identifier' && e.name === 'MESSAGE') {
-								if (message.type === 'Literal') {
-									const str = /** @type {string} */ (message.value).replace(/(`|\${)/g, '\\$1');
-									quasi.value.raw += str + q.value.raw;
-									continue;
-								}
-
-								if (message.type === 'TemplateLiteral') {
-									const m = structuredClone(message);
-									quasi.value.raw += m.quasis[0].value.raw;
-									out.quasis.push(...m.quasis.slice(1));
-									out.expressions.push(...m.expressions);
-									quasi = m.quasis[m.quasis.length - 1];
-									quasi.value.raw += q.value.raw;
-									continue;
-								}
-							}
-
-							out.quasis.push((quasi = q));
-							out.expressions.push(/** @type {ESTree.Expression} */ (context.visit(e)));
-						}
-
-						return out;
-					},
-					Literal(node) {
-						if (node.value === 'CODE') {
-							return {
-								type: 'Literal',
-								value: code
-							};
-						}
-					},
-					Identifier(node) {
-						if (node.name !== 'MESSAGE') return;
-						return message;
-					}
-				})
-			);
-
-			const jsdoc_clone = {
-				...jsdoc,
-				value: /** @type {string} */ (jsdoc.value)
-					.split('\n')
-					.map((line) => {
-						if (line === ' * MESSAGE') {
-							return messages[messages.length - 1]
-								.split('\n')
-								.map((line) => ` * ${line}`)
-								.join('\n');
-						}
-
-						if (line.includes('PARAMETER')) {
-							return vars
-								.map((name, i) => {
-									const optional = i >= group[0].vars.length;
-
-									return optional
-										? ` * @param {string | undefined | null} [${name}]`
-										: ` * @param {string} ${name}`;
-								})
-								.join('\n');
-						}
-
-						return line;
-					})
-					.filter((x) => x !== '')
-					.join('\n')
-			};
-
-			const block = esrap.print(
-				/** @type {ESTree.Program} */ ({ ...ast, body: [clone] }),
-				ts({ comments: [jsdoc_clone] })
-			).code;
-
-			printed.code += `\n\n${block}`;
-
-			body.push(clone);
-		}
+		const codes = `[\n${Object.keys(category)
+			.map((code) => `\t'${code}'`)
+			.join(',\n')}\n]`;
+		const preamble = source.slice(0, index).trimEnd().replace('CODES', codes);
+		const template = source.slice(index).trim();
+		const output = Object.values(category)
+			.map((message) => render(message, template))
+			.join('\n\n');
 
 		fs.writeFileSync(
 			dest,
 			`/* This file is generated by scripts/process-messages/index.js. Do not edit! */\n\n` +
-				printed.code,
+				preamble +
+				'\n\n' +
+				output +
+				'\n',
 			'utf-8'
 		);
 	}
diff --git a/packages/svelte/scripts/process-messages/templates/client-errors.js b/packages/svelte/scripts/process-messages/templates/client-errors.js
index ef749b4ba3..563e7e77d5 100644
--- a/packages/svelte/scripts/process-messages/templates/client-errors.js
+++ b/packages/svelte/scripts/process-messages/templates/client-errors.js
@@ -3,13 +3,13 @@ import { DEV } from 'esm-env';
 export * from '../shared/errors.js';
 
 /**
- * MESSAGE
- * @param {string} PARAMETER
+ * DESCRIPTION
+ * @param {VALUES} values
  * @returns {never}
  */
-export function CODE(PARAMETER) {
+export function CODE(values) {
 	if (DEV) {
-		const error = new Error(`${'CODE'}\n${MESSAGE}\nhttps://svelte.dev/e/${'CODE'}`);
+		const error = new Error(`${'CODE'}\n${MESSAGE(values)}\nhttps://svelte.dev/e/${'CODE'}`);
 		error.name = 'Svelte error';
 		throw error;
 	} else {
diff --git a/packages/svelte/scripts/process-messages/templates/client-warnings.js b/packages/svelte/scripts/process-messages/templates/client-warnings.js
index 8a9b87b760..7b4a6821fe 100644
--- a/packages/svelte/scripts/process-messages/templates/client-warnings.js
+++ b/packages/svelte/scripts/process-messages/templates/client-warnings.js
@@ -4,13 +4,13 @@ var bold = 'font-weight: bold';
 var normal = 'font-weight: normal';
 
 /**
- * MESSAGE
- * @param {string} PARAMETER
+ * DESCRIPTION
+ * @param {VALUES} values
  */
-export function CODE(PARAMETER) {
+export function CODE(values) {
 	if (DEV) {
 		console.warn(
-			`%c[svelte] ${'CODE'}\n%c${MESSAGE}\nhttps://svelte.dev/e/${'CODE'}`,
+			`%c[svelte] ${'CODE'}\n%c${MESSAGE(values)}\nhttps://svelte.dev/e/${'CODE'}`,
 			bold,
 			normal
 		);
diff --git a/packages/svelte/scripts/process-messages/templates/compile-errors.js b/packages/svelte/scripts/process-messages/templates/compile-errors.js
index 445f5d14e6..7b1bf63c4a 100644
--- a/packages/svelte/scripts/process-messages/templates/compile-errors.js
+++ b/packages/svelte/scripts/process-messages/templates/compile-errors.js
@@ -50,11 +50,11 @@ function e(node, code, message) {
 }
 
 /**
- * MESSAGE
+ * DESCRIPTION
  * @param {null | number | NodeLike} node
- * @param {string} PARAMETER
+ * @param {VALUES} values
  * @returns {never}
  */
-export function CODE(node, PARAMETER) {
-	e(node, 'CODE', `${MESSAGE}\nhttps://svelte.dev/e/${'CODE'}`);
+export function CODE(node, values) {
+	e(node, 'CODE', `${MESSAGE(values)}\nhttps://svelte.dev/e/${'CODE'}`);
 }
diff --git a/packages/svelte/scripts/process-messages/templates/compile-warnings.js b/packages/svelte/scripts/process-messages/templates/compile-warnings.js
index e0c970c664..768f9c6eb3 100644
--- a/packages/svelte/scripts/process-messages/templates/compile-warnings.js
+++ b/packages/svelte/scripts/process-messages/templates/compile-warnings.js
@@ -42,10 +42,10 @@ function w(node, code, message) {
 export const codes = CODES;
 
 /**
- * MESSAGE
+ * DESCRIPTION
  * @param {null | NodeLike} node
- * @param {string} PARAMETER
+ * @param {VALUES} values
  */
-export function CODE(node, PARAMETER) {
-	w(node, 'CODE', `${MESSAGE}\nhttps://svelte.dev/e/${'CODE'}`);
+export function CODE(node, values) {
+	w(node, 'CODE', `${MESSAGE(values)}\nhttps://svelte.dev/e/${'CODE'}`);
 }
diff --git a/packages/svelte/scripts/process-messages/templates/server-errors.js b/packages/svelte/scripts/process-messages/templates/server-errors.js
index 0bbe801abc..83b8d87616 100644
--- a/packages/svelte/scripts/process-messages/templates/server-errors.js
+++ b/packages/svelte/scripts/process-messages/templates/server-errors.js
@@ -1,12 +1,12 @@
 export * from '../shared/errors.js';
 
 /**
- * MESSAGE
- * @param {string} PARAMETER
+ * DESCRIPTION
+ * @param {VALUES} values
  * @returns {never}
  */
-export function CODE(PARAMETER) {
-	const error = new Error(`${'CODE'}\n${MESSAGE}\nhttps://svelte.dev/e/${'CODE'}`);
+export function CODE(values) {
+	const error = new Error(`${'CODE'}\n${MESSAGE(values)}\nhttps://svelte.dev/e/${'CODE'}`);
 	error.name = 'Svelte error';
 	throw error;
 }
diff --git a/packages/svelte/scripts/process-messages/templates/server-warnings.js b/packages/svelte/scripts/process-messages/templates/server-warnings.js
index 8a9b87b760..7b4a6821fe 100644
--- a/packages/svelte/scripts/process-messages/templates/server-warnings.js
+++ b/packages/svelte/scripts/process-messages/templates/server-warnings.js
@@ -4,13 +4,13 @@ var bold = 'font-weight: bold';
 var normal = 'font-weight: normal';
 
 /**
- * MESSAGE
- * @param {string} PARAMETER
+ * DESCRIPTION
+ * @param {VALUES} values
  */
-export function CODE(PARAMETER) {
+export function CODE(values) {
 	if (DEV) {
 		console.warn(
-			`%c[svelte] ${'CODE'}\n%c${MESSAGE}\nhttps://svelte.dev/e/${'CODE'}`,
+			`%c[svelte] ${'CODE'}\n%c${MESSAGE(values)}\nhttps://svelte.dev/e/${'CODE'}`,
 			bold,
 			normal
 		);
diff --git a/packages/svelte/scripts/process-messages/templates/shared-errors.js b/packages/svelte/scripts/process-messages/templates/shared-errors.js
index c72e9f9d5e..de7d8c4e99 100644
--- a/packages/svelte/scripts/process-messages/templates/shared-errors.js
+++ b/packages/svelte/scripts/process-messages/templates/shared-errors.js
@@ -1,13 +1,13 @@
 import { DEV } from 'esm-env';
 
 /**
- * MESSAGE
- * @param {string} PARAMETER
+ * DESCRIPTION
+ * @param {VALUES} values
  * @returns {never}
  */
-export function CODE(PARAMETER) {
+export function CODE(values) {
 	if (DEV) {
-		const error = new Error(`${'CODE'}\n${MESSAGE}\nhttps://svelte.dev/e/${'CODE'}`);
+		const error = new Error(`${'CODE'}\n${MESSAGE(values)}\nhttps://svelte.dev/e/${'CODE'}`);
 		error.name = 'Svelte error';
 		throw error;
 	} else {
diff --git a/packages/svelte/scripts/process-messages/templates/shared-warnings.js b/packages/svelte/scripts/process-messages/templates/shared-warnings.js
index 8a9b87b760..7b4a6821fe 100644
--- a/packages/svelte/scripts/process-messages/templates/shared-warnings.js
+++ b/packages/svelte/scripts/process-messages/templates/shared-warnings.js
@@ -4,13 +4,13 @@ var bold = 'font-weight: bold';
 var normal = 'font-weight: normal';
 
 /**
- * MESSAGE
- * @param {string} PARAMETER
+ * DESCRIPTION
+ * @param {VALUES} values
  */
-export function CODE(PARAMETER) {
+export function CODE(values) {
 	if (DEV) {
 		console.warn(
-			`%c[svelte] ${'CODE'}\n%c${MESSAGE}\nhttps://svelte.dev/e/${'CODE'}`,
+			`%c[svelte] ${'CODE'}\n%c${MESSAGE(values)}\nhttps://svelte.dev/e/${'CODE'}`,
 			bold,
 			normal
 		);
diff --git a/packages/svelte/src/compiler/errors.js b/packages/svelte/src/compiler/errors.js
index ccb7fe833e..c96d214b56 100644
--- a/packages/svelte/src/compiler/errors.js
+++ b/packages/svelte/src/compiler/errors.js
@@ -3,6 +3,7 @@
 import { CompileDiagnostic } from './utils/compile_diagnostic.js';
 
 /** @typedef {{ start?: number, end?: number }} NodeLike */
+
 class InternalCompileError extends Error {
 	message = ''; // ensure this property is enumerable
 	#diagnostic;
@@ -20,7 +21,6 @@ class InternalCompileError extends Error {
 		// But we also want to share the same object shape with that of warnings, therefore
 		// we create an instance of the shared class an copy over its properties.
 		this.#diagnostic = new CompileDiagnostic(code, message, position);
-
 		Object.assign(this, this.#diagnostic);
 		this.name = 'CompileError';
 	}
@@ -44,1694 +44,1809 @@ function e(node, code, message) {
 	const start = typeof node === 'number' ? node : node?.start;
 	const end = typeof node === 'number' ? node : node?.end;
 
-	throw new InternalCompileError(code, message, start !== undefined ? [start, end ?? start] : undefined);
+	throw new InternalCompileError(
+		code,
+		message,
+		start !== undefined ? [start, end ?? start] : undefined
+	);
 }
 
 /**
  * Invalid compiler option: %details%
  * @param {null | number | NodeLike} node
- * @param {string} details
+ * @param {{ "details": string }} values
  * @returns {never}
  */
-export function options_invalid_value(node, details) {
-	e(node, 'options_invalid_value', `Invalid compiler option: ${details}\nhttps://svelte.dev/e/options_invalid_value`);
+export function options_invalid_value(node, values) {
+	e(node, 'options_invalid_value', `${`Invalid compiler option: ${values.details}`}\nhttps://svelte.dev/e/${'options_invalid_value'}`);
 }
 
 /**
  * Invalid compiler option: %details%
  * @param {null | number | NodeLike} node
- * @param {string} details
+ * @param {{ "details": string }} values
  * @returns {never}
  */
-export function options_removed(node, details) {
-	e(node, 'options_removed', `Invalid compiler option: ${details}\nhttps://svelte.dev/e/options_removed`);
+export function options_removed(node, values) {
+	e(node, 'options_removed', `${`Invalid compiler option: ${values.details}`}\nhttps://svelte.dev/e/${'options_removed'}`);
 }
 
 /**
  * Unrecognised compiler option %keypath%
  * @param {null | number | NodeLike} node
- * @param {string} keypath
+ * @param {{ "keypath": string }} values
  * @returns {never}
  */
-export function options_unrecognised(node, keypath) {
-	e(node, 'options_unrecognised', `Unrecognised compiler option ${keypath}\nhttps://svelte.dev/e/options_unrecognised`);
+export function options_unrecognised(node, values) {
+	e(node, 'options_unrecognised', `${`Unrecognised compiler option ${values.keypath}`}\nhttps://svelte.dev/e/${'options_unrecognised'}`);
 }
 
 /**
  * `$bindable()` can only be used inside a `$props()` declaration
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function bindable_invalid_location(node) {
-	e(node, 'bindable_invalid_location', `\`$bindable()\` can only be used inside a \`$props()\` declaration\nhttps://svelte.dev/e/bindable_invalid_location`);
+export function bindable_invalid_location(node, values) {
+	e(node, 'bindable_invalid_location', `${`\`$bindable()\` can only be used inside a \`$props()\` declaration`}\nhttps://svelte.dev/e/${'bindable_invalid_location'}`);
 }
 
 /**
  * Cannot assign to %thing%
  * @param {null | number | NodeLike} node
- * @param {string} thing
+ * @param {{ "thing": string }} values
  * @returns {never}
  */
-export function constant_assignment(node, thing) {
-	e(node, 'constant_assignment', `Cannot assign to ${thing}\nhttps://svelte.dev/e/constant_assignment`);
+export function constant_assignment(node, values) {
+	e(node, 'constant_assignment', `${`Cannot assign to ${values.thing}`}\nhttps://svelte.dev/e/${'constant_assignment'}`);
 }
 
 /**
  * Cannot bind to %thing%
  * @param {null | number | NodeLike} node
- * @param {string} thing
+ * @param {{ "thing": string }} values
  * @returns {never}
  */
-export function constant_binding(node, thing) {
-	e(node, 'constant_binding', `Cannot bind to ${thing}\nhttps://svelte.dev/e/constant_binding`);
+export function constant_binding(node, values) {
+	e(node, 'constant_binding', `${`Cannot bind to ${values.thing}`}\nhttps://svelte.dev/e/${'constant_binding'}`);
 }
 
 /**
  * `%name%` has already been declared
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function declaration_duplicate(node, name) {
-	e(node, 'declaration_duplicate', `\`${name}\` has already been declared\nhttps://svelte.dev/e/declaration_duplicate`);
+export function declaration_duplicate(node, values) {
+	e(node, 'declaration_duplicate', `${`\`${values.name}\` has already been declared`}\nhttps://svelte.dev/e/${'declaration_duplicate'}`);
 }
 
 /**
  * Cannot declare a variable with the same name as an import from `<script module>`
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function declaration_duplicate_module_import(node) {
-	e(node, 'declaration_duplicate_module_import', `Cannot declare a variable with the same name as an import from \`<script module>\`\nhttps://svelte.dev/e/declaration_duplicate_module_import`);
+export function declaration_duplicate_module_import(node, values) {
+	e(node, 'declaration_duplicate_module_import', `${`Cannot declare a variable with the same name as an import from \`<script module>\``}\nhttps://svelte.dev/e/${'declaration_duplicate_module_import'}`);
 }
 
 /**
  * Cannot export derived state from a module. To expose the current derived value, export a function returning its value
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function derived_invalid_export(node) {
-	e(node, 'derived_invalid_export', `Cannot export derived state from a module. To expose the current derived value, export a function returning its value\nhttps://svelte.dev/e/derived_invalid_export`);
+export function derived_invalid_export(node, values) {
+	e(node, 'derived_invalid_export', `${`Cannot export derived state from a module. To expose the current derived value, export a function returning its value`}\nhttps://svelte.dev/e/${'derived_invalid_export'}`);
 }
 
 /**
  * The $ name is reserved, and cannot be used for variables and imports
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function dollar_binding_invalid(node) {
-	e(node, 'dollar_binding_invalid', `The $ name is reserved, and cannot be used for variables and imports\nhttps://svelte.dev/e/dollar_binding_invalid`);
+export function dollar_binding_invalid(node, values) {
+	e(node, 'dollar_binding_invalid', `${`The $ name is reserved, and cannot be used for variables and imports`}\nhttps://svelte.dev/e/${'dollar_binding_invalid'}`);
 }
 
 /**
  * The $ prefix is reserved, and cannot be used for variables and imports
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function dollar_prefix_invalid(node) {
-	e(node, 'dollar_prefix_invalid', `The $ prefix is reserved, and cannot be used for variables and imports\nhttps://svelte.dev/e/dollar_prefix_invalid`);
+export function dollar_prefix_invalid(node, values) {
+	e(node, 'dollar_prefix_invalid', `${`The $ prefix is reserved, and cannot be used for variables and imports`}\nhttps://svelte.dev/e/${'dollar_prefix_invalid'}`);
 }
 
 /**
  * `%name%` has already been declared
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function duplicate_class_field(node, name) {
-	e(node, 'duplicate_class_field', `\`${name}\` has already been declared\nhttps://svelte.dev/e/duplicate_class_field`);
+export function duplicate_class_field(node, values) {
+	e(node, 'duplicate_class_field', `${`\`${values.name}\` has already been declared`}\nhttps://svelte.dev/e/${'duplicate_class_field'}`);
 }
 
 /**
  * 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`, or `bind:value={array[i]}` instead of `bind:value={entry}`)
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function each_item_invalid_assignment(node) {
-	e(node, 'each_item_invalid_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\`, or \`bind:value={array[i]}\` instead of \`bind:value={entry}\`)\nhttps://svelte.dev/e/each_item_invalid_assignment`);
+export function each_item_invalid_assignment(node, values) {
+	e(node, 'each_item_invalid_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\`, or \`bind:value={array[i]}\` instead of \`bind:value={entry}\`)`}\nhttps://svelte.dev/e/${'each_item_invalid_assignment'}`);
 }
 
 /**
  * `$effect()` can only be used as an expression statement
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function effect_invalid_placement(node) {
-	e(node, 'effect_invalid_placement', `\`$effect()\` can only be used as an expression statement\nhttps://svelte.dev/e/effect_invalid_placement`);
+export function effect_invalid_placement(node, values) {
+	e(node, 'effect_invalid_placement', `${`\`$effect()\` can only be used as an expression statement`}\nhttps://svelte.dev/e/${'effect_invalid_placement'}`);
 }
 
 /**
  * Cannot use `await` in deriveds and template expressions, or at the top level of a component, unless the `experimental.async` compiler option is `true`
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function experimental_async(node) {
-	e(node, 'experimental_async', `Cannot use \`await\` in deriveds and template expressions, or at the top level of a component, unless the \`experimental.async\` compiler option is \`true\`\nhttps://svelte.dev/e/experimental_async`);
+export function experimental_async(node, values) {
+	e(node, 'experimental_async', `${`Cannot use \`await\` in deriveds and template expressions, or at the top level of a component, unless the \`experimental.async\` compiler option is \`true\``}\nhttps://svelte.dev/e/${'experimental_async'}`);
 }
 
 /**
  * `%name%` is not defined
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function export_undefined(node, name) {
-	e(node, 'export_undefined', `\`${name}\` is not defined\nhttps://svelte.dev/e/export_undefined`);
+export function export_undefined(node, values) {
+	e(node, 'export_undefined', `${`\`${values.name}\` is not defined`}\nhttps://svelte.dev/e/${'export_undefined'}`);
 }
 
 /**
  * `%name%` is an illegal variable name. To reference a global variable called `%name%`, use `globalThis.%name%`
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function global_reference_invalid(node, name) {
-	e(node, 'global_reference_invalid', `\`${name}\` is an illegal variable name. To reference a global variable called \`${name}\`, use \`globalThis.${name}\`\nhttps://svelte.dev/e/global_reference_invalid`);
+export function global_reference_invalid(node, values) {
+	e(node, 'global_reference_invalid', `${`\`${values.name}\` is an illegal variable name. To reference a global variable called \`${values.name}\`, use \`globalThis.${values.name}\``}\nhttps://svelte.dev/e/${'global_reference_invalid'}`);
 }
 
 /**
  * `$host()` can only be used inside custom element component instances
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function host_invalid_placement(node) {
-	e(node, 'host_invalid_placement', `\`$host()\` can only be used inside custom element component instances\nhttps://svelte.dev/e/host_invalid_placement`);
+export function host_invalid_placement(node, values) {
+	e(node, 'host_invalid_placement', `${`\`$host()\` can only be used inside custom element component instances`}\nhttps://svelte.dev/e/${'host_invalid_placement'}`);
 }
 
 /**
  * Imports of `svelte/internal/*` are forbidden. It contains private runtime code which is subject to change without notice. If you're importing from `svelte/internal/*` to work around a limitation of Svelte, please open an issue at https://github.com/sveltejs/svelte and explain your use case
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function import_svelte_internal_forbidden(node) {
-	e(node, 'import_svelte_internal_forbidden', `Imports of \`svelte/internal/*\` are forbidden. It contains private runtime code which is subject to change without notice. If you're importing from \`svelte/internal/*\` to work around a limitation of Svelte, please open an issue at https://github.com/sveltejs/svelte and explain your use case\nhttps://svelte.dev/e/import_svelte_internal_forbidden`);
+export function import_svelte_internal_forbidden(node, values) {
+	e(node, 'import_svelte_internal_forbidden', `${`Imports of \`svelte/internal/*\` are forbidden. It contains private runtime code which is subject to change without notice. If you're importing from \`svelte/internal/*\` to work around a limitation of Svelte, please open an issue at https://github.com/sveltejs/svelte and explain your use case`}\nhttps://svelte.dev/e/${'import_svelte_internal_forbidden'}`);
 }
 
 /**
  * `$inspect.trace(...)` cannot be used inside a generator function
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function inspect_trace_generator(node) {
-	e(node, 'inspect_trace_generator', `\`$inspect.trace(...)\` cannot be used inside a generator function\nhttps://svelte.dev/e/inspect_trace_generator`);
+export function inspect_trace_generator(node, values) {
+	e(node, 'inspect_trace_generator', `${`\`$inspect.trace(...)\` cannot be used inside a generator function`}\nhttps://svelte.dev/e/${'inspect_trace_generator'}`);
 }
 
 /**
  * `$inspect.trace(...)` must be the first statement of a function body
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function inspect_trace_invalid_placement(node) {
-	e(node, 'inspect_trace_invalid_placement', `\`$inspect.trace(...)\` must be the first statement of a function body\nhttps://svelte.dev/e/inspect_trace_invalid_placement`);
+export function inspect_trace_invalid_placement(node, values) {
+	e(node, 'inspect_trace_invalid_placement', `${`\`$inspect.trace(...)\` must be the first statement of a function body`}\nhttps://svelte.dev/e/${'inspect_trace_invalid_placement'}`);
 }
 
 /**
  * The arguments keyword cannot be used within the template or at the top level of a component
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function invalid_arguments_usage(node) {
-	e(node, 'invalid_arguments_usage', `The arguments keyword cannot be used within the template or at the top level of a component\nhttps://svelte.dev/e/invalid_arguments_usage`);
+export function invalid_arguments_usage(node, values) {
+	e(node, 'invalid_arguments_usage', `${`The arguments keyword cannot be used within the template or at the top level of a component`}\nhttps://svelte.dev/e/${'invalid_arguments_usage'}`);
 }
 
 /**
  * Cannot use `await` in deriveds and template expressions, or at the top level of a component, unless in runes mode
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function legacy_await_invalid(node) {
-	e(node, 'legacy_await_invalid', `Cannot use \`await\` in deriveds and template expressions, or at the top level of a component, unless in runes mode\nhttps://svelte.dev/e/legacy_await_invalid`);
+export function legacy_await_invalid(node, values) {
+	e(node, 'legacy_await_invalid', `${`Cannot use \`await\` in deriveds and template expressions, or at the top level of a component, unless in runes mode`}\nhttps://svelte.dev/e/${'legacy_await_invalid'}`);
 }
 
 /**
  * Cannot use `export let` in runes mode — use `$props()` instead
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function legacy_export_invalid(node) {
-	e(node, 'legacy_export_invalid', `Cannot use \`export let\` in runes mode — use \`$props()\` instead\nhttps://svelte.dev/e/legacy_export_invalid`);
+export function legacy_export_invalid(node, values) {
+	e(node, 'legacy_export_invalid', `${`Cannot use \`export let\` in runes mode — use \`$props()\` instead`}\nhttps://svelte.dev/e/${'legacy_export_invalid'}`);
 }
 
 /**
  * Cannot use `$$props` in runes mode
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function legacy_props_invalid(node) {
-	e(node, 'legacy_props_invalid', `Cannot use \`$$props\` in runes mode\nhttps://svelte.dev/e/legacy_props_invalid`);
+export function legacy_props_invalid(node, values) {
+	e(node, 'legacy_props_invalid', `${`Cannot use \`$$props\` in runes mode`}\nhttps://svelte.dev/e/${'legacy_props_invalid'}`);
 }
 
 /**
  * `$:` is not allowed in runes mode, use `$derived` or `$effect` instead
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function legacy_reactive_statement_invalid(node) {
-	e(node, 'legacy_reactive_statement_invalid', `\`$:\` is not allowed in runes mode, use \`$derived\` or \`$effect\` instead\nhttps://svelte.dev/e/legacy_reactive_statement_invalid`);
+export function legacy_reactive_statement_invalid(node, values) {
+	e(node, 'legacy_reactive_statement_invalid', `${`\`$:\` is not allowed in runes mode, use \`$derived\` or \`$effect\` instead`}\nhttps://svelte.dev/e/${'legacy_reactive_statement_invalid'}`);
 }
 
 /**
  * Cannot use `$$restProps` in runes mode
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function legacy_rest_props_invalid(node) {
-	e(node, 'legacy_rest_props_invalid', `Cannot use \`$$restProps\` in runes mode\nhttps://svelte.dev/e/legacy_rest_props_invalid`);
+export function legacy_rest_props_invalid(node, values) {
+	e(node, 'legacy_rest_props_invalid', `${`Cannot use \`$$restProps\` in runes mode`}\nhttps://svelte.dev/e/${'legacy_rest_props_invalid'}`);
 }
 
 /**
  * A component cannot have a default export
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function module_illegal_default_export(node) {
-	e(node, 'module_illegal_default_export', `A component cannot have a default export\nhttps://svelte.dev/e/module_illegal_default_export`);
+export function module_illegal_default_export(node, values) {
+	e(node, 'module_illegal_default_export', `${`A component cannot have a default export`}\nhttps://svelte.dev/e/${'module_illegal_default_export'}`);
 }
 
 /**
  * Cannot use `%rune%()` more than once
  * @param {null | number | NodeLike} node
- * @param {string} rune
+ * @param {{ "rune": string }} values
  * @returns {never}
  */
-export function props_duplicate(node, rune) {
-	e(node, 'props_duplicate', `Cannot use \`${rune}()\` more than once\nhttps://svelte.dev/e/props_duplicate`);
+export function props_duplicate(node, values) {
+	e(node, 'props_duplicate', `${`Cannot use \`${values.rune}()\` more than once`}\nhttps://svelte.dev/e/${'props_duplicate'}`);
 }
 
 /**
  * `$props.id()` can only be used at the top level of components as a variable declaration initializer
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function props_id_invalid_placement(node) {
-	e(node, 'props_id_invalid_placement', `\`$props.id()\` can only be used at the top level of components as a variable declaration initializer\nhttps://svelte.dev/e/props_id_invalid_placement`);
+export function props_id_invalid_placement(node, values) {
+	e(node, 'props_id_invalid_placement', `${`\`$props.id()\` can only be used at the top level of components as a variable declaration initializer`}\nhttps://svelte.dev/e/${'props_id_invalid_placement'}`);
 }
 
 /**
  * Declaring or accessing a prop starting with `$$` is illegal (they are reserved for Svelte internals)
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function props_illegal_name(node) {
-	e(node, 'props_illegal_name', `Declaring or accessing a prop starting with \`$$\` is illegal (they are reserved for Svelte internals)\nhttps://svelte.dev/e/props_illegal_name`);
+export function props_illegal_name(node, values) {
+	e(node, 'props_illegal_name', `${`Declaring or accessing a prop starting with \`$$\` is illegal (they are reserved for Svelte internals)`}\nhttps://svelte.dev/e/${'props_illegal_name'}`);
 }
 
 /**
  * `$props()` can only be used with an object destructuring pattern
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function props_invalid_identifier(node) {
-	e(node, 'props_invalid_identifier', `\`$props()\` can only be used with an object destructuring pattern\nhttps://svelte.dev/e/props_invalid_identifier`);
+export function props_invalid_identifier(node, values) {
+	e(node, 'props_invalid_identifier', `${`\`$props()\` can only be used with an object destructuring pattern`}\nhttps://svelte.dev/e/${'props_invalid_identifier'}`);
 }
 
 /**
  * `$props()` assignment must not contain nested properties or computed keys
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function props_invalid_pattern(node) {
-	e(node, 'props_invalid_pattern', `\`$props()\` assignment must not contain nested properties or computed keys\nhttps://svelte.dev/e/props_invalid_pattern`);
+export function props_invalid_pattern(node, values) {
+	e(node, 'props_invalid_pattern', `${`\`$props()\` assignment must not contain nested properties or computed keys`}\nhttps://svelte.dev/e/${'props_invalid_pattern'}`);
 }
 
 /**
  * `$props()` can only be used at the top level of components as a variable declaration initializer
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function props_invalid_placement(node) {
-	e(node, 'props_invalid_placement', `\`$props()\` can only be used at the top level of components as a variable declaration initializer\nhttps://svelte.dev/e/props_invalid_placement`);
+export function props_invalid_placement(node, values) {
+	e(node, 'props_invalid_placement', `${`\`$props()\` can only be used at the top level of components as a variable declaration initializer`}\nhttps://svelte.dev/e/${'props_invalid_placement'}`);
 }
 
 /**
  * Cyclical dependency detected: %cycle%
  * @param {null | number | NodeLike} node
- * @param {string} cycle
+ * @param {{ "cycle": string }} values
  * @returns {never}
  */
-export function reactive_declaration_cycle(node, cycle) {
-	e(node, 'reactive_declaration_cycle', `Cyclical dependency detected: ${cycle}\nhttps://svelte.dev/e/reactive_declaration_cycle`);
+export function reactive_declaration_cycle(node, values) {
+	e(node, 'reactive_declaration_cycle', `${`Cyclical dependency detected: ${values.cycle}`}\nhttps://svelte.dev/e/${'reactive_declaration_cycle'}`);
 }
 
 /**
  * `%rune%` cannot be called with arguments
  * @param {null | number | NodeLike} node
- * @param {string} rune
+ * @param {{ "rune": string }} values
  * @returns {never}
  */
-export function rune_invalid_arguments(node, rune) {
-	e(node, 'rune_invalid_arguments', `\`${rune}\` cannot be called with arguments\nhttps://svelte.dev/e/rune_invalid_arguments`);
+export function rune_invalid_arguments(node, values) {
+	e(node, 'rune_invalid_arguments', `${`\`${values.rune}\` cannot be called with arguments`}\nhttps://svelte.dev/e/${'rune_invalid_arguments'}`);
 }
 
 /**
  * `%rune%` must be called with %args%
  * @param {null | number | NodeLike} node
- * @param {string} rune
- * @param {string} args
+ * @param {{ "rune": string, "args": string }} values
  * @returns {never}
  */
-export function rune_invalid_arguments_length(node, rune, args) {
-	e(node, 'rune_invalid_arguments_length', `\`${rune}\` must be called with ${args}\nhttps://svelte.dev/e/rune_invalid_arguments_length`);
+export function rune_invalid_arguments_length(node, values) {
+	e(node, 'rune_invalid_arguments_length', `${`\`${values.rune}\` must be called with ${values.args}`}\nhttps://svelte.dev/e/${'rune_invalid_arguments_length'}`);
 }
 
 /**
  * Cannot access a computed property of a rune
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function rune_invalid_computed_property(node) {
-	e(node, 'rune_invalid_computed_property', `Cannot access a computed property of a rune\nhttps://svelte.dev/e/rune_invalid_computed_property`);
+export function rune_invalid_computed_property(node, values) {
+	e(node, 'rune_invalid_computed_property', `${`Cannot access a computed property of a rune`}\nhttps://svelte.dev/e/${'rune_invalid_computed_property'}`);
 }
 
 /**
  * `%name%` is not a valid rune
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function rune_invalid_name(node, name) {
-	e(node, 'rune_invalid_name', `\`${name}\` is not a valid rune\nhttps://svelte.dev/e/rune_invalid_name`);
+export function rune_invalid_name(node, values) {
+	e(node, 'rune_invalid_name', `${`\`${values.name}\` is not a valid rune`}\nhttps://svelte.dev/e/${'rune_invalid_name'}`);
 }
 
 /**
  * `%rune%` cannot be called with a spread argument
  * @param {null | number | NodeLike} node
- * @param {string} rune
+ * @param {{ "rune": string }} values
  * @returns {never}
  */
-export function rune_invalid_spread(node, rune) {
-	e(node, 'rune_invalid_spread', `\`${rune}\` cannot be called with a spread argument\nhttps://svelte.dev/e/rune_invalid_spread`);
+export function rune_invalid_spread(node, values) {
+	e(node, 'rune_invalid_spread', `${`\`${values.rune}\` cannot be called with a spread argument`}\nhttps://svelte.dev/e/${'rune_invalid_spread'}`);
 }
 
 /**
  * Cannot use `%rune%` rune in non-runes mode
  * @param {null | number | NodeLike} node
- * @param {string} rune
+ * @param {{ "rune": string }} values
  * @returns {never}
  */
-export function rune_invalid_usage(node, rune) {
-	e(node, 'rune_invalid_usage', `Cannot use \`${rune}\` rune in non-runes mode\nhttps://svelte.dev/e/rune_invalid_usage`);
+export function rune_invalid_usage(node, values) {
+	e(node, 'rune_invalid_usage', `${`Cannot use \`${values.rune}\` rune in non-runes mode`}\nhttps://svelte.dev/e/${'rune_invalid_usage'}`);
 }
 
 /**
  * Cannot use rune without parentheses
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function rune_missing_parentheses(node) {
-	e(node, 'rune_missing_parentheses', `Cannot use rune without parentheses\nhttps://svelte.dev/e/rune_missing_parentheses`);
+export function rune_missing_parentheses(node, values) {
+	e(node, 'rune_missing_parentheses', `${`Cannot use rune without parentheses`}\nhttps://svelte.dev/e/${'rune_missing_parentheses'}`);
 }
 
 /**
  * The `%name%` rune has been removed
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function rune_removed(node, name) {
-	e(node, 'rune_removed', `The \`${name}\` rune has been removed\nhttps://svelte.dev/e/rune_removed`);
+export function rune_removed(node, values) {
+	e(node, 'rune_removed', `${`The \`${values.name}\` rune has been removed`}\nhttps://svelte.dev/e/${'rune_removed'}`);
 }
 
 /**
  * `%name%` is now `%replacement%`
  * @param {null | number | NodeLike} node
- * @param {string} name
- * @param {string} replacement
+ * @param {{ "name": string, "replacement": string }} values
  * @returns {never}
  */
-export function rune_renamed(node, name, replacement) {
-	e(node, 'rune_renamed', `\`${name}\` is now \`${replacement}\`\nhttps://svelte.dev/e/rune_renamed`);
+export function rune_renamed(node, values) {
+	e(node, 'rune_renamed', `${`\`${values.name}\` is now \`${values.replacement}\``}\nhttps://svelte.dev/e/${'rune_renamed'}`);
 }
 
 /**
  * %name% cannot be used in runes mode
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function runes_mode_invalid_import(node, name) {
-	e(node, 'runes_mode_invalid_import', `${name} cannot be used in runes mode\nhttps://svelte.dev/e/runes_mode_invalid_import`);
+export function runes_mode_invalid_import(node, values) {
+	e(node, 'runes_mode_invalid_import', `${`${values.name} cannot be used in runes mode`}\nhttps://svelte.dev/e/${'runes_mode_invalid_import'}`);
 }
 
 /**
  * An exported snippet can only reference things declared in a `<script module>`, or other exportable snippets
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function snippet_invalid_export(node) {
-	e(node, 'snippet_invalid_export', `An exported snippet can only reference things declared in a \`<script module>\`, or other exportable snippets\nhttps://svelte.dev/e/snippet_invalid_export`);
+export function snippet_invalid_export(node, values) {
+	e(node, 'snippet_invalid_export', `${`An exported snippet can only reference things declared in a \`<script module>\`, or other exportable snippets`}\nhttps://svelte.dev/e/${'snippet_invalid_export'}`);
 }
 
 /**
  * Cannot reassign or bind to snippet parameter
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function snippet_parameter_assignment(node) {
-	e(node, 'snippet_parameter_assignment', `Cannot reassign or bind to snippet parameter\nhttps://svelte.dev/e/snippet_parameter_assignment`);
+export function snippet_parameter_assignment(node, values) {
+	e(node, 'snippet_parameter_assignment', `${`Cannot reassign or bind to snippet parameter`}\nhttps://svelte.dev/e/${'snippet_parameter_assignment'}`);
 }
 
 /**
  * `%name%` has already been declared on this class
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function state_field_duplicate(node, name) {
-	e(node, 'state_field_duplicate', `\`${name}\` has already been declared on this class\nhttps://svelte.dev/e/state_field_duplicate`);
+export function state_field_duplicate(node, values) {
+	e(node, 'state_field_duplicate', `${`\`${values.name}\` has already been declared on this class`}\nhttps://svelte.dev/e/${'state_field_duplicate'}`);
 }
 
 /**
  * Cannot assign to a state field before its declaration
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function state_field_invalid_assignment(node) {
-	e(node, 'state_field_invalid_assignment', `Cannot assign to a state field before its declaration\nhttps://svelte.dev/e/state_field_invalid_assignment`);
+export function state_field_invalid_assignment(node, values) {
+	e(node, 'state_field_invalid_assignment', `${`Cannot assign to a state field before its declaration`}\nhttps://svelte.dev/e/${'state_field_invalid_assignment'}`);
 }
 
 /**
  * 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
+ * @param {void} values
  * @returns {never}
  */
-export function state_invalid_export(node) {
-	e(node, 'state_invalid_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\nhttps://svelte.dev/e/state_invalid_export`);
+export function state_invalid_export(node, values) {
+	e(node, 'state_invalid_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`}\nhttps://svelte.dev/e/${'state_invalid_export'}`);
 }
 
 /**
  * `%rune%(...)` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.
  * @param {null | number | NodeLike} node
- * @param {string} rune
+ * @param {{ "rune": string }} values
  * @returns {never}
  */
-export function state_invalid_placement(node, rune) {
-	e(node, 'state_invalid_placement', `\`${rune}(...)\` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.\nhttps://svelte.dev/e/state_invalid_placement`);
+export function state_invalid_placement(node, values) {
+	e(node, 'state_invalid_placement', `${`\`${values.rune}(...)\` can only be used as a variable declaration initializer, a class field declaration, or the first assignment to a class field at the top level of the constructor.`}\nhttps://svelte.dev/e/${'state_invalid_placement'}`);
 }
 
 /**
  * Cannot subscribe to stores that are not declared at the top level of the component
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function store_invalid_scoped_subscription(node) {
-	e(node, 'store_invalid_scoped_subscription', `Cannot subscribe to stores that are not declared at the top level of the component\nhttps://svelte.dev/e/store_invalid_scoped_subscription`);
+export function store_invalid_scoped_subscription(node, values) {
+	e(node, 'store_invalid_scoped_subscription', `${`Cannot subscribe to stores that are not declared at the top level of the component`}\nhttps://svelte.dev/e/${'store_invalid_scoped_subscription'}`);
 }
 
 /**
  * Cannot reference store value inside `<script module>`
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function store_invalid_subscription(node) {
-	e(node, 'store_invalid_subscription', `Cannot reference store value inside \`<script module>\`\nhttps://svelte.dev/e/store_invalid_subscription`);
+export function store_invalid_subscription(node, values) {
+	e(node, 'store_invalid_subscription', `${`Cannot reference store value inside \`<script module>\``}\nhttps://svelte.dev/e/${'store_invalid_subscription'}`);
 }
 
 /**
  * Cannot reference store value outside a `.svelte` file
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function store_invalid_subscription_module(node) {
-	e(node, 'store_invalid_subscription_module', `Cannot reference store value outside a \`.svelte\` file\nhttps://svelte.dev/e/store_invalid_subscription_module`);
+export function store_invalid_subscription_module(node, values) {
+	e(node, 'store_invalid_subscription_module', `${`Cannot reference store value outside a \`.svelte\` file`}\nhttps://svelte.dev/e/${'store_invalid_subscription_module'}`);
 }
 
 /**
  * TypeScript language features like %feature% are not natively supported, and their use is generally discouraged. Outside of `<script>` tags, these features are not supported. For use within `<script>` tags, you will need to use a preprocessor to convert it to JavaScript before it gets passed to the Svelte compiler. If you are using `vitePreprocess`, make sure to specifically enable preprocessing script tags (`vitePreprocess({ script: true })`)
  * @param {null | number | NodeLike} node
- * @param {string} feature
+ * @param {{ "feature": string }} values
  * @returns {never}
  */
-export function typescript_invalid_feature(node, feature) {
-	e(node, 'typescript_invalid_feature', `TypeScript language features like ${feature} are not natively supported, and their use is generally discouraged. Outside of \`<script>\` tags, these features are not supported. For use within \`<script>\` tags, you will need to use a preprocessor to convert it to JavaScript before it gets passed to the Svelte compiler. If you are using \`vitePreprocess\`, make sure to specifically enable preprocessing script tags (\`vitePreprocess({ script: true })\`)\nhttps://svelte.dev/e/typescript_invalid_feature`);
+export function typescript_invalid_feature(node, values) {
+	e(node, 'typescript_invalid_feature', `${`TypeScript language features like ${values.feature} are not natively supported, and their use is generally discouraged. Outside of \`<script>\` tags, these features are not supported. For use within \`<script>\` tags, you will need to use a preprocessor to convert it to JavaScript before it gets passed to the Svelte compiler. If you are using \`vitePreprocess\`, make sure to specifically enable preprocessing script tags (\`vitePreprocess({ script: true })\`)`}\nhttps://svelte.dev/e/${'typescript_invalid_feature'}`);
 }
 
 /**
  * Declaration cannot be empty
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_empty_declaration(node) {
-	e(node, 'css_empty_declaration', `Declaration cannot be empty\nhttps://svelte.dev/e/css_empty_declaration`);
+export function css_empty_declaration(node, values) {
+	e(node, 'css_empty_declaration', `${`Declaration cannot be empty`}\nhttps://svelte.dev/e/${'css_empty_declaration'}`);
 }
 
 /**
  * Expected a valid CSS identifier
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_expected_identifier(node) {
-	e(node, 'css_expected_identifier', `Expected a valid CSS identifier\nhttps://svelte.dev/e/css_expected_identifier`);
+export function css_expected_identifier(node, values) {
+	e(node, 'css_expected_identifier', `${`Expected a valid CSS identifier`}\nhttps://svelte.dev/e/${'css_expected_identifier'}`);
 }
 
 /**
  * A `:global` selector cannot follow a `%name%` combinator
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function css_global_block_invalid_combinator(node, name) {
-	e(node, 'css_global_block_invalid_combinator', `A \`:global\` selector cannot follow a \`${name}\` combinator\nhttps://svelte.dev/e/css_global_block_invalid_combinator`);
+export function css_global_block_invalid_combinator(node, values) {
+	e(node, 'css_global_block_invalid_combinator', `${`A \`:global\` selector cannot follow a \`${values.name}\` combinator`}\nhttps://svelte.dev/e/${'css_global_block_invalid_combinator'}`);
 }
 
 /**
  * A top-level `:global {...}` block can only contain rules, not declarations
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_global_block_invalid_declaration(node) {
-	e(node, 'css_global_block_invalid_declaration', `A top-level \`:global {...}\` block can only contain rules, not declarations\nhttps://svelte.dev/e/css_global_block_invalid_declaration`);
+export function css_global_block_invalid_declaration(node, values) {
+	e(node, 'css_global_block_invalid_declaration', `${`A top-level \`:global {...}\` block can only contain rules, not declarations`}\nhttps://svelte.dev/e/${'css_global_block_invalid_declaration'}`);
 }
 
 /**
  * A `:global` selector cannot be part of a selector list with entries that don't contain `:global`
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_global_block_invalid_list(node) {
-	e(node, 'css_global_block_invalid_list', `A \`:global\` selector cannot be part of a selector list with entries that don't contain \`:global\`\nhttps://svelte.dev/e/css_global_block_invalid_list`);
+export function css_global_block_invalid_list(node, values) {
+	e(node, 'css_global_block_invalid_list', `${`A \`:global\` selector cannot be part of a selector list with entries that don't contain \`:global\``}\nhttps://svelte.dev/e/${'css_global_block_invalid_list'}`);
 }
 
 /**
  * A `:global` selector cannot modify an existing selector
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_global_block_invalid_modifier(node) {
-	e(node, 'css_global_block_invalid_modifier', `A \`:global\` selector cannot modify an existing selector\nhttps://svelte.dev/e/css_global_block_invalid_modifier`);
+export function css_global_block_invalid_modifier(node, values) {
+	e(node, 'css_global_block_invalid_modifier', `${`A \`:global\` selector cannot modify an existing selector`}\nhttps://svelte.dev/e/${'css_global_block_invalid_modifier'}`);
 }
 
 /**
  * A `:global` selector can only be modified if it is a descendant of other selectors
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_global_block_invalid_modifier_start(node) {
-	e(node, 'css_global_block_invalid_modifier_start', `A \`:global\` selector can only be modified if it is a descendant of other selectors\nhttps://svelte.dev/e/css_global_block_invalid_modifier_start`);
+export function css_global_block_invalid_modifier_start(node, values) {
+	e(node, 'css_global_block_invalid_modifier_start', `${`A \`:global\` selector can only be modified if it is a descendant of other selectors`}\nhttps://svelte.dev/e/${'css_global_block_invalid_modifier_start'}`);
 }
 
 /**
  * A `:global` selector cannot be inside a pseudoclass
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_global_block_invalid_placement(node) {
-	e(node, 'css_global_block_invalid_placement', `A \`:global\` selector cannot be inside a pseudoclass\nhttps://svelte.dev/e/css_global_block_invalid_placement`);
+export function css_global_block_invalid_placement(node, values) {
+	e(node, 'css_global_block_invalid_placement', `${`A \`:global\` selector cannot be inside a pseudoclass`}\nhttps://svelte.dev/e/${'css_global_block_invalid_placement'}`);
 }
 
 /**
  * `:global(...)` can be at the start or end of a selector sequence, but not in the middle
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_global_invalid_placement(node) {
-	e(node, 'css_global_invalid_placement', `\`:global(...)\` can be at the start or end of a selector sequence, but not in the middle\nhttps://svelte.dev/e/css_global_invalid_placement`);
+export function css_global_invalid_placement(node, values) {
+	e(node, 'css_global_invalid_placement', `${`\`:global(...)\` can be at the start or end of a selector sequence, but not in the middle`}\nhttps://svelte.dev/e/${'css_global_invalid_placement'}`);
 }
 
 /**
  * `:global(...)` must contain exactly one selector
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_global_invalid_selector(node) {
-	e(node, 'css_global_invalid_selector', `\`:global(...)\` must contain exactly one selector\nhttps://svelte.dev/e/css_global_invalid_selector`);
+export function css_global_invalid_selector(node, values) {
+	e(node, 'css_global_invalid_selector', `${`\`:global(...)\` must contain exactly one selector`}\nhttps://svelte.dev/e/${'css_global_invalid_selector'}`);
 }
 
 /**
  * `:global(...)` must not contain type or universal selectors when used in a compound selector
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_global_invalid_selector_list(node) {
-	e(node, 'css_global_invalid_selector_list', `\`:global(...)\` must not contain type or universal selectors when used in a compound selector\nhttps://svelte.dev/e/css_global_invalid_selector_list`);
+export function css_global_invalid_selector_list(node, values) {
+	e(node, 'css_global_invalid_selector_list', `${`\`:global(...)\` must not contain type or universal selectors when used in a compound selector`}\nhttps://svelte.dev/e/${'css_global_invalid_selector_list'}`);
 }
 
 /**
  * Nesting selectors can only be used inside a rule or as the first selector inside a lone `:global(...)`
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_nesting_selector_invalid_placement(node) {
-	e(node, 'css_nesting_selector_invalid_placement', `Nesting selectors can only be used inside a rule or as the first selector inside a lone \`:global(...)\`\nhttps://svelte.dev/e/css_nesting_selector_invalid_placement`);
+export function css_nesting_selector_invalid_placement(node, values) {
+	e(node, 'css_nesting_selector_invalid_placement', `${`Nesting selectors can only be used inside a rule or as the first selector inside a lone \`:global(...)\``}\nhttps://svelte.dev/e/${'css_nesting_selector_invalid_placement'}`);
 }
 
 /**
  * Invalid selector
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_selector_invalid(node) {
-	e(node, 'css_selector_invalid', `Invalid selector\nhttps://svelte.dev/e/css_selector_invalid`);
+export function css_selector_invalid(node, values) {
+	e(node, 'css_selector_invalid', `${`Invalid selector`}\nhttps://svelte.dev/e/${'css_selector_invalid'}`);
 }
 
 /**
  * `:global(...)` must not be followed by a type selector
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function css_type_selector_invalid_placement(node) {
-	e(node, 'css_type_selector_invalid_placement', `\`:global(...)\` must not be followed by a type selector\nhttps://svelte.dev/e/css_type_selector_invalid_placement`);
+export function css_type_selector_invalid_placement(node, values) {
+	e(node, 'css_type_selector_invalid_placement', `${`\`:global(...)\` must not be followed by a type selector`}\nhttps://svelte.dev/e/${'css_type_selector_invalid_placement'}`);
 }
 
 /**
  * An element can only have one 'animate' directive
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function animation_duplicate(node) {
-	e(node, 'animation_duplicate', `An element can only have one 'animate' directive\nhttps://svelte.dev/e/animation_duplicate`);
+export function animation_duplicate(node, values) {
+	e(node, 'animation_duplicate', `${`An element can only have one 'animate' directive`}\nhttps://svelte.dev/e/${'animation_duplicate'}`);
 }
 
 /**
  * An element that uses the `animate:` directive must be the only child of a keyed `{#each ...}` block
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @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\nhttps://svelte.dev/e/animation_invalid_placement`);
+export function animation_invalid_placement(node, values) {
+	e(node, 'animation_invalid_placement', `${`An element that uses the \`animate:\` directive must be the only child of a keyed \`{#each ...}\` block`}\nhttps://svelte.dev/e/${'animation_invalid_placement'}`);
 }
 
 /**
  * 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
+ * @param {void} values
  * @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?\nhttps://svelte.dev/e/animation_missing_key`);
+export function animation_missing_key(node, values) {
+	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?`}\nhttps://svelte.dev/e/${'animation_missing_key'}`);
 }
 
 /**
  * 'contenteditable' attribute cannot be dynamic if element uses two-way binding
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_contenteditable_dynamic(node) {
-	e(node, 'attribute_contenteditable_dynamic', `'contenteditable' attribute cannot be dynamic if element uses two-way binding\nhttps://svelte.dev/e/attribute_contenteditable_dynamic`);
+export function attribute_contenteditable_dynamic(node, values) {
+	e(node, 'attribute_contenteditable_dynamic', `${`'contenteditable' attribute cannot be dynamic if element uses two-way binding`}\nhttps://svelte.dev/e/${'attribute_contenteditable_dynamic'}`);
 }
 
 /**
  * 'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_contenteditable_missing(node) {
-	e(node, 'attribute_contenteditable_missing', `'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings\nhttps://svelte.dev/e/attribute_contenteditable_missing`);
+export function attribute_contenteditable_missing(node, values) {
+	e(node, 'attribute_contenteditable_missing', `${`'contenteditable' attribute is required for textContent, innerHTML and innerText two-way bindings`}\nhttps://svelte.dev/e/${'attribute_contenteditable_missing'}`);
 }
 
 /**
  * Attributes need to be unique
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_duplicate(node) {
-	e(node, 'attribute_duplicate', `Attributes need to be unique\nhttps://svelte.dev/e/attribute_duplicate`);
+export function attribute_duplicate(node, values) {
+	e(node, 'attribute_duplicate', `${`Attributes need to be unique`}\nhttps://svelte.dev/e/${'attribute_duplicate'}`);
 }
 
 /**
  * Attribute shorthand cannot be empty
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_empty_shorthand(node) {
-	e(node, 'attribute_empty_shorthand', `Attribute shorthand cannot be empty\nhttps://svelte.dev/e/attribute_empty_shorthand`);
+export function attribute_empty_shorthand(node, values) {
+	e(node, 'attribute_empty_shorthand', `${`Attribute shorthand cannot be empty`}\nhttps://svelte.dev/e/${'attribute_empty_shorthand'}`);
 }
 
 /**
  * Event attribute must be a JavaScript expression, not a string
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_invalid_event_handler(node) {
-	e(node, 'attribute_invalid_event_handler', `Event attribute must be a JavaScript expression, not a string\nhttps://svelte.dev/e/attribute_invalid_event_handler`);
+export function attribute_invalid_event_handler(node, values) {
+	e(node, 'attribute_invalid_event_handler', `${`Event attribute must be a JavaScript expression, not a string`}\nhttps://svelte.dev/e/${'attribute_invalid_event_handler'}`);
 }
 
 /**
  * 'multiple' attribute must be static if select uses two-way binding
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_invalid_multiple(node) {
-	e(node, 'attribute_invalid_multiple', `'multiple' attribute must be static if select uses two-way binding\nhttps://svelte.dev/e/attribute_invalid_multiple`);
+export function attribute_invalid_multiple(node, values) {
+	e(node, 'attribute_invalid_multiple', `${`'multiple' attribute must be static if select uses two-way binding`}\nhttps://svelte.dev/e/${'attribute_invalid_multiple'}`);
 }
 
 /**
  * '%name%' is not a valid attribute name
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function attribute_invalid_name(node, name) {
-	e(node, 'attribute_invalid_name', `'${name}' is not a valid attribute name\nhttps://svelte.dev/e/attribute_invalid_name`);
+export function attribute_invalid_name(node, values) {
+	e(node, 'attribute_invalid_name', `${`'${values.name}' is not a valid attribute name`}\nhttps://svelte.dev/e/${'attribute_invalid_name'}`);
 }
 
 /**
  * Comma-separated expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_invalid_sequence_expression(node) {
-	e(node, 'attribute_invalid_sequence_expression', `Comma-separated expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses\nhttps://svelte.dev/e/attribute_invalid_sequence_expression`);
+export function attribute_invalid_sequence_expression(node, values) {
+	e(node, 'attribute_invalid_sequence_expression', `${`Comma-separated expressions are not allowed as attribute/directive values in runes mode, unless wrapped in parentheses`}\nhttps://svelte.dev/e/${'attribute_invalid_sequence_expression'}`);
 }
 
 /**
  * 'type' attribute must be a static text value if input uses two-way binding
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_invalid_type(node) {
-	e(node, 'attribute_invalid_type', `'type' attribute must be a static text value if input uses two-way binding\nhttps://svelte.dev/e/attribute_invalid_type`);
+export function attribute_invalid_type(node, values) {
+	e(node, 'attribute_invalid_type', `${`'type' attribute must be a static text value if input uses two-way binding`}\nhttps://svelte.dev/e/${'attribute_invalid_type'}`);
 }
 
 /**
  * Attribute values containing `{...}` must be enclosed in quote marks, unless the value only contains the expression
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function attribute_unquoted_sequence(node) {
-	e(node, 'attribute_unquoted_sequence', `Attribute values containing \`{...}\` must be enclosed in quote marks, unless the value only contains the expression\nhttps://svelte.dev/e/attribute_unquoted_sequence`);
+export function attribute_unquoted_sequence(node, values) {
+	e(node, 'attribute_unquoted_sequence', `${`Attribute values containing \`{...}\` must be enclosed in quote marks, unless the value only contains the expression`}\nhttps://svelte.dev/e/${'attribute_unquoted_sequence'}`);
 }
 
 /**
  * `bind:group` can only bind to an Identifier or MemberExpression
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function bind_group_invalid_expression(node) {
-	e(node, 'bind_group_invalid_expression', `\`bind:group\` can only bind to an Identifier or MemberExpression\nhttps://svelte.dev/e/bind_group_invalid_expression`);
+export function bind_group_invalid_expression(node, values) {
+	e(node, 'bind_group_invalid_expression', `${`\`bind:group\` can only bind to an Identifier or MemberExpression`}\nhttps://svelte.dev/e/${'bind_group_invalid_expression'}`);
 }
 
 /**
  * Cannot `bind:group` to a snippet parameter
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function bind_group_invalid_snippet_parameter(node) {
-	e(node, 'bind_group_invalid_snippet_parameter', `Cannot \`bind:group\` to a snippet parameter\nhttps://svelte.dev/e/bind_group_invalid_snippet_parameter`);
+export function bind_group_invalid_snippet_parameter(node, values) {
+	e(node, 'bind_group_invalid_snippet_parameter', `${`Cannot \`bind:group\` to a snippet parameter`}\nhttps://svelte.dev/e/${'bind_group_invalid_snippet_parameter'}`);
 }
 
 /**
  * Can only bind to an Identifier or MemberExpression or a `{get, set}` pair
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function bind_invalid_expression(node) {
-	e(node, 'bind_invalid_expression', `Can only bind to an Identifier or MemberExpression or a \`{get, set}\` pair\nhttps://svelte.dev/e/bind_invalid_expression`);
+export function bind_invalid_expression(node, values) {
+	e(node, 'bind_invalid_expression', `${`Can only bind to an Identifier or MemberExpression or a \`{get, set}\` pair`}\nhttps://svelte.dev/e/${'bind_invalid_expression'}`);
 }
 
 /**
- * `bind:%name%` is not a valid binding. %explanation%
+ * `bind:%name%` is not a valid binding
  * @param {null | number | NodeLike} node
- * @param {string} name
- * @param {string | undefined | null} [explanation]
+ * @param {{ "name": string } | { "name": string, "explanation": string }} values
  * @returns {never}
  */
-export function bind_invalid_name(node, name, explanation) {
-	e(node, 'bind_invalid_name', `${explanation
-		? `\`bind:${name}\` is not a valid binding. ${explanation}`
-		: `\`bind:${name}\` is not a valid binding`}\nhttps://svelte.dev/e/bind_invalid_name`);
+export function bind_invalid_name(node, values) {
+	e(node, 'bind_invalid_name', `${(values?.explanation !== undefined ? `\`bind:${values.name}\` is not a valid binding. ${values.explanation}` : `\`bind:${values.name}\` is not a valid binding`)}\nhttps://svelte.dev/e/${'bind_invalid_name'}`);
 }
 
 /**
  * `bind:%name%={get, set}` must not have surrounding parentheses
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function bind_invalid_parens(node, name) {
-	e(node, 'bind_invalid_parens', `\`bind:${name}={get, set}\` must not have surrounding parentheses\nhttps://svelte.dev/e/bind_invalid_parens`);
+export function bind_invalid_parens(node, values) {
+	e(node, 'bind_invalid_parens', `${`\`bind:${values.name}={get, set}\` must not have surrounding parentheses`}\nhttps://svelte.dev/e/${'bind_invalid_parens'}`);
 }
 
 /**
  * `bind:%name%` can only be used with %elements%
  * @param {null | number | NodeLike} node
- * @param {string} name
- * @param {string} elements
+ * @param {{ "name": string, "elements": string }} values
  * @returns {never}
  */
-export function bind_invalid_target(node, name, elements) {
-	e(node, 'bind_invalid_target', `\`bind:${name}\` can only be used with ${elements}\nhttps://svelte.dev/e/bind_invalid_target`);
+export function bind_invalid_target(node, values) {
+	e(node, 'bind_invalid_target', `${`\`bind:${values.name}\` can only be used with ${values.elements}`}\nhttps://svelte.dev/e/${'bind_invalid_target'}`);
 }
 
 /**
  * Can only bind to state or props
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function bind_invalid_value(node) {
-	e(node, 'bind_invalid_value', `Can only bind to state or props\nhttps://svelte.dev/e/bind_invalid_value`);
+export function bind_invalid_value(node, values) {
+	e(node, 'bind_invalid_value', `${`Can only bind to state or props`}\nhttps://svelte.dev/e/${'bind_invalid_value'}`);
 }
 
 /**
  * %name% cannot appear more than once within a block
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function block_duplicate_clause(node, name) {
-	e(node, 'block_duplicate_clause', `${name} cannot appear more than once within a block\nhttps://svelte.dev/e/block_duplicate_clause`);
+export function block_duplicate_clause(node, values) {
+	e(node, 'block_duplicate_clause', `${`${values.name} cannot appear more than once within a block`}\nhttps://svelte.dev/e/${'block_duplicate_clause'}`);
 }
 
 /**
  * {:...} block is invalid at this position (did you forget to close the preceding element or block?)
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function block_invalid_continuation_placement(node) {
-	e(node, 'block_invalid_continuation_placement', `{:...} block is invalid at this position (did you forget to close the preceding element or block?)\nhttps://svelte.dev/e/block_invalid_continuation_placement`);
+export function block_invalid_continuation_placement(node, values) {
+	e(node, 'block_invalid_continuation_placement', `${`{:...} block is invalid at this position (did you forget to close the preceding element or block?)`}\nhttps://svelte.dev/e/${'block_invalid_continuation_placement'}`);
 }
 
 /**
  * 'elseif' should be 'else if'
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function block_invalid_elseif(node) {
-	e(node, 'block_invalid_elseif', `'elseif' should be 'else if'\nhttps://svelte.dev/e/block_invalid_elseif`);
+export function block_invalid_elseif(node, values) {
+	e(node, 'block_invalid_elseif', `${`'elseif' should be 'else if'`}\nhttps://svelte.dev/e/${'block_invalid_elseif'}`);
 }
 
 /**
  * {#%name% ...} block cannot be %location%
  * @param {null | number | NodeLike} node
- * @param {string} name
- * @param {string} location
+ * @param {{ "name": string, "location": string }} values
  * @returns {never}
  */
-export function block_invalid_placement(node, name, location) {
-	e(node, 'block_invalid_placement', `{#${name} ...} block cannot be ${location}\nhttps://svelte.dev/e/block_invalid_placement`);
+export function block_invalid_placement(node, values) {
+	e(node, 'block_invalid_placement', `${`{#${values.name} ...} block cannot be ${values.location}`}\nhttps://svelte.dev/e/${'block_invalid_placement'}`);
 }
 
 /**
  * Block was left open
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function block_unclosed(node) {
-	e(node, 'block_unclosed', `Block was left open\nhttps://svelte.dev/e/block_unclosed`);
+export function block_unclosed(node, values) {
+	e(node, 'block_unclosed', `${`Block was left open`}\nhttps://svelte.dev/e/${'block_unclosed'}`);
 }
 
 /**
  * Expected a `%character%` character immediately following the opening bracket
  * @param {null | number | NodeLike} node
- * @param {string} character
+ * @param {{ "character": string }} values
  * @returns {never}
  */
-export function block_unexpected_character(node, character) {
-	e(node, 'block_unexpected_character', `Expected a \`${character}\` character immediately following the opening bracket\nhttps://svelte.dev/e/block_unexpected_character`);
+export function block_unexpected_character(node, values) {
+	e(node, 'block_unexpected_character', `${`Expected a \`${values.character}\` character immediately following the opening bracket`}\nhttps://svelte.dev/e/${'block_unexpected_character'}`);
 }
 
 /**
  * Unexpected block closing tag
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function block_unexpected_close(node) {
-	e(node, 'block_unexpected_close', `Unexpected block closing tag\nhttps://svelte.dev/e/block_unexpected_close`);
+export function block_unexpected_close(node, values) {
+	e(node, 'block_unexpected_close', `${`Unexpected block closing tag`}\nhttps://svelte.dev/e/${'block_unexpected_close'}`);
 }
 
 /**
  * This type of directive is not valid on components
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function component_invalid_directive(node) {
-	e(node, 'component_invalid_directive', `This type of directive is not valid on components\nhttps://svelte.dev/e/component_invalid_directive`);
+export function component_invalid_directive(node, values) {
+	e(node, 'component_invalid_directive', `${`This type of directive is not valid on components`}\nhttps://svelte.dev/e/${'component_invalid_directive'}`);
 }
 
 /**
  * Cyclical dependency detected: %cycle%
  * @param {null | number | NodeLike} node
- * @param {string} cycle
+ * @param {{ "cycle": string }} values
  * @returns {never}
  */
-export function const_tag_cycle(node, cycle) {
-	e(node, 'const_tag_cycle', `Cyclical dependency detected: ${cycle}\nhttps://svelte.dev/e/const_tag_cycle`);
+export function const_tag_cycle(node, values) {
+	e(node, 'const_tag_cycle', `${`Cyclical dependency detected: ${values.cycle}`}\nhttps://svelte.dev/e/${'const_tag_cycle'}`);
 }
 
 /**
  * {@const ...} must consist of a single variable declaration
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function const_tag_invalid_expression(node) {
-	e(node, 'const_tag_invalid_expression', `{@const ...} must consist of a single variable declaration\nhttps://svelte.dev/e/const_tag_invalid_expression`);
+export function const_tag_invalid_expression(node, values) {
+	e(node, 'const_tag_invalid_expression', `${`{@const ...} must consist of a single variable declaration`}\nhttps://svelte.dev/e/${'const_tag_invalid_expression'}`);
 }
 
 /**
  * `{@const}` must be the immediate child of `{#snippet}`, `{#if}`, `{:else if}`, `{:else}`, `{#each}`, `{:then}`, `{:catch}`, `<svelte:fragment>`, `<svelte:boundary>` or `<Component>`
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function const_tag_invalid_placement(node) {
-	e(node, 'const_tag_invalid_placement', `\`{@const}\` must be the immediate child of \`{#snippet}\`, \`{#if}\`, \`{:else if}\`, \`{:else}\`, \`{#each}\`, \`{:then}\`, \`{:catch}\`, \`<svelte:fragment>\`, \`<svelte:boundary>\` or \`<Component>\`\nhttps://svelte.dev/e/const_tag_invalid_placement`);
+export function const_tag_invalid_placement(node, values) {
+	e(node, 'const_tag_invalid_placement', `${`\`{@const}\` must be the immediate child of \`{#snippet}\`, \`{#if}\`, \`{:else if}\`, \`{:else}\`, \`{#each}\`, \`{:then}\`, \`{:catch}\`, \`<svelte:fragment>\`, \`<svelte:boundary>\` or \`<Component>\``}\nhttps://svelte.dev/e/${'const_tag_invalid_placement'}`);
 }
 
 /**
  * The `{@const %name% = ...}` declaration is not available in this snippet
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function const_tag_invalid_reference(node, name) {
-	e(node, 'const_tag_invalid_reference', `The \`{@const ${name} = ...}\` declaration is not available in this snippet\nhttps://svelte.dev/e/const_tag_invalid_reference`);
+export function const_tag_invalid_reference(node, values) {
+	e(node, 'const_tag_invalid_reference', `${`The \`{@const ${values.name} = ...}\` declaration is not available in this snippet`}\nhttps://svelte.dev/e/${'const_tag_invalid_reference'}`);
 }
 
 /**
  * {@debug ...} arguments must be identifiers, not arbitrary expressions
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function debug_tag_invalid_arguments(node) {
-	e(node, 'debug_tag_invalid_arguments', `{@debug ...} arguments must be identifiers, not arbitrary expressions\nhttps://svelte.dev/e/debug_tag_invalid_arguments`);
+export function debug_tag_invalid_arguments(node, values) {
+	e(node, 'debug_tag_invalid_arguments', `${`{@debug ...} arguments must be identifiers, not arbitrary expressions`}\nhttps://svelte.dev/e/${'debug_tag_invalid_arguments'}`);
 }
 
 /**
  * Declaration tags must be `let` or `const` declarations
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function declaration_tag_invalid_type(node) {
-	e(node, 'declaration_tag_invalid_type', `Declaration tags must be \`let\` or \`const\` declarations\nhttps://svelte.dev/e/declaration_tag_invalid_type`);
+export function declaration_tag_invalid_type(node, values) {
+	e(node, 'declaration_tag_invalid_type', `${`Declaration tags must be \`let\` or \`const\` declarations`}\nhttps://svelte.dev/e/${'declaration_tag_invalid_type'}`);
 }
 
 /**
  * Declaration tags cannot be used in legacy mode
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function declaration_tag_no_legacy_mode(node) {
-	e(node, 'declaration_tag_no_legacy_mode', `Declaration tags cannot be used in legacy mode\nhttps://svelte.dev/e/declaration_tag_no_legacy_mode`);
+export function declaration_tag_no_legacy_mode(node, values) {
+	e(node, 'declaration_tag_no_legacy_mode', `${`Declaration tags cannot be used in legacy mode`}\nhttps://svelte.dev/e/${'declaration_tag_no_legacy_mode'}`);
 }
 
 /**
  * Directive value must be a JavaScript expression enclosed in curly braces
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function directive_invalid_value(node) {
-	e(node, 'directive_invalid_value', `Directive value must be a JavaScript expression enclosed in curly braces\nhttps://svelte.dev/e/directive_invalid_value`);
+export function directive_invalid_value(node, values) {
+	e(node, 'directive_invalid_value', `${`Directive value must be a JavaScript expression enclosed in curly braces`}\nhttps://svelte.dev/e/${'directive_invalid_value'}`);
 }
 
 /**
  * `%type%` name cannot be empty
  * @param {null | number | NodeLike} node
- * @param {string} type
+ * @param {{ "type": string }} values
  * @returns {never}
  */
-export function directive_missing_name(node, type) {
-	e(node, 'directive_missing_name', `\`${type}\` name cannot be empty\nhttps://svelte.dev/e/directive_missing_name`);
+export function directive_missing_name(node, values) {
+	e(node, 'directive_missing_name', `${`\`${values.type}\` name cannot be empty`}\nhttps://svelte.dev/e/${'directive_missing_name'}`);
 }
 
 /**
  * An `{#each ...}` block without an `as` clause cannot have a key
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function each_key_without_as(node) {
-	e(node, 'each_key_without_as', `An \`{#each ...}\` block without an \`as\` clause cannot have a key\nhttps://svelte.dev/e/each_key_without_as`);
+export function each_key_without_as(node, values) {
+	e(node, 'each_key_without_as', `${`An \`{#each ...}\` block without an \`as\` clause cannot have a key`}\nhttps://svelte.dev/e/${'each_key_without_as'}`);
 }
 
 /**
  * `</%name%>` attempted to close an element that was not open
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function element_invalid_closing_tag(node, name) {
-	e(node, 'element_invalid_closing_tag', `\`</${name}>\` attempted to close an element that was not open\nhttps://svelte.dev/e/element_invalid_closing_tag`);
+export function element_invalid_closing_tag(node, values) {
+	e(node, 'element_invalid_closing_tag', `${`\`</${values.name}>\` attempted to close an element that was not open`}\nhttps://svelte.dev/e/${'element_invalid_closing_tag'}`);
 }
 
 /**
  * `</%name%>` attempted to close element that was already automatically closed by `<%reason%>` (cannot nest `<%reason%>` inside `<%name%>`)
  * @param {null | number | NodeLike} node
- * @param {string} name
- * @param {string} reason
+ * @param {{ "name": string, "reason": string }} values
  * @returns {never}
  */
-export function element_invalid_closing_tag_autoclosed(node, name, reason) {
-	e(node, 'element_invalid_closing_tag_autoclosed', `\`</${name}>\` attempted to close element that was already automatically closed by \`<${reason}>\` (cannot nest \`<${reason}>\` inside \`<${name}>\`)\nhttps://svelte.dev/e/element_invalid_closing_tag_autoclosed`);
+export function element_invalid_closing_tag_autoclosed(node, values) {
+	e(node, 'element_invalid_closing_tag_autoclosed', `${`\`</${values.name}>\` attempted to close element that was already automatically closed by \`<${values.reason}>\` (cannot nest \`<${values.reason}>\` inside \`<${values.name}>\`)`}\nhttps://svelte.dev/e/${'element_invalid_closing_tag_autoclosed'}`);
 }
 
 /**
  * `<%name%>` was left open
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function element_unclosed(node, name) {
-	e(node, 'element_unclosed', `\`<${name}>\` was left open\nhttps://svelte.dev/e/element_unclosed`);
+export function element_unclosed(node, values) {
+	e(node, 'element_unclosed', `${`\`<${values.name}>\` was left open`}\nhttps://svelte.dev/e/${'element_unclosed'}`);
 }
 
 /**
  * Event modifiers other than 'once' can only be used on DOM elements
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function event_handler_invalid_component_modifier(node) {
-	e(node, 'event_handler_invalid_component_modifier', `Event modifiers other than 'once' can only be used on DOM elements\nhttps://svelte.dev/e/event_handler_invalid_component_modifier`);
+export function event_handler_invalid_component_modifier(node, values) {
+	e(node, 'event_handler_invalid_component_modifier', `${`Event modifiers other than 'once' can only be used on DOM elements`}\nhttps://svelte.dev/e/${'event_handler_invalid_component_modifier'}`);
 }
 
 /**
  * Valid event modifiers are %list%
  * @param {null | number | NodeLike} node
- * @param {string} list
+ * @param {{ "list": string }} values
  * @returns {never}
  */
-export function event_handler_invalid_modifier(node, list) {
-	e(node, 'event_handler_invalid_modifier', `Valid event modifiers are ${list}\nhttps://svelte.dev/e/event_handler_invalid_modifier`);
+export function event_handler_invalid_modifier(node, values) {
+	e(node, 'event_handler_invalid_modifier', `${`Valid event modifiers are ${values.list}`}\nhttps://svelte.dev/e/${'event_handler_invalid_modifier'}`);
 }
 
 /**
  * The '%modifier1%' and '%modifier2%' modifiers cannot be used together
  * @param {null | number | NodeLike} node
- * @param {string} modifier1
- * @param {string} modifier2
+ * @param {{ "modifier1": string, "modifier2": string }} values
  * @returns {never}
  */
-export function event_handler_invalid_modifier_combination(node, modifier1, modifier2) {
-	e(node, 'event_handler_invalid_modifier_combination', `The '${modifier1}' and '${modifier2}' modifiers cannot be used together\nhttps://svelte.dev/e/event_handler_invalid_modifier_combination`);
+export function event_handler_invalid_modifier_combination(node, values) {
+	e(node, 'event_handler_invalid_modifier_combination', `${`The '${values.modifier1}' and '${values.modifier2}' modifiers cannot be used together`}\nhttps://svelte.dev/e/${'event_handler_invalid_modifier_combination'}`);
 }
 
 /**
  * Expected attribute value
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function expected_attribute_value(node) {
-	e(node, 'expected_attribute_value', `Expected attribute value\nhttps://svelte.dev/e/expected_attribute_value`);
+export function expected_attribute_value(node, values) {
+	e(node, 'expected_attribute_value', `${`Expected attribute value`}\nhttps://svelte.dev/e/${'expected_attribute_value'}`);
 }
 
 /**
  * Expected 'if', 'each', 'await', 'key' or 'snippet'
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function expected_block_type(node) {
-	e(node, 'expected_block_type', `Expected 'if', 'each', 'await', 'key' or 'snippet'\nhttps://svelte.dev/e/expected_block_type`);
+export function expected_block_type(node, values) {
+	e(node, 'expected_block_type', `${`Expected 'if', 'each', 'await', 'key' or 'snippet'`}\nhttps://svelte.dev/e/${'expected_block_type'}`);
 }
 
 /**
  * Expected an identifier
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function expected_identifier(node) {
-	e(node, 'expected_identifier', `Expected an identifier\nhttps://svelte.dev/e/expected_identifier`);
+export function expected_identifier(node, values) {
+	e(node, 'expected_identifier', `${`Expected an identifier`}\nhttps://svelte.dev/e/${'expected_identifier'}`);
 }
 
 /**
  * Expected identifier or destructure pattern
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function expected_pattern(node) {
-	e(node, 'expected_pattern', `Expected identifier or destructure pattern\nhttps://svelte.dev/e/expected_pattern`);
+export function expected_pattern(node, values) {
+	e(node, 'expected_pattern', `${`Expected identifier or destructure pattern`}\nhttps://svelte.dev/e/${'expected_pattern'}`);
 }
 
 /**
  * Expected 'html', 'render', 'attach', 'const', or 'debug'
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function expected_tag(node) {
-	e(node, 'expected_tag', `Expected 'html', 'render', 'attach', 'const', or 'debug'\nhttps://svelte.dev/e/expected_tag`);
+export function expected_tag(node, values) {
+	e(node, 'expected_tag', `${`Expected 'html', 'render', 'attach', 'const', or 'debug'`}\nhttps://svelte.dev/e/${'expected_tag'}`);
 }
 
 /**
  * Expected token %token%
  * @param {null | number | NodeLike} node
- * @param {string} token
+ * @param {{ "token": string }} values
  * @returns {never}
  */
-export function expected_token(node, token) {
-	e(node, 'expected_token', `Expected token ${token}\nhttps://svelte.dev/e/expected_token`);
+export function expected_token(node, values) {
+	e(node, 'expected_token', `${`Expected token ${values.token}`}\nhttps://svelte.dev/e/${'expected_token'}`);
 }
 
 /**
  * Expected whitespace
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function expected_whitespace(node) {
-	e(node, 'expected_whitespace', `Expected whitespace\nhttps://svelte.dev/e/expected_whitespace`);
+export function expected_whitespace(node, values) {
+	e(node, 'expected_whitespace', `${`Expected whitespace`}\nhttps://svelte.dev/e/${'expected_whitespace'}`);
 }
 
 /**
  * `use:`, `transition:` and `animate:` directives, attachments and bindings do not support await expressions
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function illegal_await_expression(node) {
-	e(node, 'illegal_await_expression', `\`use:\`, \`transition:\` and \`animate:\` directives, attachments and bindings do not support await expressions\nhttps://svelte.dev/e/illegal_await_expression`);
+export function illegal_await_expression(node, values) {
+	e(node, 'illegal_await_expression', `${`\`use:\`, \`transition:\` and \`animate:\` directives, attachments and bindings do not support await expressions`}\nhttps://svelte.dev/e/${'illegal_await_expression'}`);
 }
 
 /**
  * `<%name%>` does not support non-event attributes or spread attributes
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function illegal_element_attribute(node, name) {
-	e(node, 'illegal_element_attribute', `\`<${name}>\` does not support non-event attributes or spread attributes\nhttps://svelte.dev/e/illegal_element_attribute`);
+export function illegal_element_attribute(node, values) {
+	e(node, 'illegal_element_attribute', `${`\`<${values.name}>\` does not support non-event attributes or spread attributes`}\nhttps://svelte.dev/e/${'illegal_element_attribute'}`);
 }
 
 /**
  * %message%
  * @param {null | number | NodeLike} node
- * @param {string} message
+ * @param {{ "message": string }} values
  * @returns {never}
  */
-export function js_parse_error(node, message) {
-	e(node, 'js_parse_error', `${message}\nhttps://svelte.dev/e/js_parse_error`);
+export function js_parse_error(node, values) {
+	e(node, 'js_parse_error', `${`${values.message}`}\nhttps://svelte.dev/e/${'js_parse_error'}`);
 }
 
 /**
  * `let:` directive at invalid position
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function let_directive_invalid_placement(node) {
-	e(node, 'let_directive_invalid_placement', `\`let:\` directive at invalid position\nhttps://svelte.dev/e/let_directive_invalid_placement`);
+export function let_directive_invalid_placement(node, values) {
+	e(node, 'let_directive_invalid_placement', `${`\`let:\` directive at invalid position`}\nhttps://svelte.dev/e/${'let_directive_invalid_placement'}`);
 }
 
 /**
  * Mixing old (on:%name%) and new syntaxes for event handling is not allowed. Use only the on%name% syntax
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function mixed_event_handler_syntaxes(node, name) {
-	e(node, 'mixed_event_handler_syntaxes', `Mixing old (on:${name}) and new syntaxes for event handling is not allowed. Use only the on${name} syntax\nhttps://svelte.dev/e/mixed_event_handler_syntaxes`);
+export function mixed_event_handler_syntaxes(node, values) {
+	e(node, 'mixed_event_handler_syntaxes', `${`Mixing old (on:${values.name}) and new syntaxes for event handling is not allowed. Use only the on${values.name} syntax`}\nhttps://svelte.dev/e/${'mixed_event_handler_syntaxes'}`);
 }
 
 /**
  * %message%. The browser will 'repair' the HTML (by moving, removing, or inserting elements) which breaks Svelte's assumptions about the structure of your components.
  * @param {null | number | NodeLike} node
- * @param {string} message
+ * @param {{ "message": string }} values
  * @returns {never}
  */
-export function node_invalid_placement(node, message) {
-	e(node, 'node_invalid_placement', `${message}. The browser will 'repair' the HTML (by moving, removing, or inserting elements) which breaks Svelte's assumptions about the structure of your components.\nhttps://svelte.dev/e/node_invalid_placement`);
+export function node_invalid_placement(node, values) {
+	e(node, 'node_invalid_placement', `${`${values.message}. The browser will 'repair' the HTML (by moving, removing, or inserting elements) which breaks Svelte's assumptions about the structure of your components.`}\nhttps://svelte.dev/e/${'node_invalid_placement'}`);
 }
 
 /**
  * Calling a snippet function using apply, bind or call is not allowed
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function render_tag_invalid_call_expression(node) {
-	e(node, 'render_tag_invalid_call_expression', `Calling a snippet function using apply, bind or call is not allowed\nhttps://svelte.dev/e/render_tag_invalid_call_expression`);
+export function render_tag_invalid_call_expression(node, values) {
+	e(node, 'render_tag_invalid_call_expression', `${`Calling a snippet function using apply, bind or call is not allowed`}\nhttps://svelte.dev/e/${'render_tag_invalid_call_expression'}`);
 }
 
 /**
  * `{@render ...}` tags can only contain call expressions
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function render_tag_invalid_expression(node) {
-	e(node, 'render_tag_invalid_expression', `\`{@render ...}\` tags can only contain call expressions\nhttps://svelte.dev/e/render_tag_invalid_expression`);
+export function render_tag_invalid_expression(node, values) {
+	e(node, 'render_tag_invalid_expression', `${`\`{@render ...}\` tags can only contain call expressions`}\nhttps://svelte.dev/e/${'render_tag_invalid_expression'}`);
 }
 
 /**
  * cannot use spread arguments in `{@render ...}` tags
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function render_tag_invalid_spread_argument(node) {
-	e(node, 'render_tag_invalid_spread_argument', `cannot use spread arguments in \`{@render ...}\` tags\nhttps://svelte.dev/e/render_tag_invalid_spread_argument`);
+export function render_tag_invalid_spread_argument(node, values) {
+	e(node, 'render_tag_invalid_spread_argument', `${`cannot use spread arguments in \`{@render ...}\` tags`}\nhttps://svelte.dev/e/${'render_tag_invalid_spread_argument'}`);
 }
 
 /**
  * A component can have a single top-level `<script>` element and/or a single top-level `<script module>` element
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function script_duplicate(node) {
-	e(node, 'script_duplicate', `A component can have a single top-level \`<script>\` element and/or a single top-level \`<script module>\` element\nhttps://svelte.dev/e/script_duplicate`);
+export function script_duplicate(node, values) {
+	e(node, 'script_duplicate', `${`A component can have a single top-level \`<script>\` element and/or a single top-level \`<script module>\` element`}\nhttps://svelte.dev/e/${'script_duplicate'}`);
 }
 
 /**
  * If the `%name%` attribute is supplied, it must be a boolean attribute
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function script_invalid_attribute_value(node, name) {
-	e(node, 'script_invalid_attribute_value', `If the \`${name}\` attribute is supplied, it must be a boolean attribute\nhttps://svelte.dev/e/script_invalid_attribute_value`);
+export function script_invalid_attribute_value(node, values) {
+	e(node, 'script_invalid_attribute_value', `${`If the \`${values.name}\` attribute is supplied, it must be a boolean attribute`}\nhttps://svelte.dev/e/${'script_invalid_attribute_value'}`);
 }
 
 /**
  * If the context attribute is supplied, its value must be "module"
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function script_invalid_context(node) {
-	e(node, 'script_invalid_context', `If the context attribute is supplied, its value must be "module"\nhttps://svelte.dev/e/script_invalid_context`);
+export function script_invalid_context(node, values) {
+	e(node, 'script_invalid_context', `${`If the context attribute is supplied, its value must be "module"`}\nhttps://svelte.dev/e/${'script_invalid_context'}`);
 }
 
 /**
  * The `%name%` attribute is reserved and cannot be used
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function script_reserved_attribute(node, name) {
-	e(node, 'script_reserved_attribute', `The \`${name}\` attribute is reserved and cannot be used\nhttps://svelte.dev/e/script_reserved_attribute`);
+export function script_reserved_attribute(node, values) {
+	e(node, 'script_reserved_attribute', `${`The \`${values.name}\` attribute is reserved and cannot be used`}\nhttps://svelte.dev/e/${'script_reserved_attribute'}`);
 }
 
 /**
  * Duplicate slot name '%name%' in <%component%>
  * @param {null | number | NodeLike} node
- * @param {string} name
- * @param {string} component
+ * @param {{ "name": string, "component": string }} values
  * @returns {never}
  */
-export function slot_attribute_duplicate(node, name, component) {
-	e(node, 'slot_attribute_duplicate', `Duplicate slot name '${name}' in <${component}>\nhttps://svelte.dev/e/slot_attribute_duplicate`);
+export function slot_attribute_duplicate(node, values) {
+	e(node, 'slot_attribute_duplicate', `${`Duplicate slot name '${values.name}' in <${values.component}>`}\nhttps://svelte.dev/e/${'slot_attribute_duplicate'}`);
 }
 
 /**
  * slot attribute must be a static value
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function slot_attribute_invalid(node) {
-	e(node, 'slot_attribute_invalid', `slot attribute must be a static value\nhttps://svelte.dev/e/slot_attribute_invalid`);
+export function slot_attribute_invalid(node, values) {
+	e(node, 'slot_attribute_invalid', `${`slot attribute must be a static value`}\nhttps://svelte.dev/e/${'slot_attribute_invalid'}`);
 }
 
 /**
  * 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 {void} values
  * @returns {never}
  */
-export function slot_attribute_invalid_placement(node) {
-	e(node, 'slot_attribute_invalid_placement', `Element with a slot='...' attribute must be a child of a component or a descendant of a custom element\nhttps://svelte.dev/e/slot_attribute_invalid_placement`);
+export function slot_attribute_invalid_placement(node, values) {
+	e(node, 'slot_attribute_invalid_placement', `${`Element with a slot='...' attribute must be a child of a component or a descendant of a custom element`}\nhttps://svelte.dev/e/${'slot_attribute_invalid_placement'}`);
 }
 
 /**
  * Found default slot content alongside an explicit slot="default"
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function slot_default_duplicate(node) {
-	e(node, 'slot_default_duplicate', `Found default slot content alongside an explicit slot="default"\nhttps://svelte.dev/e/slot_default_duplicate`);
+export function slot_default_duplicate(node, values) {
+	e(node, 'slot_default_duplicate', `${`Found default slot content alongside an explicit slot="default"`}\nhttps://svelte.dev/e/${'slot_default_duplicate'}`);
 }
 
 /**
  * `<slot>` can only receive attributes and (optionally) let directives
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function slot_element_invalid_attribute(node) {
-	e(node, 'slot_element_invalid_attribute', `\`<slot>\` can only receive attributes and (optionally) let directives\nhttps://svelte.dev/e/slot_element_invalid_attribute`);
+export function slot_element_invalid_attribute(node, values) {
+	e(node, 'slot_element_invalid_attribute', `${`\`<slot>\` can only receive attributes and (optionally) let directives`}\nhttps://svelte.dev/e/${'slot_element_invalid_attribute'}`);
 }
 
 /**
  * slot attribute must be a static value
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function slot_element_invalid_name(node) {
-	e(node, 'slot_element_invalid_name', `slot attribute must be a static value\nhttps://svelte.dev/e/slot_element_invalid_name`);
+export function slot_element_invalid_name(node, values) {
+	e(node, 'slot_element_invalid_name', `${`slot attribute must be a static value`}\nhttps://svelte.dev/e/${'slot_element_invalid_name'}`);
 }
 
 /**
  * `default` is a reserved word — it cannot be used as a slot name
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function slot_element_invalid_name_default(node) {
-	e(node, 'slot_element_invalid_name_default', `\`default\` is a reserved word — it cannot be used as a slot name\nhttps://svelte.dev/e/slot_element_invalid_name_default`);
+export function slot_element_invalid_name_default(node, values) {
+	e(node, 'slot_element_invalid_name_default', `${`\`default\` is a reserved word — it cannot be used as a slot name`}\nhttps://svelte.dev/e/${'slot_element_invalid_name_default'}`);
 }
 
 /**
  * Cannot use `<slot>` syntax and `{@render ...}` tags in the same component. Migrate towards `{@render ...}` tags completely
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function slot_snippet_conflict(node) {
-	e(node, 'slot_snippet_conflict', `Cannot use \`<slot>\` syntax and \`{@render ...}\` tags in the same component. Migrate towards \`{@render ...}\` tags completely\nhttps://svelte.dev/e/slot_snippet_conflict`);
+export function slot_snippet_conflict(node, values) {
+	e(node, 'slot_snippet_conflict', `${`Cannot use \`<slot>\` syntax and \`{@render ...}\` tags in the same component. Migrate towards \`{@render ...}\` tags completely`}\nhttps://svelte.dev/e/${'slot_snippet_conflict'}`);
 }
 
 /**
  * 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
+ * @param {void} values
  * @returns {never}
  */
-export function snippet_conflict(node) {
-	e(node, 'snippet_conflict', `Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block\nhttps://svelte.dev/e/snippet_conflict`);
+export function snippet_conflict(node, values) {
+	e(node, 'snippet_conflict', `${`Cannot use explicit children snippet at the same time as implicit children content. Remove either the non-whitespace content or the children snippet block`}\nhttps://svelte.dev/e/${'snippet_conflict'}`);
 }
 
 /**
  * Snippets do not support rest parameters; use an array instead
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function snippet_invalid_rest_parameter(node) {
-	e(node, 'snippet_invalid_rest_parameter', `Snippets do not support rest parameters; use an array instead\nhttps://svelte.dev/e/snippet_invalid_rest_parameter`);
+export function snippet_invalid_rest_parameter(node, values) {
+	e(node, 'snippet_invalid_rest_parameter', `${`Snippets do not support rest parameters; use an array instead`}\nhttps://svelte.dev/e/${'snippet_invalid_rest_parameter'}`);
 }
 
 /**
  * This snippet is shadowing the prop `%prop%` with the same name
  * @param {null | number | NodeLike} node
- * @param {string} prop
+ * @param {{ "prop": string }} values
  * @returns {never}
  */
-export function snippet_shadowing_prop(node, prop) {
-	e(node, 'snippet_shadowing_prop', `This snippet is shadowing the prop \`${prop}\` with the same name\nhttps://svelte.dev/e/snippet_shadowing_prop`);
+export function snippet_shadowing_prop(node, values) {
+	e(node, 'snippet_shadowing_prop', `${`This snippet is shadowing the prop \`${values.prop}\` with the same name`}\nhttps://svelte.dev/e/${'snippet_shadowing_prop'}`);
 }
 
 /**
  * `style:` directive can only use the `important` modifier
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function style_directive_invalid_modifier(node) {
-	e(node, 'style_directive_invalid_modifier', `\`style:\` directive can only use the \`important\` modifier\nhttps://svelte.dev/e/style_directive_invalid_modifier`);
+export function style_directive_invalid_modifier(node, values) {
+	e(node, 'style_directive_invalid_modifier', `${`\`style:\` directive can only use the \`important\` modifier`}\nhttps://svelte.dev/e/${'style_directive_invalid_modifier'}`);
 }
 
 /**
  * A component can have a single top-level `<style>` element
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function style_duplicate(node) {
-	e(node, 'style_duplicate', `A component can have a single top-level \`<style>\` element\nhttps://svelte.dev/e/style_duplicate`);
+export function style_duplicate(node, values) {
+	e(node, 'style_duplicate', `${`A component can have a single top-level \`<style>\` element`}\nhttps://svelte.dev/e/${'style_duplicate'}`);
 }
 
 /**
  * `<svelte:body>` does not support non-event attributes or spread attributes
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_body_illegal_attribute(node) {
-	e(node, 'svelte_body_illegal_attribute', `\`<svelte:body>\` does not support non-event attributes or spread attributes\nhttps://svelte.dev/e/svelte_body_illegal_attribute`);
+export function svelte_body_illegal_attribute(node, values) {
+	e(node, 'svelte_body_illegal_attribute', `${`\`<svelte:body>\` does not support non-event attributes or spread attributes`}\nhttps://svelte.dev/e/${'svelte_body_illegal_attribute'}`);
 }
 
 /**
  * Valid attributes on `<svelte:boundary>` are `onerror` and `failed`
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_boundary_invalid_attribute(node) {
-	e(node, 'svelte_boundary_invalid_attribute', `Valid attributes on \`<svelte:boundary>\` are \`onerror\` and \`failed\`\nhttps://svelte.dev/e/svelte_boundary_invalid_attribute`);
+export function svelte_boundary_invalid_attribute(node, values) {
+	e(node, 'svelte_boundary_invalid_attribute', `${`Valid attributes on \`<svelte:boundary>\` are \`onerror\` and \`failed\``}\nhttps://svelte.dev/e/${'svelte_boundary_invalid_attribute'}`);
 }
 
 /**
  * Attribute value must be a non-string expression
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_boundary_invalid_attribute_value(node) {
-	e(node, 'svelte_boundary_invalid_attribute_value', `Attribute value must be a non-string expression\nhttps://svelte.dev/e/svelte_boundary_invalid_attribute_value`);
+export function svelte_boundary_invalid_attribute_value(node, values) {
+	e(node, 'svelte_boundary_invalid_attribute_value', `${`Attribute value must be a non-string expression`}\nhttps://svelte.dev/e/${'svelte_boundary_invalid_attribute_value'}`);
 }
 
 /**
  * Invalid component definition — must be an `{expression}`
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_component_invalid_this(node) {
-	e(node, 'svelte_component_invalid_this', `Invalid component definition — must be an \`{expression}\`\nhttps://svelte.dev/e/svelte_component_invalid_this`);
+export function svelte_component_invalid_this(node, values) {
+	e(node, 'svelte_component_invalid_this', `${`Invalid component definition — must be an \`{expression}\``}\nhttps://svelte.dev/e/${'svelte_component_invalid_this'}`);
 }
 
 /**
  * `<svelte:component>` must have a 'this' attribute
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_component_missing_this(node) {
-	e(node, 'svelte_component_missing_this', `\`<svelte:component>\` must have a 'this' attribute\nhttps://svelte.dev/e/svelte_component_missing_this`);
+export function svelte_component_missing_this(node, values) {
+	e(node, 'svelte_component_missing_this', `${`\`<svelte:component>\` must have a 'this' attribute`}\nhttps://svelte.dev/e/${'svelte_component_missing_this'}`);
 }
 
 /**
  * `<svelte:element>` must have a 'this' attribute with a value
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_element_missing_this(node) {
-	e(node, 'svelte_element_missing_this', `\`<svelte:element>\` must have a 'this' attribute with a value\nhttps://svelte.dev/e/svelte_element_missing_this`);
+export function svelte_element_missing_this(node, values) {
+	e(node, 'svelte_element_missing_this', `${`\`<svelte:element>\` must have a 'this' attribute with a value`}\nhttps://svelte.dev/e/${'svelte_element_missing_this'}`);
 }
 
 /**
  * `<svelte:fragment>` can only have a slot attribute and (optionally) a let: directive
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_fragment_invalid_attribute(node) {
-	e(node, 'svelte_fragment_invalid_attribute', `\`<svelte:fragment>\` can only have a slot attribute and (optionally) a let: directive\nhttps://svelte.dev/e/svelte_fragment_invalid_attribute`);
+export function svelte_fragment_invalid_attribute(node, values) {
+	e(node, 'svelte_fragment_invalid_attribute', `${`\`<svelte:fragment>\` can only have a slot attribute and (optionally) a let: directive`}\nhttps://svelte.dev/e/${'svelte_fragment_invalid_attribute'}`);
 }
 
 /**
  * `<svelte:fragment>` must be the direct child of a component
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_fragment_invalid_placement(node) {
-	e(node, 'svelte_fragment_invalid_placement', `\`<svelte:fragment>\` must be the direct child of a component\nhttps://svelte.dev/e/svelte_fragment_invalid_placement`);
+export function svelte_fragment_invalid_placement(node, values) {
+	e(node, 'svelte_fragment_invalid_placement', `${`\`<svelte:fragment>\` must be the direct child of a component`}\nhttps://svelte.dev/e/${'svelte_fragment_invalid_placement'}`);
 }
 
 /**
  * `<svelte:head>` cannot have attributes nor directives
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_head_illegal_attribute(node) {
-	e(node, 'svelte_head_illegal_attribute', `\`<svelte:head>\` cannot have attributes nor directives\nhttps://svelte.dev/e/svelte_head_illegal_attribute`);
+export function svelte_head_illegal_attribute(node, values) {
+	e(node, 'svelte_head_illegal_attribute', `${`\`<svelte:head>\` cannot have attributes nor directives`}\nhttps://svelte.dev/e/${'svelte_head_illegal_attribute'}`);
 }
 
 /**
  * A component can only have one `<%name%>` element
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function svelte_meta_duplicate(node, name) {
-	e(node, 'svelte_meta_duplicate', `A component can only have one \`<${name}>\` element\nhttps://svelte.dev/e/svelte_meta_duplicate`);
+export function svelte_meta_duplicate(node, values) {
+	e(node, 'svelte_meta_duplicate', `${`A component can only have one \`<${values.name}>\` element`}\nhttps://svelte.dev/e/${'svelte_meta_duplicate'}`);
 }
 
 /**
  * <%name%> cannot have children
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function svelte_meta_invalid_content(node, name) {
-	e(node, 'svelte_meta_invalid_content', `<${name}> cannot have children\nhttps://svelte.dev/e/svelte_meta_invalid_content`);
+export function svelte_meta_invalid_content(node, values) {
+	e(node, 'svelte_meta_invalid_content', `${`<${values.name}> cannot have children`}\nhttps://svelte.dev/e/${'svelte_meta_invalid_content'}`);
 }
 
 /**
  * `<%name%>` tags cannot be inside elements or blocks
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function svelte_meta_invalid_placement(node, name) {
-	e(node, 'svelte_meta_invalid_placement', `\`<${name}>\` tags cannot be inside elements or blocks\nhttps://svelte.dev/e/svelte_meta_invalid_placement`);
+export function svelte_meta_invalid_placement(node, values) {
+	e(node, 'svelte_meta_invalid_placement', `${`\`<${values.name}>\` tags cannot be inside elements or blocks`}\nhttps://svelte.dev/e/${'svelte_meta_invalid_placement'}`);
 }
 
 /**
  * Valid `<svelte:...>` tag names are %list%
  * @param {null | number | NodeLike} node
- * @param {string} list
+ * @param {{ "list": string }} values
  * @returns {never}
  */
-export function svelte_meta_invalid_tag(node, list) {
-	e(node, 'svelte_meta_invalid_tag', `Valid \`<svelte:...>\` tag names are ${list}\nhttps://svelte.dev/e/svelte_meta_invalid_tag`);
+export function svelte_meta_invalid_tag(node, values) {
+	e(node, 'svelte_meta_invalid_tag', `${`Valid \`<svelte:...>\` tag names are ${values.list}`}\nhttps://svelte.dev/e/${'svelte_meta_invalid_tag'}`);
 }
 
 /**
  * "tag" option is deprecated — use "customElement" instead
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_options_deprecated_tag(node) {
-	e(node, 'svelte_options_deprecated_tag', `"tag" option is deprecated — use "customElement" instead\nhttps://svelte.dev/e/svelte_options_deprecated_tag`);
+export function svelte_options_deprecated_tag(node, values) {
+	e(node, 'svelte_options_deprecated_tag', `${`"tag" option is deprecated — use "customElement" instead`}\nhttps://svelte.dev/e/${'svelte_options_deprecated_tag'}`);
 }
 
 /**
  * `<svelte:options>` can only receive static attributes
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_options_invalid_attribute(node) {
-	e(node, 'svelte_options_invalid_attribute', `\`<svelte:options>\` can only receive static attributes\nhttps://svelte.dev/e/svelte_options_invalid_attribute`);
+export function svelte_options_invalid_attribute(node, values) {
+	e(node, 'svelte_options_invalid_attribute', `${`\`<svelte:options>\` can only receive static attributes`}\nhttps://svelte.dev/e/${'svelte_options_invalid_attribute'}`);
 }
 
 /**
  * Value must be %list%, if specified
  * @param {null | number | NodeLike} node
- * @param {string} list
+ * @param {{ "list": string }} values
  * @returns {never}
  */
-export function svelte_options_invalid_attribute_value(node, list) {
-	e(node, 'svelte_options_invalid_attribute_value', `Value must be ${list}, if specified\nhttps://svelte.dev/e/svelte_options_invalid_attribute_value`);
+export function svelte_options_invalid_attribute_value(node, values) {
+	e(node, 'svelte_options_invalid_attribute_value', `${`Value must be ${values.list}, if specified`}\nhttps://svelte.dev/e/${'svelte_options_invalid_attribute_value'}`);
 }
 
 /**
  * "customElement" must be a string literal defining a valid custom element name or an object of the form { tag?: string; shadow?: "open" | "none" | `ShadowRootInit`; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_options_invalid_customelement(node) {
-	e(node, 'svelte_options_invalid_customelement', `"customElement" must be a string literal defining a valid custom element name or an object of the form { tag?: string; shadow?: "open" | "none" | \`ShadowRootInit\`; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }\nhttps://svelte.dev/e/svelte_options_invalid_customelement`);
+export function svelte_options_invalid_customelement(node, values) {
+	e(node, 'svelte_options_invalid_customelement', `${`"customElement" must be a string literal defining a valid custom element name or an object of the form { tag?: string; shadow?: "open" | "none" | \`ShadowRootInit\`; props?: { [key: string]: { attribute?: string; reflect?: boolean; type: .. } } }`}\nhttps://svelte.dev/e/${'svelte_options_invalid_customelement'}`);
 }
 
 /**
  * "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
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_options_invalid_customelement_props(node) {
-	e(node, 'svelte_options_invalid_customelement_props', `"props" must be a statically analyzable object literal of the form "{ [key: string]: { attribute?: string; reflect?: boolean; type?: "String" | "Boolean" | "Number" | "Array" | "Object" }"\nhttps://svelte.dev/e/svelte_options_invalid_customelement_props`);
+export function svelte_options_invalid_customelement_props(node, values) {
+	e(node, 'svelte_options_invalid_customelement_props', `${`"props" must be a statically analyzable object literal of the form "{ [key: string]: { attribute?: string; reflect?: boolean; type?: "String" | "Boolean" | "Number" | "Array" | "Object" }"`}\nhttps://svelte.dev/e/${'svelte_options_invalid_customelement_props'}`);
 }
 
 /**
  * "shadow" must be either "open", "none" or `ShadowRootInit` object.
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_options_invalid_customelement_shadow(node) {
-	e(node, 'svelte_options_invalid_customelement_shadow', `"shadow" must be either "open", "none" or \`ShadowRootInit\` object.\nhttps://svelte.dev/e/svelte_options_invalid_customelement_shadow`);
+export function svelte_options_invalid_customelement_shadow(node, values) {
+	e(node, 'svelte_options_invalid_customelement_shadow', `${`"shadow" must be either "open", "none" or \`ShadowRootInit\` object.`}\nhttps://svelte.dev/e/${'svelte_options_invalid_customelement_shadow'}`);
 }
 
 /**
  * Tag name must be lowercase and hyphenated
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_options_invalid_tagname(node) {
-	e(node, 'svelte_options_invalid_tagname', `Tag name must be lowercase and hyphenated\nhttps://svelte.dev/e/svelte_options_invalid_tagname`);
+export function svelte_options_invalid_tagname(node, values) {
+	e(node, 'svelte_options_invalid_tagname', `${`Tag name must be lowercase and hyphenated`}\nhttps://svelte.dev/e/${'svelte_options_invalid_tagname'}`);
 }
 
 /**
  * Tag name is reserved
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_options_reserved_tagname(node) {
-	e(node, 'svelte_options_reserved_tagname', `Tag name is reserved\nhttps://svelte.dev/e/svelte_options_reserved_tagname`);
+export function svelte_options_reserved_tagname(node, values) {
+	e(node, 'svelte_options_reserved_tagname', `${`Tag name is reserved`}\nhttps://svelte.dev/e/${'svelte_options_reserved_tagname'}`);
 }
 
 /**
  * `<svelte:options>` unknown attribute '%name%'
  * @param {null | number | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function svelte_options_unknown_attribute(node, name) {
-	e(node, 'svelte_options_unknown_attribute', `\`<svelte:options>\` unknown attribute '${name}'\nhttps://svelte.dev/e/svelte_options_unknown_attribute`);
+export function svelte_options_unknown_attribute(node, values) {
+	e(node, 'svelte_options_unknown_attribute', `${`\`<svelte:options>\` unknown attribute '${values.name}'`}\nhttps://svelte.dev/e/${'svelte_options_unknown_attribute'}`);
 }
 
 /**
  * `<svelte:self>` components can only exist inside `{#if}` blocks, `{#each}` blocks, `{#snippet}` blocks or slots passed to components
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_self_invalid_placement(node) {
-	e(node, 'svelte_self_invalid_placement', `\`<svelte:self>\` components can only exist inside \`{#if}\` blocks, \`{#each}\` blocks, \`{#snippet}\` blocks or slots passed to components\nhttps://svelte.dev/e/svelte_self_invalid_placement`);
+export function svelte_self_invalid_placement(node, values) {
+	e(node, 'svelte_self_invalid_placement', `${`\`<svelte:self>\` components can only exist inside \`{#if}\` blocks, \`{#each}\` blocks, \`{#snippet}\` blocks or slots passed to components`}\nhttps://svelte.dev/e/${'svelte_self_invalid_placement'}`);
 }
 
 /**
  * Expected a valid element or component name. Components must have a valid variable name or dot notation expression
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function tag_invalid_name(node) {
-	e(node, 'tag_invalid_name', `Expected a valid element or component name. Components must have a valid variable name or dot notation expression\nhttps://svelte.dev/e/tag_invalid_name`);
+export function tag_invalid_name(node, values) {
+	e(node, 'tag_invalid_name', `${`Expected a valid element or component name. Components must have a valid variable name or dot notation expression`}\nhttps://svelte.dev/e/${'tag_invalid_name'}`);
 }
 
 /**
  * {@%name% ...} tag cannot be %location%
  * @param {null | number | NodeLike} node
- * @param {string} name
- * @param {string} location
+ * @param {{ "name": string, "location": string }} values
  * @returns {never}
  */
-export function tag_invalid_placement(node, name, location) {
-	e(node, 'tag_invalid_placement', `{@${name} ...} tag cannot be ${location}\nhttps://svelte.dev/e/tag_invalid_placement`);
+export function tag_invalid_placement(node, values) {
+	e(node, 'tag_invalid_placement', `${`{@${values.name} ...} tag cannot be ${values.location}`}\nhttps://svelte.dev/e/${'tag_invalid_placement'}`);
 }
 
 /**
  * A `<textarea>` can have either a value attribute or (equivalently) child content, but not both
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function textarea_invalid_content(node) {
-	e(node, 'textarea_invalid_content', `A \`<textarea>\` can have either a value attribute or (equivalently) child content, but not both\nhttps://svelte.dev/e/textarea_invalid_content`);
+export function textarea_invalid_content(node, values) {
+	e(node, 'textarea_invalid_content', `${`A \`<textarea>\` can have either a value attribute or (equivalently) child content, but not both`}\nhttps://svelte.dev/e/${'textarea_invalid_content'}`);
 }
 
 /**
  * `<title>` cannot have attributes nor directives
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function title_illegal_attribute(node) {
-	e(node, 'title_illegal_attribute', `\`<title>\` cannot have attributes nor directives\nhttps://svelte.dev/e/title_illegal_attribute`);
+export function title_illegal_attribute(node, values) {
+	e(node, 'title_illegal_attribute', `${`\`<title>\` cannot have attributes nor directives`}\nhttps://svelte.dev/e/${'title_illegal_attribute'}`);
 }
 
 /**
  * `<title>` can only contain text and {tags}
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function title_invalid_content(node) {
-	e(node, 'title_invalid_content', `\`<title>\` can only contain text and {tags}\nhttps://svelte.dev/e/title_invalid_content`);
+export function title_invalid_content(node, values) {
+	e(node, 'title_invalid_content', `${`\`<title>\` can only contain text and {tags}`}\nhttps://svelte.dev/e/${'title_invalid_content'}`);
 }
 
 /**
  * Cannot use `%type%:` alongside existing `%existing%:` directive
  * @param {null | number | NodeLike} node
- * @param {string} type
- * @param {string} existing
+ * @param {{ "type": string, "existing": string }} values
  * @returns {never}
  */
-export function transition_conflict(node, type, existing) {
-	e(node, 'transition_conflict', `Cannot use \`${type}:\` alongside existing \`${existing}:\` directive\nhttps://svelte.dev/e/transition_conflict`);
+export function transition_conflict(node, values) {
+	e(node, 'transition_conflict', `${`Cannot use \`${values.type}:\` alongside existing \`${values.existing}:\` directive`}\nhttps://svelte.dev/e/${'transition_conflict'}`);
 }
 
 /**
  * Cannot use multiple `%type%:` directives on a single element
  * @param {null | number | NodeLike} node
- * @param {string} type
+ * @param {{ "type": string }} values
  * @returns {never}
  */
-export function transition_duplicate(node, type) {
-	e(node, 'transition_duplicate', `Cannot use multiple \`${type}:\` directives on a single element\nhttps://svelte.dev/e/transition_duplicate`);
+export function transition_duplicate(node, values) {
+	e(node, 'transition_duplicate', `${`Cannot use multiple \`${values.type}:\` directives on a single element`}\nhttps://svelte.dev/e/${'transition_duplicate'}`);
 }
 
 /**
  * Unexpected end of input
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function unexpected_eof(node) {
-	e(node, 'unexpected_eof', `Unexpected end of input\nhttps://svelte.dev/e/unexpected_eof`);
+export function unexpected_eof(node, values) {
+	e(node, 'unexpected_eof', `${`Unexpected end of input`}\nhttps://svelte.dev/e/${'unexpected_eof'}`);
 }
 
 /**
  * '%word%' is a reserved word in JavaScript and cannot be used here
  * @param {null | number | NodeLike} node
- * @param {string} word
+ * @param {{ "word": string }} values
  * @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\nhttps://svelte.dev/e/unexpected_reserved_word`);
+export function unexpected_reserved_word(node, values) {
+	e(node, 'unexpected_reserved_word', `${`'${values.word}' is a reserved word in JavaScript and cannot be used here`}\nhttps://svelte.dev/e/${'unexpected_reserved_word'}`);
 }
 
 /**
  * Unterminated string constant
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function unterminated_string_constant(node) {
-	e(node, 'unterminated_string_constant', `Unterminated string constant\nhttps://svelte.dev/e/unterminated_string_constant`);
+export function unterminated_string_constant(node, values) {
+	e(node, 'unterminated_string_constant', `${`Unterminated string constant`}\nhttps://svelte.dev/e/${'unterminated_string_constant'}`);
 }
 
 /**
  * Void elements cannot have children or closing tags
  * @param {null | number | NodeLike} node
+ * @param {void} values
  * @returns {never}
  */
-export function void_element_invalid_content(node) {
-	e(node, 'void_element_invalid_content', `Void elements cannot have children or closing tags\nhttps://svelte.dev/e/void_element_invalid_content`);
-}
\ No newline at end of file
+export function void_element_invalid_content(node, values) {
+	e(node, 'void_element_invalid_content', `${`Void elements cannot have children or closing tags`}\nhttps://svelte.dev/e/${'void_element_invalid_content'}`);
+}
diff --git a/packages/svelte/src/compiler/phases/1-parse/acorn.js b/packages/svelte/src/compiler/phases/1-parse/acorn.js
index add61ea19f..b4b5d59c96 100644
--- a/packages/svelte/src/compiler/phases/1-parse/acorn.js
+++ b/packages/svelte/src/compiler/phases/1-parse/acorn.js
@@ -169,7 +169,7 @@ const regex_position_indicator = / \(\d+:\d+\)$/;
  * @returns {never}
  */
 function handle_parse_error(err) {
-	e.js_parse_error(err.pos, err.message.replace(regex_position_indicator, ''));
+	e.js_parse_error(err.pos, { message: err.message.replace(regex_position_indicator, '') });
 }
 
 /**
diff --git a/packages/svelte/src/compiler/phases/1-parse/index.js b/packages/svelte/src/compiler/phases/1-parse/index.js
index 8edd403487..ababe31447 100644
--- a/packages/svelte/src/compiler/phases/1-parse/index.js
+++ b/packages/svelte/src/compiler/phases/1-parse/index.js
@@ -122,7 +122,7 @@ export class Parser {
 				current.end = this.template.length;
 			} else if (current.type === 'RegularElement') {
 				current.end = current.start + 1;
-				e.element_unclosed(current, current.name);
+				e.element_unclosed(current, { name: current.name });
 			} else {
 				current.end = current.start + 1;
 				e.block_unclosed(current);
@@ -171,7 +171,7 @@ export class Parser {
 		}
 
 		if (required && (!this.loose || required_in_loose)) {
-			e.expected_token(this.index, str);
+			e.expected_token(this.index, { token: str });
 		}
 
 		return false;
@@ -244,7 +244,7 @@ export class Parser {
 			this.index = end;
 
 			if (is_reserved(name)) {
-				e.unexpected_reserved_word(start, name);
+				e.unexpected_reserved_word(start, { word: name });
 			}
 		}
 
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 2677fb3b61..78ee8bb925 100644
--- a/packages/svelte/src/compiler/phases/1-parse/read/options.js
+++ b/packages/svelte/src/compiler/phases/1-parse/read/options.js
@@ -160,7 +160,9 @@ export default function read_options(node) {
 				} else if (value === 'html' || value === 'mathml' || value === 'svg') {
 					component_options.namespace = value;
 				} else {
-					e.svelte_options_invalid_attribute_value(attribute, `"html", "mathml" or "svg"`);
+					e.svelte_options_invalid_attribute_value(attribute, {
+						list: `"html", "mathml" or "svg"`
+					});
 				}
 
 				break;
@@ -171,7 +173,7 @@ export default function read_options(node) {
 				if (value === 'injected') {
 					component_options.css = value;
 				} else {
-					e.svelte_options_invalid_attribute_value(attribute, `"injected"`);
+					e.svelte_options_invalid_attribute_value(attribute, { list: `"injected"` });
 				}
 
 				break;
@@ -189,7 +191,7 @@ export default function read_options(node) {
 				break;
 			}
 			default:
-				e.svelte_options_unknown_attribute(attribute, name);
+				e.svelte_options_unknown_attribute(attribute, { name });
 		}
 	}
 
@@ -224,7 +226,7 @@ function get_static_value(attribute) {
 function get_boolean_value(attribute) {
 	const value = get_static_value(attribute);
 	if (typeof value !== 'boolean') {
-		e.svelte_options_invalid_attribute_value(attribute, 'true or false');
+		e.svelte_options_invalid_attribute_value(attribute, { list: 'true or false' });
 	}
 	return value;
 }
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 48fb540f9c..d528c9da55 100644
--- a/packages/svelte/src/compiler/phases/1-parse/read/script.js
+++ b/packages/svelte/src/compiler/phases/1-parse/read/script.js
@@ -24,7 +24,7 @@ export function read_script(parser, start, attributes) {
 	const script_start = parser.index;
 	const data = parser.read_until_regex(regex_closing_script_tag);
 	if (parser.index >= parser.template.length) {
-		e.element_unclosed(parser.template.length, 'script');
+		e.element_unclosed(parser.template.length, { name: 'script' });
 	}
 
 	const source =
@@ -47,7 +47,7 @@ export function read_script(parser, start, attributes) {
 
 	for (const attribute of /** @type {AST.Attribute[]} */ (attributes)) {
 		if (RESERVED_ATTRIBUTES.includes(attribute.name)) {
-			e.script_reserved_attribute(attribute, attribute.name);
+			e.script_reserved_attribute(attribute, { name: attribute.name });
 		}
 
 		if (!ALLOWED_ATTRIBUTES.includes(attribute.name)) {
@@ -57,7 +57,7 @@ export function read_script(parser, start, attributes) {
 		if (attribute.name === 'module') {
 			if (attribute.value !== true) {
 				// Deliberately a generic code to future-proof for potential other attributes
-				e.script_invalid_attribute_value(attribute, attribute.name);
+				e.script_invalid_attribute_value(attribute, { name: attribute.name });
 			}
 
 			context = 'module';
diff --git a/packages/svelte/src/compiler/phases/1-parse/remove_typescript_nodes.js b/packages/svelte/src/compiler/phases/1-parse/remove_typescript_nodes.js
index f573147367..934444648f 100644
--- a/packages/svelte/src/compiler/phases/1-parse/remove_typescript_nodes.js
+++ b/packages/svelte/src/compiler/phases/1-parse/remove_typescript_nodes.js
@@ -38,7 +38,9 @@ const visitors = {
 		}
 	},
 	Decorator(node) {
-		e.typescript_invalid_feature(node, 'decorators (related TSC proposal is not stage 4 yet)');
+		e.typescript_invalid_feature(node, {
+			feature: 'decorators (related TSC proposal is not stage 4 yet)'
+		});
 	},
 	ImportDeclaration(node) {
 		if (node.importKind === 'type') return b.empty;
@@ -82,10 +84,9 @@ const visitors = {
 	},
 	PropertyDefinition(node, { next }) {
 		if (node.accessor) {
-			e.typescript_invalid_feature(
-				node,
-				'accessor fields (related TSC proposal is not stage 4 yet)'
-			);
+			e.typescript_invalid_feature(node, {
+				feature: 'accessor fields (related TSC proposal is not stage 4 yet)'
+			});
 		}
 		return next();
 	},
@@ -108,11 +109,13 @@ const visitors = {
 		return context.visit(node.expression);
 	},
 	TSEnumDeclaration(node) {
-		e.typescript_invalid_feature(node, 'enums');
+		e.typescript_invalid_feature(node, { feature: 'enums' });
 	},
 	TSParameterProperty(node, context) {
 		if ((node.readonly || node.accessibility) && context.path.at(-2)?.kind === 'constructor') {
-			e.typescript_invalid_feature(node, 'accessibility modifiers on constructor parameters');
+			e.typescript_invalid_feature(node, {
+				feature: 'accessibility modifiers on constructor parameters'
+			});
 		}
 		return context.visit(node.parameter);
 	},
@@ -171,7 +174,7 @@ const visitors = {
 		// namespaces can contain non-type nodes
 		const cleaned = /** @type {any[]} */ (node.body.body).map((entry) => context.visit(entry));
 		if (cleaned.some((entry) => entry !== b.empty)) {
-			e.typescript_invalid_feature(node, 'namespaces with non-type nodes');
+			e.typescript_invalid_feature(node, { feature: 'namespaces with non-type nodes' });
 		}
 
 		return b.empty;
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 220fe24b9d..f301bbbfa9 100644
--- a/packages/svelte/src/compiler/phases/1-parse/state/element.js
+++ b/packages/svelte/src/compiler/phases/1-parse/state/element.js
@@ -106,15 +106,17 @@ export default function element(parser) {
 					const end = parent.fragment.nodes[0]?.start ?? start;
 					w.element_implicitly_closed(
 						{ start: parent.start, end },
-						`</${name}>`,
-						`</${parent.name}>`
+						{ tag: `</${name}>`, closing: `</${parent.name}>` }
 					);
 				}
 			} else if (!parser.loose) {
 				if (parser.last_auto_closed_tag && parser.last_auto_closed_tag.tag === name) {
-					e.element_invalid_closing_tag_autoclosed(start, name, parser.last_auto_closed_tag.reason);
+					e.element_invalid_closing_tag_autoclosed(start, {
+						name,
+						reason: parser.last_auto_closed_tag.reason
+					});
 				} else {
-					e.element_invalid_closing_tag(start, name);
+					e.element_invalid_closing_tag(start, { name });
 				}
 			}
 
@@ -138,7 +140,7 @@ export default function element(parser) {
 
 	if (tag.name.startsWith('svelte:') && !meta_tags.has(tag.name)) {
 		const bounds = { start: start + 1, end: start + 1 + tag.name.length };
-		e.svelte_meta_invalid_tag(bounds, list(Array.from(meta_tags.keys())));
+		e.svelte_meta_invalid_tag(bounds, { list: list(Array.from(meta_tags.keys())) });
 	}
 
 	if (!is_valid_element_name(tag.name) && !regex_valid_component_name.test(tag.name)) {
@@ -151,11 +153,11 @@ export default function element(parser) {
 
 	if (root_only_meta_tags.has(tag.name)) {
 		if (tag.name in parser.meta_tags) {
-			e.svelte_meta_duplicate(start, tag.name);
+			e.svelte_meta_duplicate(start, { name: tag.name });
 		}
 
 		if (parent.type !== 'Root') {
-			e.svelte_meta_invalid_placement(start, tag.name);
+			e.svelte_meta_invalid_placement(start, { name: tag.name });
 		}
 
 		parser.meta_tags[tag.name] = true;
@@ -209,7 +211,10 @@ export default function element(parser) {
 
 	if (parent.type === 'RegularElement' && closing_tag_omitted(parent.name, tag.name)) {
 		const end = parent.fragment.nodes[0]?.start ?? start;
-		w.element_implicitly_closed({ start: parent.start, end }, `<${tag.name}>`, `</${parent.name}>`);
+		w.element_implicitly_closed(
+			{ start: parent.start, end },
+			{ tag: `<${tag.name}>`, closing: `</${parent.name}>` }
+		);
 		parent.end = start;
 		parser.pop();
 		parser.last_auto_closed_tag = {
@@ -504,7 +509,7 @@ function read_static_attribute(parser) {
 	}
 
 	if (parser.match_regex(regex_starts_with_quote_characters)) {
-		e.expected_token(parser.index, '=');
+		e.expected_token(parser.index, { token: '=' });
 	}
 
 	return create_attribute(tag.name, tag.loc, start, parser.index, value);
@@ -638,14 +643,14 @@ function read_attribute(parser) {
 			end = parser.index;
 		}
 	} else if (parser.match_regex(regex_starts_with_quote_characters)) {
-		e.expected_token(parser.index, '=');
+		e.expected_token(parser.index, { token: '=' });
 	}
 
 	if (type) {
 		const [directive_name, ...modifiers] = tag.name.slice(colon_index + 1).split('|');
 
 		if (directive_name === '') {
-			e.directive_missing_name({ start, end: start + colon_index + 1 }, tag.name);
+			e.directive_missing_name({ start, end: start + colon_index + 1 }, { type: tag.name });
 		}
 
 		if (type === 'StyleDirective') {
@@ -818,7 +823,7 @@ function read_attribute_value(parser) {
 			const pos = error.position?.[0];
 			if (pos !== undefined && parser.template.slice(pos - 1, pos + 1) === '/>') {
 				parser.index = pos;
-				e.expected_token(pos, quote_mark || '}');
+				e.expected_token(pos, { token: quote_mark || '}' });
 			}
 		}
 		throw error;
@@ -874,13 +879,13 @@ function read_sequence(parser, done, location) {
 				parser.eat('#');
 				// const name = parser.read_until_regex(/[^a-z]/);
 				const name = read_lowercase_name(parser);
-				e.block_invalid_placement(index, name, location);
+				e.block_invalid_placement(index, { name, location });
 			} else if (parser.match('@')) {
 				const index = parser.index - 1;
 				parser.eat('@');
 				// const name = parser.read_until_regex(/[^a-z]/);
 				const name = read_lowercase_name(parser);
-				e.tag_invalid_placement(index, name, location);
+				e.tag_invalid_placement(index, { name, location });
 			}
 
 			flush(parser.index - 1);
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 9cc0a41375..146028860a 100644
--- a/packages/svelte/src/compiler/phases/1-parse/state/tag.js
+++ b/packages/svelte/src/compiler/phases/1-parse/state/tag.js
@@ -531,7 +531,7 @@ 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')) e.expected_token(start, '{:else} or {:else if}');
+		if (!parser.eat('else')) e.expected_token(start, { token: '{:else} or {:else if}' });
 		if (parser.eat('if')) e.block_invalid_elseif(start);
 
 		parser.allow_whitespace();
@@ -580,7 +580,7 @@ function next(parser) {
 	}
 
 	if (block.type === 'EachBlock') {
-		if (!parser.eat('else')) e.expected_token(start, '{:else}');
+		if (!parser.eat('else')) e.expected_token(start, { token: '{:else}' });
 
 		parser.allow_whitespace();
 		parser.eat('}', true);
@@ -596,7 +596,7 @@ function next(parser) {
 	if (block.type === 'AwaitBlock') {
 		if (parser.eat('then')) {
 			if (block.then) {
-				e.block_duplicate_clause(start, '{:then}');
+				e.block_duplicate_clause(start, { name: '{:then}' });
 			}
 
 			if (!parser.eat('}')) {
@@ -615,7 +615,7 @@ function next(parser) {
 
 		if (parser.eat('catch')) {
 			if (block.catch) {
-				e.block_duplicate_clause(start, '{:catch}');
+				e.block_duplicate_clause(start, { name: '{:catch}' });
 			}
 
 			if (!parser.eat('}')) {
@@ -632,7 +632,7 @@ function next(parser) {
 			return;
 		}
 
-		e.expected_token(start, '{:then ...} or {:catch ...}');
+		e.expected_token(start, { token: '{:then ...} or {:catch ...}' });
 	}
 
 	e.block_invalid_continuation_placement(start);
diff --git a/packages/svelte/src/compiler/phases/1-parse/utils/bracket.js b/packages/svelte/src/compiler/phases/1-parse/utils/bracket.js
index 47299c9de5..9c604e7b90 100644
--- a/packages/svelte/src/compiler/phases/1-parse/utils/bracket.js
+++ b/packages/svelte/src/compiler/phases/1-parse/utils/bracket.js
@@ -180,7 +180,7 @@ export function match_bracket(parser, start, brackets = default_brackets) {
 			const expected = /** @type {string} */ (brackets[popped]);
 
 			if (char !== expected) {
-				e.expected_token(i - 1, expected);
+				e.expected_token(i - 1, { token: expected });
 			}
 
 			if (bracket_stack.length === 0) {
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 023d4e768e..27d8b52e9c 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
@@ -230,7 +230,7 @@ const css_visitors = {
 						}
 
 						if (child.combinator && child.combinator.name !== ' ') {
-							e.css_global_block_invalid_combinator(child, child.combinator.name);
+							e.css_global_block_invalid_combinator(child, { name: child.combinator.name });
 						}
 
 						const declaration = node.block.children.find((child) => child.type === 'Declaration');
diff --git a/packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js b/packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js
index 0964be1615..b37da1c04d 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js
@@ -35,7 +35,7 @@ const visitors = {
 		) {
 			const content = context.state.stylesheet.content;
 			const text = content.styles.substring(node.start - content.start, node.end - content.start);
-			w.css_unused_selector(node, text);
+			w.css_unused_selector(node, { name: text });
 		}
 
 		context.next();
diff --git a/packages/svelte/src/compiler/phases/2-analyze/index.js b/packages/svelte/src/compiler/phases/2-analyze/index.js
index 1cdd218ea8..5b5c9eed92 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/index.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/index.js
@@ -267,7 +267,7 @@ export function analyze_module(source, options) {
 	for (const [name, references] of scope.references) {
 		if (name[0] !== '$' || RESERVED.includes(name)) continue;
 		if (name === '$' || name[1] === '$') {
-			e.global_reference_invalid(references[0].node, name);
+			e.global_reference_invalid(references[0].node, { name });
 		}
 
 		const binding = scope.get(name.slice(1));
@@ -354,7 +354,7 @@ export function analyze_component(root, source, options) {
 	for (const [name, references] of module.scope.references) {
 		if (name[0] !== '$' || RESERVED.includes(name)) continue;
 		if (name === '$' || name[1] === '$') {
-			e.global_reference_invalid(references[0].node, name);
+			e.global_reference_invalid(references[0].node, { name });
 		}
 
 		const store_name = name.slice(1);
@@ -402,11 +402,11 @@ export function analyze_component(root, source, options) {
 
 			if (runes_option !== false) {
 				if (declaration === null && /[a-z]/.test(store_name[0])) {
-					e.global_reference_invalid(references[0].node, name);
+					e.global_reference_invalid(references[0].node, { name });
 				} else if (declaration !== null && is_rune(name)) {
 					for (const { node, path } of references) {
 						if (path.at(-1)?.type === 'CallExpression') {
-							w.store_rune_conflict(node, store_name);
+							w.store_rune_conflict(node, { name: store_name });
 						}
 					}
 				}
@@ -762,7 +762,7 @@ export function analyze_component(root, source, options) {
 										type === 'AwaitBlock' ||
 										type === 'KeyBlock'
 									) {
-										w.non_reactive_update(binding.node, name);
+										w.non_reactive_update(binding.node, { name });
 										continue outer;
 									}
 								}
@@ -770,7 +770,7 @@ export function analyze_component(root, source, options) {
 							}
 						}
 
-						w.non_reactive_update(binding.node, name);
+						w.non_reactive_update(binding.node, { name });
 						continue outer;
 					}
 				}
@@ -812,7 +812,7 @@ export function analyze_component(root, source, options) {
 					(r) => r.node !== binding.node && r.path.at(-1)?.type !== 'ExportSpecifier'
 				);
 				if (!references.length && !instance.scope.declarations.has(`$${name}`)) {
-					w.export_let_unused(binding.node, name);
+					w.export_let_unused(binding.node, { name });
 				}
 			}
 		}
@@ -830,7 +830,7 @@ export function analyze_component(root, source, options) {
 					if ([...analysis.snippets].find((snippet) => snippet.expression.name === name)) {
 						e.snippet_invalid_export(specifier);
 					} else {
-						e.export_undefined(specifier, name);
+						e.export_undefined(specifier, { name });
 					}
 				} else if (binding.initial?.type === 'SnippetBlock') {
 					// If a snippet is exported, a consumer could only import this named export and not the default export (the component).
@@ -843,10 +843,9 @@ export function analyze_component(root, source, options) {
 	}
 
 	if (analysis.event_directive_node && analysis.uses_event_attributes) {
-		e.mixed_event_handler_syntaxes(
-			analysis.event_directive_node,
-			analysis.event_directive_node.name
-		);
+		e.mixed_event_handler_syntaxes(analysis.event_directive_node, {
+			name: analysis.event_directive_node.name
+		});
 	}
 
 	for (const [node, resolved] of analysis.snippet_renderers) {
@@ -1326,7 +1325,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];
-		e.reactive_declaration_cycle(declaration[0], cycle.join(' → '));
+		e.reactive_declaration_cycle(declaration[0], { cycle: 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/visitors/AwaitBlock.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitBlock.js
index 5aa04ba3b9..44816adc8b 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitBlock.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/AwaitBlock.js
@@ -23,7 +23,7 @@ export function AwaitBlock(node, context) {
 				.match(/{(\s*):then\s+$/);
 
 			if (match && match[1] !== '') {
-				e.block_unexpected_character({ start: start - 10, end: start }, ':');
+				e.block_unexpected_character({ start: start - 10, end: start }, { character: ':' });
 			}
 		}
 
@@ -34,7 +34,7 @@ export function AwaitBlock(node, context) {
 				.match(/{(\s*):catch\s+$/);
 
 			if (match && match[1] !== '') {
-				e.block_unexpected_character({ start: start - 10, end: start }, ':');
+				e.block_unexpected_character({ start: start - 10, end: start }, { character: ':' });
 			}
 		}
 	}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/BindDirective.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/BindDirective.js
index ab541703a0..365656ef32 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/BindDirective.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/BindDirective.js
@@ -30,11 +30,12 @@ export function BindDirective(node, context) {
 		if (node.name in binding_properties) {
 			const property = binding_properties[node.name];
 			if (property.valid_elements && !property.valid_elements.includes(parent.name)) {
-				e.bind_invalid_target(
-					node,
-					node.name,
-					property.valid_elements.map((valid_element) => `\`<${valid_element}>\``).join(', ')
-				);
+				e.bind_invalid_target(node, {
+					name: node.name,
+					elements: property.valid_elements
+						.map((valid_element) => `\`<${valid_element}>\``)
+						.join(', ')
+				});
 			}
 
 			if (property.invalid_elements && property.invalid_elements.includes(parent.name)) {
@@ -49,11 +50,10 @@ export function BindDirective(node, context) {
 					.map(([property_name]) => property_name)
 					.sort();
 
-				e.bind_invalid_name(
-					node,
-					node.name,
-					`Possible bindings for <${parent.name}> are ${valid_bindings.join(', ')}`
-				);
+				e.bind_invalid_name(node, {
+					name: node.name,
+					explanation: `Possible bindings for <${parent.name}> are ${valid_bindings.join(', ')}`
+				});
 			}
 
 			if (parent.name === 'input' && node.name !== 'this') {
@@ -67,15 +67,14 @@ export function BindDirective(node, context) {
 					}
 				} else {
 					if (node.name === 'checked' && type?.value[0].data !== 'checkbox') {
-						e.bind_invalid_target(
-							node,
-							node.name,
-							`\`<input type="checkbox">\`${type?.value[0].data === 'radio' ? ` — for \`<input type="radio">\`, use \`bind:group\`` : ''}`
-						);
+						e.bind_invalid_target(node, {
+							name: node.name,
+							elements: `\`<input type="checkbox">\`${type?.value[0].data === 'radio' ? ` — for \`<input type="radio">\`, use \`bind:group\`` : ''}`
+						});
 					}
 
 					if (node.name === 'files' && type?.value[0].data !== 'file') {
-						e.bind_invalid_target(node, node.name, '`<input type="file">`');
+						e.bind_invalid_target(node, { name: node.name, elements: '`<input type="file">`' });
 					}
 				}
 			}
@@ -95,11 +94,10 @@ export function BindDirective(node, context) {
 			}
 
 			if (node.name === 'offsetWidth' && is_svg(parent.name)) {
-				e.bind_invalid_target(
-					node,
-					node.name,
-					`non-\`<svg>\` elements. Use \`bind:clientWidth\` for \`<svg>\` instead`
-				);
+				e.bind_invalid_target(node, {
+					name: node.name,
+					elements: `non-\`<svg>\` elements. Use \`bind:clientWidth\` for \`<svg>\` instead`
+				});
 			}
 
 			if (is_content_editable_binding(node.name)) {
@@ -119,11 +117,11 @@ export function BindDirective(node, context) {
 			if (match) {
 				const property = binding_properties[match];
 				if (!property.valid_elements || property.valid_elements.includes(parent.name)) {
-					e.bind_invalid_name(node, node.name, `Did you mean '${match}'?`);
+					e.bind_invalid_name(node, { name: node.name, explanation: `Did you mean '${match}'?` });
 				}
 			}
 
-			e.bind_invalid_name(node, node.name);
+			e.bind_invalid_name(node, { name: node.name });
 		}
 	}
 
@@ -149,7 +147,7 @@ export function BindDirective(node, context) {
 					i >= leading_comments_start
 				)
 			) {
-				e.bind_invalid_parens(node, node.name);
+				e.bind_invalid_parens(node, { name: node.name });
 			}
 		}
 
@@ -269,7 +267,7 @@ export function BindDirective(node, context) {
 	}
 
 	if (binding?.kind === 'each' && binding.metadata?.inside_rest) {
-		w.bind_invalid_each_rest(binding.node, binding.node.name);
+		w.bind_invalid_each_rest(binding.node, { name: binding.node.name });
 	}
 
 	context.next({ ...context.state, expression: node.metadata.expression });
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
index 312a93e5fd..1e1e41327f 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
@@ -21,7 +21,7 @@ export function CallExpression(node, context) {
 	if (rune && rune !== '$inspect') {
 		for (const arg of node.arguments) {
 			if (arg.type === 'SpreadElement') {
-				e.rune_invalid_spread(node, rune);
+				e.rune_invalid_spread(node, { rune });
 			}
 		}
 	}
@@ -36,7 +36,7 @@ export function CallExpression(node, context) {
 
 		case '$bindable':
 			if (node.arguments.length > 1) {
-				e.rune_invalid_arguments_length(node, '$bindable', 'zero or one arguments');
+				e.rune_invalid_arguments_length(node, { rune: '$bindable', args: 'zero or one arguments' });
 			}
 
 			if (
@@ -58,7 +58,7 @@ export function CallExpression(node, context) {
 
 		case '$host':
 			if (node.arguments.length > 0) {
-				e.rune_invalid_arguments(node, '$host');
+				e.rune_invalid_arguments(node, { rune: '$host' });
 			} else if (context.state.ast_type === 'module' || !context.state.analysis.custom_element) {
 				e.host_invalid_placement(node);
 			}
@@ -67,7 +67,7 @@ export function CallExpression(node, context) {
 
 		case '$props':
 			if (context.state.has_props_rune) {
-				e.props_duplicate(node, rune);
+				e.props_duplicate(node, { rune });
 			}
 
 			context.state.has_props_rune = true;
@@ -81,7 +81,7 @@ export function CallExpression(node, context) {
 			}
 
 			if (node.arguments.length > 0) {
-				e.rune_invalid_arguments(node, rune);
+				e.rune_invalid_arguments(node, { rune });
 			}
 
 			break;
@@ -90,7 +90,7 @@ export function CallExpression(node, context) {
 			const grand_parent = get_parent(context.path, -2);
 
 			if (context.state.analysis.props_id) {
-				e.props_duplicate(node, rune);
+				e.props_duplicate(node, { rune });
 			}
 
 			if (
@@ -104,7 +104,7 @@ export function CallExpression(node, context) {
 			}
 
 			if (node.arguments.length > 0) {
-				e.rune_invalid_arguments(node, rune);
+				e.rune_invalid_arguments(node, { rune });
 			}
 
 			context.state.analysis.props_id = parent.id;
@@ -122,13 +122,13 @@ export function CallExpression(node, context) {
 				is_class_property_assignment_at_constructor_root(parent, context);
 
 			if (!valid) {
-				e.state_invalid_placement(node, rune);
+				e.state_invalid_placement(node, { rune });
 			}
 
 			if ((rune === '$derived' || rune === '$derived.by') && node.arguments.length !== 1) {
-				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+				e.rune_invalid_arguments_length(node, { rune, args: 'exactly one argument' });
 			} else if (node.arguments.length > 1) {
-				e.rune_invalid_arguments_length(node, rune, 'zero or one arguments');
+				e.rune_invalid_arguments_length(node, { rune, args: 'zero or one arguments' });
 			}
 
 			break;
@@ -141,7 +141,7 @@ export function CallExpression(node, context) {
 			}
 
 			if (node.arguments.length !== 1) {
-				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+				e.rune_invalid_arguments_length(node, { rune, args: 'exactly one argument' });
 			}
 
 			// `$effect` needs context because Svelte needs to know whether it should re-run
@@ -152,14 +152,14 @@ export function CallExpression(node, context) {
 
 		case '$effect.tracking':
 			if (node.arguments.length !== 0) {
-				e.rune_invalid_arguments(node, rune);
+				e.rune_invalid_arguments(node, { rune });
 			}
 
 			break;
 
 		case '$effect.root':
 			if (node.arguments.length !== 1) {
-				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+				e.rune_invalid_arguments_length(node, { rune, args: 'exactly one argument' });
 			}
 
 			break;
@@ -173,21 +173,21 @@ export function CallExpression(node, context) {
 
 		case '$inspect':
 			if (node.arguments.length < 1) {
-				e.rune_invalid_arguments_length(node, rune, 'one or more arguments');
+				e.rune_invalid_arguments_length(node, { rune, args: 'one or more arguments' });
 			}
 
 			break;
 
 		case '$inspect().with':
 			if (node.arguments.length !== 1) {
-				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+				e.rune_invalid_arguments_length(node, { rune, args: 'exactly one argument' });
 			}
 
 			break;
 
 		case '$inspect.trace': {
 			if (node.arguments.length > 1) {
-				e.rune_invalid_arguments_length(node, rune, 'zero or one arguments');
+				e.rune_invalid_arguments_length(node, { rune, args: 'zero or one arguments' });
 			}
 
 			const grand_parent = context.path.at(-2);
@@ -228,14 +228,14 @@ export function CallExpression(node, context) {
 
 		case '$state.eager':
 			if (node.arguments.length !== 1) {
-				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+				e.rune_invalid_arguments_length(node, { rune, args: 'exactly one argument' });
 			}
 
 			break;
 
 		case '$state.snapshot':
 			if (node.arguments.length !== 1) {
-				e.rune_invalid_arguments_length(node, rune, 'exactly one argument');
+				e.rune_invalid_arguments_length(node, { rune, args: 'exactly one argument' });
 			}
 
 			break;
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js
index dd21637174..91416b4be5 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ClassBody.js
@@ -54,7 +54,7 @@ export function ClassBody(node, context) {
 
 		if (rune && is_state_creation_rune(rune)) {
 			if (state_fields.has(name)) {
-				e.state_field_duplicate(node, name);
+				e.state_field_duplicate(node, { name });
 			}
 
 			const _key = (node.type === 'AssignmentExpression' || !node.static ? '' : '@') + name;
@@ -62,7 +62,7 @@ export function ClassBody(node, context) {
 
 			// if there's already a method or assigned field, error
 			if (field && !(field.length === 1 && field[0] === 'prop')) {
-				e.duplicate_class_field(node, _key);
+				e.duplicate_class_field(node, { name: _key });
 			}
 
 			state_fields.set(name, {
@@ -84,7 +84,7 @@ export function ClassBody(node, context) {
 				fields.set(key, [child.value ? 'assigned_prop' : 'prop']);
 				continue;
 			}
-			e.duplicate_class_field(child, key);
+			e.duplicate_class_field(child, { name: key });
 		}
 
 		if (child.type === 'MethodDefinition') {
@@ -102,7 +102,7 @@ export function ClassBody(node, context) {
 					field.includes('prop') ||
 					field.includes('assigned_prop')
 				) {
-					e.duplicate_class_field(child, key);
+					e.duplicate_class_field(child, { name: key });
 				}
 				if (child.kind === 'get') {
 					if (field.length === 1 && field[0] === 'set') {
@@ -118,7 +118,7 @@ export function ClassBody(node, context) {
 					field.push(child.kind);
 					continue;
 				}
-				e.duplicate_class_field(child, key);
+				e.duplicate_class_field(child, { name: key });
 			}
 		}
 	}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/DeclarationTag.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/DeclarationTag.js
index 2f72b16c72..ddab3fc7bb 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/DeclarationTag.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/DeclarationTag.js
@@ -19,7 +19,7 @@ export function DeclarationTag(node, context) {
 			.flatMap((declaration) => extract_identifiers(declaration.id))
 			.find((id) => context.state.analysis.instance.scope.declarations.has(id.name));
 		if (duplicate) {
-			e.declaration_duplicate(duplicate, duplicate.name);
+			e.declaration_duplicate(duplicate, { name: duplicate.name });
 		}
 	}
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/EachBlock.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/EachBlock.js
index 5681966475..2d6667e708 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/EachBlock.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/EachBlock.js
@@ -20,7 +20,7 @@ export function EachBlock(node, context) {
 	const id = node.context;
 	if (id?.type === 'Identifier' && (id.name === '$state' || id.name === '$derived')) {
 		// TODO weird that this is necessary
-		e.state_invalid_placement(node, id.name);
+		e.state_invalid_placement(node, { rune: id.name });
 	}
 
 	if (node.key) {
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js
index 88fe4e6afa..bd4c936fa2 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js
@@ -14,7 +14,7 @@ export function ExpressionTag(node, context) {
 	if (in_template && context.state.parent_element) {
 		const message = is_tag_valid_with_parent('#text', context.state.parent_element);
 		if (message) {
-			e.node_invalid_placement(node, message);
+			e.node_invalid_placement(node, { message });
 		}
 	}
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js
index ebb2fc2b67..d74e48d918 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js
@@ -55,18 +55,18 @@ export function Identifier(node, context) {
 
 				if (!is_rune(name)) {
 					if (name === '$effect.active') {
-						e.rune_renamed(parent, '$effect.active', '$effect.tracking');
+						e.rune_renamed(parent, { name: '$effect.active', replacement: '$effect.tracking' });
 					}
 
 					if (name === '$state.frozen') {
-						e.rune_renamed(parent, '$state.frozen', '$state.raw');
+						e.rune_renamed(parent, { name: '$state.frozen', replacement: '$state.raw' });
 					}
 
 					if (name === '$state.is') {
-						e.rune_removed(parent, '$state.is');
+						e.rune_removed(parent, { name: '$state.is' });
 					}
 
-					e.rune_invalid_name(parent, name);
+					e.rune_invalid_name(parent, { name });
 				}
 			}
 
@@ -148,7 +148,7 @@ export function Identifier(node, context) {
 				}
 			}
 
-			w.state_referenced_locally(node, node.name, type);
+			w.state_referenced_locally(node, { name: node.name, type });
 		}
 
 		if (
@@ -183,7 +183,7 @@ export function Identifier(node, context) {
 							? grand_parent.metadata.scopes.default === binding.scope
 							: context.state.scopes.get(parent) === binding.scope
 					) {
-						e.const_tag_invalid_reference(node, node.name);
+						e.const_tag_invalid_reference(node, { name: node.name });
 					} else {
 						break;
 					}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/ImportDeclaration.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/ImportDeclaration.js
index d46218ac64..7122828e0d 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/ImportDeclaration.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/ImportDeclaration.js
@@ -22,7 +22,7 @@ export function ImportDeclaration(node, context) {
 						(specifier.imported.name === 'beforeUpdate' ||
 							specifier.imported.name === 'afterUpdate')
 					) {
-						e.runes_mode_invalid_import(specifier, specifier.imported.name);
+						e.runes_mode_invalid_import(specifier, { name: specifier.imported.name });
 					}
 				}
 			}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/OnDirective.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/OnDirective.js
index b8a0d95671..89e5ab8089 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/OnDirective.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/OnDirective.js
@@ -13,7 +13,7 @@ export function OnDirective(node, context) {
 
 		// Don't warn on component events; these might not be under the author's control so the warning would be unactionable
 		if (parent_type === 'RegularElement' || parent_type === 'SvelteElement') {
-			w.event_directive_deprecated(node, node.name);
+			w.event_directive_deprecated(node, { name: node.name });
 		}
 	}
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/RegularElement.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/RegularElement.js
index bc65bd65db..87fe936f13 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/RegularElement.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/RegularElement.js
@@ -123,7 +123,7 @@ export function RegularElement(node, context) {
 		binding.declaration_kind === 'import' &&
 		binding.references.length === 0
 	) {
-		w.component_name_lowercase(node, node.name);
+		w.component_name_lowercase(node, { name: node.name });
 	}
 
 	node.metadata.has_spread = node.attributes.some(
@@ -180,9 +180,9 @@ export function RegularElement(node, context) {
 					const message = is_tag_valid_with_parent(node.name, context.state.parent_element);
 					if (message) {
 						if (only_warn) {
-							w.node_invalid_placement_ssr(node, message);
+							w.node_invalid_placement_ssr(node, { message });
 						} else {
-							e.node_invalid_placement(node, message);
+							e.node_invalid_placement(node, { message });
 						}
 					}
 
@@ -194,9 +194,9 @@ export function RegularElement(node, context) {
 				const message = is_tag_valid_with_ancestor(node.name, ancestors);
 				if (message) {
 					if (only_warn) {
-						w.node_invalid_placement_ssr(node, message);
+						w.node_invalid_placement_ssr(node, { message });
 					} else {
-						e.node_invalid_placement(node, message);
+						e.node_invalid_placement(node, { message });
 					}
 				}
 			} else if (
@@ -220,7 +220,7 @@ export function RegularElement(node, context) {
 		!is_svg(node_name) &&
 		!is_mathml(node_name)
 	) {
-		w.element_invalid_self_closing_tag(node, node.name);
+		w.element_invalid_self_closing_tag(node, { name: node.name });
 	}
 
 	context.next({ ...context.state, parent_element: node.name });
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js
index 7618716ae5..24917d2606 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js
@@ -31,7 +31,7 @@ export function SnippetBlock(node, context) {
 		const name = node.expression.name;
 
 		if (context.state.analysis.instance.scope.declarations.has(name)) {
-			e.declaration_duplicate(node.expression, name);
+			e.declaration_duplicate(node.expression, { name });
 		}
 
 		node.metadata.can_hoist =
@@ -56,7 +56,7 @@ export function SnippetBlock(node, context) {
 				attribute.name === node.expression.name
 		)
 	) {
-		e.snippet_shadowing_prop(node, node.expression.name);
+		e.snippet_shadowing_prop(node, { prop: node.expression.name });
 	}
 
 	if (node.expression.name !== 'children') return;
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteDocument.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteDocument.js
index 23e984f607..76f4394d75 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteDocument.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteDocument.js
@@ -16,7 +16,7 @@ export function SvelteDocument(node, context) {
 		if (attribute.type === 'Attribute' && is_event_attribute(attribute)) {
 			check_global_event_reference(attribute, context);
 		} else if (attribute.type === 'SpreadAttribute' || attribute.type === 'Attribute') {
-			e.illegal_element_attribute(attribute, 'svelte:document');
+			e.illegal_element_attribute(attribute, { name: 'svelte:document' });
 		}
 	}
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteSelf.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteSelf.js
index 652a447165..32ff406964 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteSelf.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteSelf.js
@@ -29,7 +29,7 @@ export function SvelteSelf(node, context) {
 				? 'Self.svelte'
 				: /** @type {string} */ (filename.split(/[/\\]/).pop());
 
-		w.svelte_self_deprecated(node, name, basename);
+		w.svelte_self_deprecated(node, { name, basename });
 	}
 
 	visit_component(node, context);
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteWindow.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteWindow.js
index 5281c7a635..227e3e3e3b 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteWindow.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/SvelteWindow.js
@@ -16,7 +16,7 @@ export function SvelteWindow(node, context) {
 		if (attribute.type === 'Attribute' && is_event_attribute(attribute)) {
 			check_global_event_reference(attribute, context);
 		} else if (attribute.type === 'SpreadAttribute' || attribute.type === 'Attribute') {
-			e.illegal_element_attribute(attribute, 'svelte:window');
+			e.illegal_element_attribute(attribute, { name: 'svelte:window' });
 		}
 	}
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/Text.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/Text.js
index a03421e8dd..144145ed25 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/Text.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/Text.js
@@ -20,7 +20,7 @@ export function Text(node, context) {
 	) {
 		const message = is_tag_valid_with_parent('#text', context.state.parent_element);
 		if (message) {
-			e.node_invalid_placement(node, message);
+			e.node_invalid_placement(node, { message });
 		}
 	}
 
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/VariableDeclarator.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/VariableDeclarator.js
index 5cf231ad01..0ff61b482e 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/VariableDeclarator.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/VariableDeclarator.js
@@ -141,7 +141,7 @@ export function VariableDeclarator(node, context) {
 				(callee.name === '$state' || callee.name === '$derived' || callee.name === '$props') &&
 				context.state.scope.get(callee.name)?.kind !== 'store_sub'
 			) {
-				e.rune_invalid_usage(node.init, callee.name);
+				e.rune_invalid_usage(node.init, { rune: callee.name });
 			}
 		}
 	}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js
index e09ab018a8..7aa293593e 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y/index.js
@@ -113,17 +113,20 @@ export function check_element(node, context) {
 		if (name.startsWith('aria-')) {
 			if (invisible_elements.includes(node.name)) {
 				// aria-unsupported-elements
-				w.a11y_aria_attributes(attribute, node.name);
+				w.a11y_aria_attributes(attribute, { name: node.name });
 			}
 
 			const type = name.slice(5);
 			if (!aria_attributes.includes(type)) {
 				const match = fuzzymatch(type, aria_attributes);
-				w.a11y_unknown_aria_attribute(attribute, type, match);
+				w.a11y_unknown_aria_attribute(
+					attribute,
+					match === null ? { attribute: type } : { attribute: type, suggestion: match }
+				);
 			}
 
 			if (name === 'aria-hidden' && regex_heading_tags.test(node.name)) {
-				w.a11y_hidden(attribute, node.name);
+				w.a11y_hidden(attribute, { name: node.name });
 			}
 
 			// aria-proptypes
@@ -151,7 +154,7 @@ export function check_element(node, context) {
 			case 'role': {
 				if (invisible_elements.includes(node.name)) {
 					// aria-unsupported-elements
-					w.a11y_misplaced_role(attribute, node.name);
+					w.a11y_misplaced_role(attribute, { name: node.name });
 				}
 
 				const value = get_static_value(attribute);
@@ -162,10 +165,13 @@ export function check_element(node, context) {
 					const current_role = /** @type {ARIARoleDefinitionKey} current_role */ (c_r);
 
 					if (current_role && is_abstract_role(current_role)) {
-						w.a11y_no_abstract_role(attribute, current_role);
+						w.a11y_no_abstract_role(attribute, { role: current_role });
 					} else if (current_role && !aria_roles.includes(current_role)) {
 						const match = fuzzymatch(current_role, aria_roles);
-						w.a11y_unknown_role(attribute, current_role, match);
+						w.a11y_unknown_role(
+							attribute,
+							match === null ? { role: current_role } : { role: current_role, suggestion: match }
+						);
 					}
 
 					// no-redundant-roles
@@ -176,7 +182,7 @@ export function check_element(node, context) {
 						// <a role="link" /> is ok because without href the a tag doesn't have a role of link
 						!(node.name === 'a' && !attribute_map.has('href'))
 					) {
-						w.a11y_no_redundant_roles(attribute, current_role);
+						w.a11y_no_redundant_roles(attribute, { role: current_role });
 					}
 
 					// Footers and headers are special cases, and should not have redundant roles unless they are the children of sections or articles.
@@ -185,7 +191,7 @@ export function check_element(node, context) {
 						const has_nested_redundant_role =
 							current_role === a11y_nested_implicit_semantics.get(node.name);
 						if (has_nested_redundant_role) {
-							w.a11y_no_redundant_roles(attribute, current_role);
+							w.a11y_no_redundant_roles(attribute, { role: current_role });
 						}
 					}
 
@@ -201,14 +207,13 @@ export function check_element(node, context) {
 								!has_spread &&
 								required_role_props.some((prop) => !attributes.find((a) => a.name === prop));
 							if (has_missing_props) {
-								w.a11y_role_has_required_aria_props(
-									attribute,
-									current_role,
-									list(
+								w.a11y_role_has_required_aria_props(attribute, {
+									role: current_role,
+									props: list(
 										required_role_props.map((v) => `"${v}"`),
 										'and'
 									)
-								);
+								});
 							}
 						}
 					}
@@ -227,7 +232,7 @@ export function check_element(node, context) {
 							a11y_interactive_handlers.includes(handler)
 						);
 						if (has_interactive_handlers) {
-							w.a11y_interactive_supports_focus(node, current_role);
+							w.a11y_interactive_supports_focus(node, { role: current_role });
 						}
 					}
 
@@ -237,7 +242,10 @@ export function check_element(node, context) {
 						is_interactive &&
 						(is_non_interactive_roles(current_role) || is_presentation_role(current_role))
 					) {
-						w.a11y_no_interactive_element_to_noninteractive_role(node, node.name, current_role);
+						w.a11y_no_interactive_element_to_noninteractive_role(node, {
+							element: node.name,
+							role: current_role
+						});
 					}
 
 					// no-noninteractive-element-to-interactive-role
@@ -249,7 +257,10 @@ export function check_element(node, context) {
 							current_role
 						)
 					) {
-						w.a11y_no_noninteractive_element_to_interactive_role(node, node.name, current_role);
+						w.a11y_no_noninteractive_element_to_interactive_role(node, {
+							element: node.name,
+							role: current_role
+						});
 					}
 				}
 				break;
@@ -302,7 +313,7 @@ export function check_element(node, context) {
 			const has_key_event =
 				handlers.has('keydown') || handlers.has('keyup') || handlers.has('keypress');
 			if (!has_key_event) {
-				w.a11y_click_events_have_key_events(node, node.name);
+				w.a11y_click_events_have_key_events(node, { element: node.name });
 			}
 		}
 	}
@@ -328,9 +339,13 @@ export function check_element(node, context) {
 		for (const attr of attributes) {
 			if (invalid_aria_props.includes(/** @type {ARIAProperty} */ (attr.name))) {
 				if (is_implicit) {
-					w.a11y_role_supports_aria_props_implicit(attr, attr.name, role_value, node.name);
+					w.a11y_role_supports_aria_props_implicit(attr, {
+						attribute: attr.name,
+						role: role_value,
+						name: node.name
+					});
 				} else {
-					w.a11y_role_supports_aria_props(attr, attr.name, role_value);
+					w.a11y_role_supports_aria_props(attr, { attribute: attr.name, role: role_value });
 				}
 			}
 		}
@@ -349,7 +364,7 @@ export function check_element(node, context) {
 			a11y_recommended_interactive_handlers.includes(handler)
 		);
 		if (has_interactive_handlers) {
-			w.a11y_no_noninteractive_element_interactions(node, node.name);
+			w.a11y_no_noninteractive_element_interactions(node, { element: node.name });
 		}
 	}
 
@@ -369,7 +384,10 @@ export function check_element(node, context) {
 			a11y_interactive_handlers.includes(handler)
 		);
 		if (interactive_handlers.length > 0) {
-			w.a11y_no_static_element_interactions(node, node.name, list(interactive_handlers));
+			w.a11y_no_static_element_interactions(node, {
+				element: node.name,
+				handler: list(interactive_handlers)
+			});
 		}
 	}
 
@@ -381,7 +399,7 @@ export function check_element(node, context) {
 		!handlers.has('focus') &&
 		!handlers.has('focusin')
 	) {
-		w.a11y_mouse_events_have_key_events(node, 'mouseover', 'focus');
+		w.a11y_mouse_events_have_key_events(node, { event: 'mouseover', accompanied_by: 'focus' });
 	}
 
 	if (
@@ -390,7 +408,7 @@ export function check_element(node, context) {
 		!handlers.has('blur') &&
 		!handlers.has('focusout')
 	) {
-		w.a11y_mouse_events_have_key_events(node, 'mouseout', 'blur');
+		w.a11y_mouse_events_have_key_events(node, { event: 'mouseout', accompanied_by: 'blur' });
 	}
 
 	// element-specific checks
@@ -417,7 +435,7 @@ export function check_element(node, context) {
 				const href_value = get_static_text_value(href);
 				if (href_value !== null) {
 					if (href_value === '' || href_value === '#' || regex_js_prefix.test(href_value)) {
-						w.a11y_invalid_attribute(href, href_value, href.name);
+						w.a11y_invalid_attribute(href, { href_value, href_attribute: href.name });
 					}
 				}
 			} else if (!has_spread) {
@@ -445,11 +463,10 @@ export function check_element(node, context) {
 			if (type && autocomplete) {
 				const autocomplete_value = get_static_value(autocomplete);
 				if (!is_valid_autocomplete(autocomplete_value)) {
-					w.a11y_autocomplete_valid(
-						autocomplete,
-						/** @type {string} */ (autocomplete_value),
-						type_value ?? '...'
-					);
+					w.a11y_autocomplete_valid(autocomplete, {
+						value: /** @type {string} */ (autocomplete_value),
+						type: type_value ?? '...'
+					});
 				}
 			}
 			break;
@@ -559,7 +576,7 @@ export function check_element(node, context) {
 
 	if (a11y_distracting_elements.includes(node.name)) {
 		// no-distracting-elements
-		w.a11y_distracting_elements(node, node.name);
+		w.a11y_distracting_elements(node, { name: node.name });
 	}
 
 	// Check content
@@ -570,7 +587,7 @@ export function check_element(node, context) {
 		a11y_required_content.includes(node.name) &&
 		!has_content(node)
 	) {
-		w.a11y_missing_content(node, node.name);
+		w.a11y_missing_content(node, { name: node.name });
 	}
 }
 
@@ -885,42 +902,44 @@ function validate_aria_attribute_value(attribute, name, schema, value) {
 		case 'id':
 		case 'string': {
 			if (value === '') {
-				w.a11y_incorrect_aria_attribute_type(attribute, name, 'non-empty string');
+				w.a11y_incorrect_aria_attribute_type(attribute, {
+					attribute: name,
+					type: 'non-empty string'
+				});
 			}
 			break;
 		}
 		case 'number': {
 			if (value === '' || isNaN(+value)) {
-				w.a11y_incorrect_aria_attribute_type(attribute, name, 'number');
+				w.a11y_incorrect_aria_attribute_type(attribute, { attribute: name, type: 'number' });
 			}
 			break;
 		}
 		case 'boolean': {
 			if (value !== 'true' && value !== 'false') {
-				w.a11y_incorrect_aria_attribute_type_boolean(attribute, name);
+				w.a11y_incorrect_aria_attribute_type_boolean(attribute, { attribute: name });
 			}
 			break;
 		}
 		case 'idlist': {
 			if (value === '') {
-				w.a11y_incorrect_aria_attribute_type_idlist(attribute, name);
+				w.a11y_incorrect_aria_attribute_type_idlist(attribute, { attribute: name });
 			}
 			break;
 		}
 		case 'integer': {
 			if (value === '' || !Number.isInteger(+value)) {
-				w.a11y_incorrect_aria_attribute_type_integer(attribute, name);
+				w.a11y_incorrect_aria_attribute_type_integer(attribute, { attribute: name });
 			}
 			break;
 		}
 		case 'token': {
 			const values = (schema.values ?? []).map((value) => value.toString());
 			if (!values.includes(value.toLowerCase())) {
-				w.a11y_incorrect_aria_attribute_type_token(
-					attribute,
-					name,
-					list(values.map((v) => `"${v}"`))
-				);
+				w.a11y_incorrect_aria_attribute_type_token(attribute, {
+					attribute: name,
+					values: list(values.map((v) => `"${v}"`))
+				});
 			}
 			break;
 		}
@@ -932,17 +951,16 @@ function validate_aria_attribute_value(attribute, name, schema, value) {
 					.split(regex_whitespaces)
 					.some((value) => !values.includes(value))
 			) {
-				w.a11y_incorrect_aria_attribute_type_tokenlist(
-					attribute,
-					name,
-					list(values.map((v) => `"${v}"`))
-				);
+				w.a11y_incorrect_aria_attribute_type_tokenlist(attribute, {
+					attribute: name,
+					values: list(values.map((v) => `"${v}"`))
+				});
 			}
 			break;
 		}
 		case 'tristate': {
 			if (value !== 'true' && value !== 'false' && value !== 'mixed') {
-				w.a11y_incorrect_aria_attribute_type_tristate(attribute, name);
+				w.a11y_incorrect_aria_attribute_type_tristate(attribute, { attribute: name });
 			}
 			break;
 		}
@@ -962,5 +980,5 @@ function warn_missing_attribute(node, attributes, name = node.name) {
 			? attributes.slice(0, -1).join(', ') + ` or ${attributes[attributes.length - 1]}`
 			: attributes[0];
 
-	w.a11y_missing_attribute(node, name, article, sequence);
+	w.a11y_missing_attribute(node, { name, article, sequence });
 }
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/attribute.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/attribute.js
index 19bd7b6e54..6d22a81473 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/attribute.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/attribute.js
@@ -97,7 +97,7 @@ export function validate_slot_attribute(context, attribute, is_component = false
 				const name = attribute.value[0].data;
 
 				if (context.state.component_slots.has(name)) {
-					e.slot_attribute_duplicate(attribute, name, owner.name);
+					e.slot_attribute_duplicate(attribute, { name, component: owner.name });
 				}
 
 				context.state.component_slots.add(name);
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js
index 6a0c58ca30..e26097ad0a 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/element.js
@@ -57,7 +57,7 @@ export function validate_element(node, context) {
 			}
 
 			if (regex_illegal_attribute_character.test(attribute.name)) {
-				e.attribute_invalid_name(attribute, attribute.name);
+				e.attribute_invalid_name(attribute, { name: attribute.name });
 			}
 
 			if (attribute.name.startsWith('on') && attribute.name.length > 2) {
@@ -79,7 +79,10 @@ export function validate_element(node, context) {
 
 			const correct_name = react_attributes.get(attribute.name);
 			if (correct_name) {
-				w.attribute_invalid_property_name(attribute, attribute.name, correct_name);
+				w.attribute_invalid_property_name(attribute, {
+					wrong: attribute.name,
+					right: correct_name
+				});
 			}
 
 			validate_attribute_name(attribute);
@@ -116,9 +119,9 @@ export function validate_element(node, context) {
 				const b = attribute.intro ? (attribute.outro ? 'transition' : 'in') : 'out';
 
 				if (a === b) {
-					e.transition_duplicate(attribute, a);
+					e.transition_duplicate(attribute, { type: a });
 				} else {
-					e.transition_conflict(attribute, a, b);
+					e.transition_conflict(attribute, { type: a, existing: b });
 				}
 			}
 
@@ -130,7 +133,7 @@ export function validate_element(node, context) {
 			for (const modifier of attribute.modifiers) {
 				if (!EVENT_MODIFIERS.includes(modifier)) {
 					const list = `${EVENT_MODIFIERS.slice(0, -1).join(', ')} or ${EVENT_MODIFIERS.at(-1)}`;
-					e.event_handler_invalid_modifier(attribute, list);
+					e.event_handler_invalid_modifier(attribute, { list });
 				}
 				if (modifier === 'passive') {
 					has_passive_modifier = true;
@@ -138,11 +141,10 @@ export function validate_element(node, context) {
 					conflicting_passive_modifier = modifier;
 				}
 				if (has_passive_modifier && conflicting_passive_modifier) {
-					e.event_handler_invalid_modifier_combination(
-						attribute,
-						'passive',
-						conflicting_passive_modifier
-					);
+					e.event_handler_invalid_modifier_combination(attribute, {
+						modifier1: 'passive',
+						modifier2: conflicting_passive_modifier
+					});
 				}
 			}
 		}
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/special-element.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/special-element.js
index e72b3c6b2a..9d92313d69 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/special-element.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/special-element.js
@@ -11,6 +11,6 @@ export function disallow_children(node) {
 		const first = nodes[0];
 		const last = nodes[nodes.length - 1];
 
-		e.svelte_meta_invalid_content({ start: first.start, end: last.end }, node.name);
+		e.svelte_meta_invalid_content({ start: first.start, end: last.end }, { name: node.name });
 	}
 }
diff --git a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js
index a32355abf5..727245a893 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/visitors/shared/utils.js
@@ -30,7 +30,7 @@ export function validate_assignment(node, argument, context) {
 				context.state.analysis.props_id != null &&
 				binding?.node === context.state.analysis.props_id
 			) {
-				e.constant_assignment(node, '$props.id()');
+				e.constant_assignment(node, { thing: '$props.id()' });
 			}
 
 			if (binding?.kind === 'each') {
@@ -118,9 +118,9 @@ export function validate_no_const_assignment(node, argument, scope, is_binding)
 			const thing = binding.declaration_kind === 'import' ? 'import' : 'constant';
 
 			if (is_binding) {
-				e.constant_binding(node, thing);
+				e.constant_binding(node, { thing });
 			} else {
-				e.constant_assignment(node, thing);
+				e.constant_assignment(node, { thing });
 			}
 		}
 	}
@@ -136,7 +136,10 @@ export function validate_no_const_assignment(node, argument, scope, is_binding)
 export function validate_opening_tag(node, state, expected) {
 	if (state.analysis.source[node.start + 1] !== expected) {
 		// avoid a sea of red and only mark the first few characters
-		e.block_unexpected_character({ start: node.start, end: node.start + 5 }, expected);
+		e.block_unexpected_character(
+			{ start: node.start, end: node.start + 5 },
+			{ character: expected }
+		);
 	}
 }
 
@@ -317,6 +320,6 @@ export function check_global_event_reference(attribute, context) {
 		value.name === attribute.name &&
 		!context.state.scope.get(value.name)
 	) {
-		w.attribute_global_event_reference(attribute, attribute.name);
+		w.attribute_global_event_reference(attribute, { name: attribute.name });
 	}
 }
diff --git a/packages/svelte/src/compiler/phases/3-transform/utils.js b/packages/svelte/src/compiler/phases/3-transform/utils.js
index c7fce61ff9..b90f7e5ba4 100644
--- a/packages/svelte/src/compiler/phases/3-transform/utils.js
+++ b/packages/svelte/src/compiler/phases/3-transform/utils.js
@@ -81,7 +81,7 @@ function sort_const_tags(nodes, state) {
 	const cycle = check_graph_for_cycles(edges);
 	if (cycle?.length) {
 		const tag = /** @type {Tag} */ (tags.get(cycle[0]));
-		e.const_tag_cycle(tag.node, cycle.map((binding) => binding.node.name).join(' → '));
+		e.const_tag_cycle(tag.node, { cycle: cycle.map((binding) => binding.node.name).join(' → ') });
 	}
 
 	/** @type {AST.ConstTag[]} */
diff --git a/packages/svelte/src/compiler/phases/scope.js b/packages/svelte/src/compiler/phases/scope.js
index e3560753b4..4f2c05a53e 100644
--- a/packages/svelte/src/compiler/phases/scope.js
+++ b/packages/svelte/src/compiler/phases/scope.js
@@ -686,7 +686,7 @@ export class Scope {
 			if (binding && binding.declaration_kind !== 'var' && declaration_kind !== 'var') {
 				// This also errors on function types, but that's arguably a good thing
 				// declaring function twice is also caught by acorn in the parse phase
-				e.declaration_duplicate(node, node.name);
+				e.declaration_duplicate(node, { name: node.name });
 			}
 		}
 
diff --git a/packages/svelte/src/compiler/utils/extract_svelte_ignore.js b/packages/svelte/src/compiler/utils/extract_svelte_ignore.js
index 2f0d387307..98bb09ba93 100644
--- a/packages/svelte/src/compiler/utils/extract_svelte_ignore.js
+++ b/packages/svelte/src/compiler/utils/extract_svelte_ignore.js
@@ -50,10 +50,10 @@ export function extract_svelte_ignore(offset, text, runes) {
 				const end = start + code.length;
 
 				if (codes.includes(replacement)) {
-					w.legacy_code({ start, end }, code, replacement);
+					w.legacy_code({ start, end }, { code, suggestion: replacement });
 				} else {
 					const suggestion = fuzzymatch(code, codes);
-					w.unknown_code({ start, end }, code, suggestion);
+					w.unknown_code({ start, end }, suggestion === null ? { code } : { code, suggestion });
 				}
 			}
 
diff --git a/packages/svelte/src/compiler/validate-options.js b/packages/svelte/src/compiler/validate-options.js
index f7c56aa33c..f769813313 100644
--- a/packages/svelte/src/compiler/validate-options.js
+++ b/packages/svelte/src/compiler/validate-options.js
@@ -187,7 +187,7 @@ export const validate_component_options =
 function removed(msg) {
 	return (input) => {
 		if (input !== undefined) {
-			e.options_removed(null, msg);
+			e.options_removed(null, { details: msg });
 		}
 		return /** @type {any} */ (undefined);
 	};
@@ -245,7 +245,7 @@ function object(children, allow_unknown = false) {
 				if (allow_unknown) {
 					output[key] = input[key];
 				} else {
-					e.options_unrecognised(null, `${keypath ? `${keypath}.${key}` : key}`);
+					e.options_unrecognised(null, { keypath: `${keypath ? `${keypath}.${key}` : key}` });
 				}
 			}
 		}
@@ -357,5 +357,5 @@ function parametric(fallback, normalize = (value) => /** @type {ReturnType<F>} *
 
 /** @param {string} msg */
 function throw_error(msg) {
-	e.options_invalid_value(null, msg);
+	e.options_invalid_value(null, { details: msg });
 }
diff --git a/packages/svelte/src/compiler/warnings.js b/packages/svelte/src/compiler/warnings.js
index 98f407671d..8e3af7d959 100644
--- a/packages/svelte/src/compiler/warnings.js
+++ b/packages/svelte/src/compiler/warnings.js
@@ -4,6 +4,7 @@ import { warnings, ignore_stack, ignore_map, warning_filter } from './state.js';
 import { CompileDiagnostic } from './utils/compile_diagnostic.js';
 
 /** @typedef {{ start?: number, end?: number }} NodeLike */
+
 class InternalCompileWarning extends CompileDiagnostic {
 	name = 'CompileWarning';
 
@@ -24,14 +25,16 @@ class InternalCompileWarning extends CompileDiagnostic {
  */
 function w(node, code, message) {
 	let stack = ignore_stack;
-
 	if (node) {
 		stack = ignore_map.get(node) ?? ignore_stack;
 	}
-
 	if (stack && stack.at(-1)?.has(code)) return;
 
-	const warning = new InternalCompileWarning(code, message, node && node.start !== undefined ? [node.start, node.end ?? node.start] : undefined);
+	const warning = new InternalCompileWarning(
+		code,
+		message,
+		node && node.start !== undefined ? [node.start, node.end ?? node.start] : undefined
+	);
 
 	if (!warning_filter(warning)) return;
 
@@ -125,722 +128,728 @@ export const codes = [
 /**
  * Avoid using accesskey
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_accesskey(node) {
-	w(node, 'a11y_accesskey', `Avoid using accesskey\nhttps://svelte.dev/e/a11y_accesskey`);
+export function a11y_accesskey(node, values) {
+	w(node, 'a11y_accesskey', `${`Avoid using accesskey`}\nhttps://svelte.dev/e/${'a11y_accesskey'}`);
 }
 
 /**
  * An element with an aria-activedescendant attribute should have a tabindex value
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_aria_activedescendant_has_tabindex(node) {
-	w(node, 'a11y_aria_activedescendant_has_tabindex', `An element with an aria-activedescendant attribute should have a tabindex value\nhttps://svelte.dev/e/a11y_aria_activedescendant_has_tabindex`);
+export function a11y_aria_activedescendant_has_tabindex(node, values) {
+	w(node, 'a11y_aria_activedescendant_has_tabindex', `${`An element with an aria-activedescendant attribute should have a tabindex value`}\nhttps://svelte.dev/e/${'a11y_aria_activedescendant_has_tabindex'}`);
 }
 
 /**
  * `<%name%>` should not have aria-* attributes
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function a11y_aria_attributes(node, name) {
-	w(node, 'a11y_aria_attributes', `\`<${name}>\` should not have aria-* attributes\nhttps://svelte.dev/e/a11y_aria_attributes`);
+export function a11y_aria_attributes(node, values) {
+	w(node, 'a11y_aria_attributes', `${`\`<${values.name}>\` should not have aria-* attributes`}\nhttps://svelte.dev/e/${'a11y_aria_attributes'}`);
 }
 
 /**
  * '%value%' is an invalid value for 'autocomplete' on `<input type="%type%">`
  * @param {null | NodeLike} node
- * @param {string} value
- * @param {string} type
+ * @param {{ "value": string, "type": string }} values
  */
-export function a11y_autocomplete_valid(node, value, type) {
-	w(node, 'a11y_autocomplete_valid', `'${value}' is an invalid value for 'autocomplete' on \`<input type="${type}">\`\nhttps://svelte.dev/e/a11y_autocomplete_valid`);
+export function a11y_autocomplete_valid(node, values) {
+	w(node, 'a11y_autocomplete_valid', `${`'${values.value}' is an invalid value for 'autocomplete' on \`<input type="${values.type}">\``}\nhttps://svelte.dev/e/${'a11y_autocomplete_valid'}`);
 }
 
 /**
  * Avoid using autofocus
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_autofocus(node) {
-	w(node, 'a11y_autofocus', `Avoid using autofocus\nhttps://svelte.dev/e/a11y_autofocus`);
+export function a11y_autofocus(node, values) {
+	w(node, 'a11y_autofocus', `${`Avoid using autofocus`}\nhttps://svelte.dev/e/${'a11y_autofocus'}`);
 }
 
 /**
  * Visible, non-interactive element `<%element%>` with a click event must be accompanied by a keyboard event handler. Consider whether an interactive element such as `<button type="button">` or `<a>` might be more appropriate
  * @param {null | NodeLike} node
- * @param {string} element
+ * @param {{ "element": string }} values
  */
-export function a11y_click_events_have_key_events(node, element) {
-	w(node, 'a11y_click_events_have_key_events', `Visible, non-interactive element \`<${element}>\` with a click event must be accompanied by a keyboard event handler. Consider whether an interactive element such as \`<button type="button">\` or \`<a>\` might be more appropriate\nhttps://svelte.dev/e/a11y_click_events_have_key_events`);
+export function a11y_click_events_have_key_events(node, values) {
+	w(node, 'a11y_click_events_have_key_events', `${`Visible, non-interactive element \`<${values.element}>\` with a click event must be accompanied by a keyboard event handler. Consider whether an interactive element such as \`<button type="button">\` or \`<a>\` might be more appropriate`}\nhttps://svelte.dev/e/${'a11y_click_events_have_key_events'}`);
 }
 
 /**
  * Buttons and links should either contain text or have an `aria-label`, `aria-labelledby` or `title` attribute
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_consider_explicit_label(node) {
-	w(node, 'a11y_consider_explicit_label', `Buttons and links should either contain text or have an \`aria-label\`, \`aria-labelledby\` or \`title\` attribute\nhttps://svelte.dev/e/a11y_consider_explicit_label`);
+export function a11y_consider_explicit_label(node, values) {
+	w(node, 'a11y_consider_explicit_label', `${`Buttons and links should either contain text or have an \`aria-label\`, \`aria-labelledby\` or \`title\` attribute`}\nhttps://svelte.dev/e/${'a11y_consider_explicit_label'}`);
 }
 
 /**
  * Avoid `<%name%>` elements
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function a11y_distracting_elements(node, name) {
-	w(node, 'a11y_distracting_elements', `Avoid \`<${name}>\` elements\nhttps://svelte.dev/e/a11y_distracting_elements`);
+export function a11y_distracting_elements(node, values) {
+	w(node, 'a11y_distracting_elements', `${`Avoid \`<${values.name}>\` elements`}\nhttps://svelte.dev/e/${'a11y_distracting_elements'}`);
 }
 
 /**
  * `<figcaption>` must be first or last child of `<figure>`
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_figcaption_index(node) {
-	w(node, 'a11y_figcaption_index', `\`<figcaption>\` must be first or last child of \`<figure>\`\nhttps://svelte.dev/e/a11y_figcaption_index`);
+export function a11y_figcaption_index(node, values) {
+	w(node, 'a11y_figcaption_index', `${`\`<figcaption>\` must be first or last child of \`<figure>\``}\nhttps://svelte.dev/e/${'a11y_figcaption_index'}`);
 }
 
 /**
  * `<figcaption>` must be an immediate child of `<figure>`
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_figcaption_parent(node) {
-	w(node, 'a11y_figcaption_parent', `\`<figcaption>\` must be an immediate child of \`<figure>\`\nhttps://svelte.dev/e/a11y_figcaption_parent`);
+export function a11y_figcaption_parent(node, values) {
+	w(node, 'a11y_figcaption_parent', `${`\`<figcaption>\` must be an immediate child of \`<figure>\``}\nhttps://svelte.dev/e/${'a11y_figcaption_parent'}`);
 }
 
 /**
  * `<%name%>` element should not be hidden
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function a11y_hidden(node, name) {
-	w(node, 'a11y_hidden', `\`<${name}>\` element should not be hidden\nhttps://svelte.dev/e/a11y_hidden`);
+export function a11y_hidden(node, values) {
+	w(node, 'a11y_hidden', `${`\`<${values.name}>\` element should not be hidden`}\nhttps://svelte.dev/e/${'a11y_hidden'}`);
 }
 
 /**
  * Screenreaders already announce `<img>` elements as an image
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_img_redundant_alt(node) {
-	w(node, 'a11y_img_redundant_alt', `Screenreaders already announce \`<img>\` elements as an image\nhttps://svelte.dev/e/a11y_img_redundant_alt`);
+export function a11y_img_redundant_alt(node, values) {
+	w(node, 'a11y_img_redundant_alt', `${`Screenreaders already announce \`<img>\` elements as an image`}\nhttps://svelte.dev/e/${'a11y_img_redundant_alt'}`);
 }
 
 /**
  * The value of '%attribute%' must be a %type%
  * @param {null | NodeLike} node
- * @param {string} attribute
- * @param {string} type
+ * @param {{ "attribute": string, "type": string }} values
  */
-export function a11y_incorrect_aria_attribute_type(node, attribute, type) {
-	w(node, 'a11y_incorrect_aria_attribute_type', `The value of '${attribute}' must be a ${type}\nhttps://svelte.dev/e/a11y_incorrect_aria_attribute_type`);
+export function a11y_incorrect_aria_attribute_type(node, values) {
+	w(node, 'a11y_incorrect_aria_attribute_type', `${`The value of '${values.attribute}' must be a ${values.type}`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type'}`);
 }
 
 /**
  * The value of '%attribute%' must be either 'true' or 'false'. It cannot be empty
  * @param {null | NodeLike} node
- * @param {string} attribute
+ * @param {{ "attribute": string }} values
  */
-export function a11y_incorrect_aria_attribute_type_boolean(node, attribute) {
-	w(node, 'a11y_incorrect_aria_attribute_type_boolean', `The value of '${attribute}' must be either 'true' or 'false'. It cannot be empty\nhttps://svelte.dev/e/a11y_incorrect_aria_attribute_type_boolean`);
+export function a11y_incorrect_aria_attribute_type_boolean(node, values) {
+	w(node, 'a11y_incorrect_aria_attribute_type_boolean', `${`The value of '${values.attribute}' must be either 'true' or 'false'. It cannot be empty`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_boolean'}`);
 }
 
 /**
  * The value of '%attribute%' must be a string that represents a DOM element ID
  * @param {null | NodeLike} node
- * @param {string} attribute
+ * @param {{ "attribute": string }} values
  */
-export function a11y_incorrect_aria_attribute_type_id(node, attribute) {
-	w(node, 'a11y_incorrect_aria_attribute_type_id', `The value of '${attribute}' must be a string that represents a DOM element ID\nhttps://svelte.dev/e/a11y_incorrect_aria_attribute_type_id`);
+export function a11y_incorrect_aria_attribute_type_id(node, values) {
+	w(node, 'a11y_incorrect_aria_attribute_type_id', `${`The value of '${values.attribute}' must be a string that represents a DOM element ID`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_id'}`);
 }
 
 /**
  * The value of '%attribute%' must be a space-separated list of strings that represent DOM element IDs
  * @param {null | NodeLike} node
- * @param {string} attribute
+ * @param {{ "attribute": string }} values
  */
-export function a11y_incorrect_aria_attribute_type_idlist(node, attribute) {
-	w(node, 'a11y_incorrect_aria_attribute_type_idlist', `The value of '${attribute}' must be a space-separated list of strings that represent DOM element IDs\nhttps://svelte.dev/e/a11y_incorrect_aria_attribute_type_idlist`);
+export function a11y_incorrect_aria_attribute_type_idlist(node, values) {
+	w(node, 'a11y_incorrect_aria_attribute_type_idlist', `${`The value of '${values.attribute}' must be a space-separated list of strings that represent DOM element IDs`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_idlist'}`);
 }
 
 /**
  * The value of '%attribute%' must be an integer
  * @param {null | NodeLike} node
- * @param {string} attribute
+ * @param {{ "attribute": string }} values
  */
-export function a11y_incorrect_aria_attribute_type_integer(node, attribute) {
-	w(node, 'a11y_incorrect_aria_attribute_type_integer', `The value of '${attribute}' must be an integer\nhttps://svelte.dev/e/a11y_incorrect_aria_attribute_type_integer`);
+export function a11y_incorrect_aria_attribute_type_integer(node, values) {
+	w(node, 'a11y_incorrect_aria_attribute_type_integer', `${`The value of '${values.attribute}' must be an integer`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_integer'}`);
 }
 
 /**
  * The value of '%attribute%' must be exactly one of %values%
  * @param {null | NodeLike} node
- * @param {string} attribute
- * @param {string} values
+ * @param {{ "attribute": string, "values": string }} values
  */
-export function a11y_incorrect_aria_attribute_type_token(node, attribute, values) {
-	w(node, 'a11y_incorrect_aria_attribute_type_token', `The value of '${attribute}' must be exactly one of ${values}\nhttps://svelte.dev/e/a11y_incorrect_aria_attribute_type_token`);
+export function a11y_incorrect_aria_attribute_type_token(node, values) {
+	w(node, 'a11y_incorrect_aria_attribute_type_token', `${`The value of '${values.attribute}' must be exactly one of ${values.values}`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_token'}`);
 }
 
 /**
  * The value of '%attribute%' must be a space-separated list of one or more of %values%
  * @param {null | NodeLike} node
- * @param {string} attribute
- * @param {string} values
+ * @param {{ "attribute": string, "values": string }} values
  */
-export function a11y_incorrect_aria_attribute_type_tokenlist(node, attribute, values) {
-	w(node, 'a11y_incorrect_aria_attribute_type_tokenlist', `The value of '${attribute}' must be a space-separated list of one or more of ${values}\nhttps://svelte.dev/e/a11y_incorrect_aria_attribute_type_tokenlist`);
+export function a11y_incorrect_aria_attribute_type_tokenlist(node, values) {
+	w(node, 'a11y_incorrect_aria_attribute_type_tokenlist', `${`The value of '${values.attribute}' must be a space-separated list of one or more of ${values.values}`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_tokenlist'}`);
 }
 
 /**
  * The value of '%attribute%' must be exactly one of true, false, or mixed
  * @param {null | NodeLike} node
- * @param {string} attribute
+ * @param {{ "attribute": string }} values
  */
-export function a11y_incorrect_aria_attribute_type_tristate(node, attribute) {
-	w(node, 'a11y_incorrect_aria_attribute_type_tristate', `The value of '${attribute}' must be exactly one of true, false, or mixed\nhttps://svelte.dev/e/a11y_incorrect_aria_attribute_type_tristate`);
+export function a11y_incorrect_aria_attribute_type_tristate(node, values) {
+	w(node, 'a11y_incorrect_aria_attribute_type_tristate', `${`The value of '${values.attribute}' must be exactly one of true, false, or mixed`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_tristate'}`);
 }
 
 /**
  * Elements with the '%role%' interactive role must have a tabindex value
  * @param {null | NodeLike} node
- * @param {string} role
+ * @param {{ "role": string }} values
  */
-export function a11y_interactive_supports_focus(node, role) {
-	w(node, 'a11y_interactive_supports_focus', `Elements with the '${role}' interactive role must have a tabindex value\nhttps://svelte.dev/e/a11y_interactive_supports_focus`);
+export function a11y_interactive_supports_focus(node, values) {
+	w(node, 'a11y_interactive_supports_focus', `${`Elements with the '${values.role}' interactive role must have a tabindex value`}\nhttps://svelte.dev/e/${'a11y_interactive_supports_focus'}`);
 }
 
 /**
  * '%href_value%' is not a valid %href_attribute% attribute
  * @param {null | NodeLike} node
- * @param {string} href_value
- * @param {string} href_attribute
+ * @param {{ "href_value": string, "href_attribute": string }} values
  */
-export function a11y_invalid_attribute(node, href_value, href_attribute) {
-	w(node, 'a11y_invalid_attribute', `'${href_value}' is not a valid ${href_attribute} attribute\nhttps://svelte.dev/e/a11y_invalid_attribute`);
+export function a11y_invalid_attribute(node, values) {
+	w(node, 'a11y_invalid_attribute', `${`'${values.href_value}' is not a valid ${values.href_attribute} attribute`}\nhttps://svelte.dev/e/${'a11y_invalid_attribute'}`);
 }
 
 /**
  * A form label must be associated with a control
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_label_has_associated_control(node) {
-	w(node, 'a11y_label_has_associated_control', `A form label must be associated with a control\nhttps://svelte.dev/e/a11y_label_has_associated_control`);
+export function a11y_label_has_associated_control(node, values) {
+	w(node, 'a11y_label_has_associated_control', `${`A form label must be associated with a control`}\nhttps://svelte.dev/e/${'a11y_label_has_associated_control'}`);
 }
 
 /**
  * `<video>` elements must have a `<track kind="captions">`
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_media_has_caption(node) {
-	w(node, 'a11y_media_has_caption', `\`<video>\` elements must have a \`<track kind="captions">\`\nhttps://svelte.dev/e/a11y_media_has_caption`);
+export function a11y_media_has_caption(node, values) {
+	w(node, 'a11y_media_has_caption', `${`\`<video>\` elements must have a \`<track kind="captions">\``}\nhttps://svelte.dev/e/${'a11y_media_has_caption'}`);
 }
 
 /**
  * `<%name%>` should not have role attribute
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function a11y_misplaced_role(node, name) {
-	w(node, 'a11y_misplaced_role', `\`<${name}>\` should not have role attribute\nhttps://svelte.dev/e/a11y_misplaced_role`);
+export function a11y_misplaced_role(node, values) {
+	w(node, 'a11y_misplaced_role', `${`\`<${values.name}>\` should not have role attribute`}\nhttps://svelte.dev/e/${'a11y_misplaced_role'}`);
 }
 
 /**
  * The scope attribute should only be used with `<th>` elements
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_misplaced_scope(node) {
-	w(node, 'a11y_misplaced_scope', `The scope attribute should only be used with \`<th>\` elements\nhttps://svelte.dev/e/a11y_misplaced_scope`);
+export function a11y_misplaced_scope(node, values) {
+	w(node, 'a11y_misplaced_scope', `${`The scope attribute should only be used with \`<th>\` elements`}\nhttps://svelte.dev/e/${'a11y_misplaced_scope'}`);
 }
 
 /**
  * `<%name%>` element should have %article% %sequence% attribute
  * @param {null | NodeLike} node
- * @param {string} name
- * @param {string} article
- * @param {string} sequence
+ * @param {{ "name": string, "article": string, "sequence": string }} values
  */
-export function a11y_missing_attribute(node, name, article, sequence) {
-	w(node, 'a11y_missing_attribute', `\`<${name}>\` element should have ${article} ${sequence} attribute\nhttps://svelte.dev/e/a11y_missing_attribute`);
+export function a11y_missing_attribute(node, values) {
+	w(node, 'a11y_missing_attribute', `${`\`<${values.name}>\` element should have ${values.article} ${values.sequence} attribute`}\nhttps://svelte.dev/e/${'a11y_missing_attribute'}`);
 }
 
 /**
  * `<%name%>` element should contain text
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function a11y_missing_content(node, name) {
-	w(node, 'a11y_missing_content', `\`<${name}>\` element should contain text\nhttps://svelte.dev/e/a11y_missing_content`);
+export function a11y_missing_content(node, values) {
+	w(node, 'a11y_missing_content', `${`\`<${values.name}>\` element should contain text`}\nhttps://svelte.dev/e/${'a11y_missing_content'}`);
 }
 
 /**
  * '%event%' event must be accompanied by '%accompanied_by%' event
  * @param {null | NodeLike} node
- * @param {string} event
- * @param {string} accompanied_by
+ * @param {{ "event": string, "accompanied_by": string }} values
  */
-export function a11y_mouse_events_have_key_events(node, event, accompanied_by) {
-	w(node, 'a11y_mouse_events_have_key_events', `'${event}' event must be accompanied by '${accompanied_by}' event\nhttps://svelte.dev/e/a11y_mouse_events_have_key_events`);
+export function a11y_mouse_events_have_key_events(node, values) {
+	w(node, 'a11y_mouse_events_have_key_events', `${`'${values.event}' event must be accompanied by '${values.accompanied_by}' event`}\nhttps://svelte.dev/e/${'a11y_mouse_events_have_key_events'}`);
 }
 
 /**
  * Abstract role '%role%' is forbidden
  * @param {null | NodeLike} node
- * @param {string} role
+ * @param {{ "role": string }} values
  */
-export function a11y_no_abstract_role(node, role) {
-	w(node, 'a11y_no_abstract_role', `Abstract role '${role}' is forbidden\nhttps://svelte.dev/e/a11y_no_abstract_role`);
+export function a11y_no_abstract_role(node, values) {
+	w(node, 'a11y_no_abstract_role', `${`Abstract role '${values.role}' is forbidden`}\nhttps://svelte.dev/e/${'a11y_no_abstract_role'}`);
 }
 
 /**
  * `<%element%>` cannot have role '%role%'
  * @param {null | NodeLike} node
- * @param {string} element
- * @param {string} role
+ * @param {{ "element": string, "role": string }} values
  */
-export function a11y_no_interactive_element_to_noninteractive_role(node, element, role) {
-	w(node, 'a11y_no_interactive_element_to_noninteractive_role', `\`<${element}>\` cannot have role '${role}'\nhttps://svelte.dev/e/a11y_no_interactive_element_to_noninteractive_role`);
+export function a11y_no_interactive_element_to_noninteractive_role(node, values) {
+	w(node, 'a11y_no_interactive_element_to_noninteractive_role', `${`\`<${values.element}>\` cannot have role '${values.role}'`}\nhttps://svelte.dev/e/${'a11y_no_interactive_element_to_noninteractive_role'}`);
 }
 
 /**
  * Non-interactive element `<%element%>` should not be assigned mouse or keyboard event listeners
  * @param {null | NodeLike} node
- * @param {string} element
+ * @param {{ "element": string }} values
  */
-export function a11y_no_noninteractive_element_interactions(node, element) {
-	w(node, 'a11y_no_noninteractive_element_interactions', `Non-interactive element \`<${element}>\` should not be assigned mouse or keyboard event listeners\nhttps://svelte.dev/e/a11y_no_noninteractive_element_interactions`);
+export function a11y_no_noninteractive_element_interactions(node, values) {
+	w(node, 'a11y_no_noninteractive_element_interactions', `${`Non-interactive element \`<${values.element}>\` should not be assigned mouse or keyboard event listeners`}\nhttps://svelte.dev/e/${'a11y_no_noninteractive_element_interactions'}`);
 }
 
 /**
  * Non-interactive element `<%element%>` cannot have interactive role '%role%'
  * @param {null | NodeLike} node
- * @param {string} element
- * @param {string} role
+ * @param {{ "element": string, "role": string }} values
  */
-export function a11y_no_noninteractive_element_to_interactive_role(node, element, role) {
-	w(node, 'a11y_no_noninteractive_element_to_interactive_role', `Non-interactive element \`<${element}>\` cannot have interactive role '${role}'\nhttps://svelte.dev/e/a11y_no_noninteractive_element_to_interactive_role`);
+export function a11y_no_noninteractive_element_to_interactive_role(node, values) {
+	w(node, 'a11y_no_noninteractive_element_to_interactive_role', `${`Non-interactive element \`<${values.element}>\` cannot have interactive role '${values.role}'`}\nhttps://svelte.dev/e/${'a11y_no_noninteractive_element_to_interactive_role'}`);
 }
 
 /**
  * noninteractive element cannot have nonnegative tabIndex value
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_no_noninteractive_tabindex(node) {
-	w(node, 'a11y_no_noninteractive_tabindex', `noninteractive element cannot have nonnegative tabIndex value\nhttps://svelte.dev/e/a11y_no_noninteractive_tabindex`);
+export function a11y_no_noninteractive_tabindex(node, values) {
+	w(node, 'a11y_no_noninteractive_tabindex', `${`noninteractive element cannot have nonnegative tabIndex value`}\nhttps://svelte.dev/e/${'a11y_no_noninteractive_tabindex'}`);
 }
 
 /**
  * Redundant role '%role%'
  * @param {null | NodeLike} node
- * @param {string} role
+ * @param {{ "role": string }} values
  */
-export function a11y_no_redundant_roles(node, role) {
-	w(node, 'a11y_no_redundant_roles', `Redundant role '${role}'\nhttps://svelte.dev/e/a11y_no_redundant_roles`);
+export function a11y_no_redundant_roles(node, values) {
+	w(node, 'a11y_no_redundant_roles', `${`Redundant role '${values.role}'`}\nhttps://svelte.dev/e/${'a11y_no_redundant_roles'}`);
 }
 
 /**
  * `<%element%>` with a %handler% handler must have an ARIA role
  * @param {null | NodeLike} node
- * @param {string} element
- * @param {string} handler
+ * @param {{ "element": string, "handler": string }} values
  */
-export function a11y_no_static_element_interactions(node, element, handler) {
-	w(node, 'a11y_no_static_element_interactions', `\`<${element}>\` with a ${handler} handler must have an ARIA role\nhttps://svelte.dev/e/a11y_no_static_element_interactions`);
+export function a11y_no_static_element_interactions(node, values) {
+	w(node, 'a11y_no_static_element_interactions', `${`\`<${values.element}>\` with a ${values.handler} handler must have an ARIA role`}\nhttps://svelte.dev/e/${'a11y_no_static_element_interactions'}`);
 }
 
 /**
  * Avoid tabindex values above zero
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function a11y_positive_tabindex(node) {
-	w(node, 'a11y_positive_tabindex', `Avoid tabindex values above zero\nhttps://svelte.dev/e/a11y_positive_tabindex`);
+export function a11y_positive_tabindex(node, values) {
+	w(node, 'a11y_positive_tabindex', `${`Avoid tabindex values above zero`}\nhttps://svelte.dev/e/${'a11y_positive_tabindex'}`);
 }
 
 /**
  * Elements with the ARIA role "%role%" must have the following attributes defined: %props%
  * @param {null | NodeLike} node
- * @param {string} role
- * @param {string} props
+ * @param {{ "role": string, "props": string }} values
  */
-export function a11y_role_has_required_aria_props(node, role, props) {
-	w(node, 'a11y_role_has_required_aria_props', `Elements with the ARIA role "${role}" must have the following attributes defined: ${props}\nhttps://svelte.dev/e/a11y_role_has_required_aria_props`);
+export function a11y_role_has_required_aria_props(node, values) {
+	w(node, 'a11y_role_has_required_aria_props', `${`Elements with the ARIA role "${values.role}" must have the following attributes defined: ${values.props}`}\nhttps://svelte.dev/e/${'a11y_role_has_required_aria_props'}`);
 }
 
 /**
  * The attribute '%attribute%' is not supported by the role '%role%'
  * @param {null | NodeLike} node
- * @param {string} attribute
- * @param {string} role
+ * @param {{ "attribute": string, "role": string }} values
  */
-export function a11y_role_supports_aria_props(node, attribute, role) {
-	w(node, 'a11y_role_supports_aria_props', `The attribute '${attribute}' is not supported by the role '${role}'\nhttps://svelte.dev/e/a11y_role_supports_aria_props`);
+export function a11y_role_supports_aria_props(node, values) {
+	w(node, 'a11y_role_supports_aria_props', `${`The attribute '${values.attribute}' is not supported by the role '${values.role}'`}\nhttps://svelte.dev/e/${'a11y_role_supports_aria_props'}`);
 }
 
 /**
  * The attribute '%attribute%' is not supported by the role '%role%'. This role is implicit on the element `<%name%>`
  * @param {null | NodeLike} node
- * @param {string} attribute
- * @param {string} role
- * @param {string} name
+ * @param {{ "attribute": string, "role": string, "name": string }} values
  */
-export function a11y_role_supports_aria_props_implicit(node, attribute, role, name) {
-	w(node, 'a11y_role_supports_aria_props_implicit', `The attribute '${attribute}' is not supported by the role '${role}'. This role is implicit on the element \`<${name}>\`\nhttps://svelte.dev/e/a11y_role_supports_aria_props_implicit`);
+export function a11y_role_supports_aria_props_implicit(node, values) {
+	w(node, 'a11y_role_supports_aria_props_implicit', `${`The attribute '${values.attribute}' is not supported by the role '${values.role}'. This role is implicit on the element \`<${values.name}>\``}\nhttps://svelte.dev/e/${'a11y_role_supports_aria_props_implicit'}`);
 }
 
 /**
- * Unknown aria attribute 'aria-%attribute%'. Did you mean '%suggestion%'?
+ * Unknown aria attribute 'aria-%attribute%'
  * @param {null | NodeLike} node
- * @param {string} attribute
- * @param {string | undefined | null} [suggestion]
+ * @param {{ "attribute": string } | { "attribute": string, "suggestion": string }} values
  */
-export function a11y_unknown_aria_attribute(node, attribute, suggestion) {
-	w(node, 'a11y_unknown_aria_attribute', `${suggestion
-		? `Unknown aria attribute 'aria-${attribute}'. Did you mean '${suggestion}'?`
-		: `Unknown aria attribute 'aria-${attribute}'`}\nhttps://svelte.dev/e/a11y_unknown_aria_attribute`);
+export function a11y_unknown_aria_attribute(node, values) {
+	w(node, 'a11y_unknown_aria_attribute', `${(values?.suggestion !== undefined ? `Unknown aria attribute 'aria-${values.attribute}'. Did you mean '${values.suggestion}'?` : `Unknown aria attribute 'aria-${values.attribute}'`)}\nhttps://svelte.dev/e/${'a11y_unknown_aria_attribute'}`);
 }
 
 /**
- * Unknown role '%role%'. Did you mean '%suggestion%'?
+ * Unknown role '%role%'
  * @param {null | NodeLike} node
- * @param {string} role
- * @param {string | undefined | null} [suggestion]
+ * @param {{ "role": string } | { "role": string, "suggestion": string }} values
  */
-export function a11y_unknown_role(node, role, suggestion) {
-	w(node, 'a11y_unknown_role', `${suggestion
-		? `Unknown role '${role}'. Did you mean '${suggestion}'?`
-		: `Unknown role '${role}'`}\nhttps://svelte.dev/e/a11y_unknown_role`);
+export function a11y_unknown_role(node, values) {
+	w(node, 'a11y_unknown_role', `${(values?.suggestion !== undefined ? `Unknown role '${values.role}'. Did you mean '${values.suggestion}'?` : `Unknown role '${values.role}'`)}\nhttps://svelte.dev/e/${'a11y_unknown_role'}`);
 }
 
 /**
  * A bidirectional control character was detected in your code. These characters can be used to alter the visual direction of your code and could have unintended consequences
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function bidirectional_control_characters(node) {
-	w(node, 'bidirectional_control_characters', `A bidirectional control character was detected in your code. These characters can be used to alter the visual direction of your code and could have unintended consequences\nhttps://svelte.dev/e/bidirectional_control_characters`);
+export function bidirectional_control_characters(node, values) {
+	w(node, 'bidirectional_control_characters', `${`A bidirectional control character was detected in your code. These characters can be used to alter the visual direction of your code and could have unintended consequences`}\nhttps://svelte.dev/e/${'bidirectional_control_characters'}`);
 }
 
 /**
  * `%code%` is no longer valid — please use `%suggestion%` instead
  * @param {null | NodeLike} node
- * @param {string} code
- * @param {string} suggestion
+ * @param {{ "code": string, "suggestion": string }} values
  */
-export function legacy_code(node, code, suggestion) {
-	w(node, 'legacy_code', `\`${code}\` is no longer valid — please use \`${suggestion}\` instead\nhttps://svelte.dev/e/legacy_code`);
+export function legacy_code(node, values) {
+	w(node, 'legacy_code', `${`\`${values.code}\` is no longer valid — please use \`${values.suggestion}\` instead`}\nhttps://svelte.dev/e/${'legacy_code'}`);
 }
 
 /**
- * `%code%` is not a recognised code (did you mean `%suggestion%`?)
+ * `%code%` is not a recognised code
  * @param {null | NodeLike} node
- * @param {string} code
- * @param {string | undefined | null} [suggestion]
+ * @param {{ "code": string } | { "code": string, "suggestion": string }} values
  */
-export function unknown_code(node, code, suggestion) {
-	w(node, 'unknown_code', `${suggestion
-		? `\`${code}\` is not a recognised code (did you mean \`${suggestion}\`?)`
-		: `\`${code}\` is not a recognised code`}\nhttps://svelte.dev/e/unknown_code`);
+export function unknown_code(node, values) {
+	w(node, 'unknown_code', `${(values?.suggestion !== undefined ? `\`${values.code}\` is not a recognised code (did you mean \`${values.suggestion}\`?)` : `\`${values.code}\` is not a recognised code`)}\nhttps://svelte.dev/e/${'unknown_code'}`);
 }
 
 /**
  * The `accessors` option has been deprecated. It will have no effect in runes mode
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function options_deprecated_accessors(node) {
-	w(node, 'options_deprecated_accessors', `The \`accessors\` option has been deprecated. It will have no effect in runes mode\nhttps://svelte.dev/e/options_deprecated_accessors`);
+export function options_deprecated_accessors(node, values) {
+	w(node, 'options_deprecated_accessors', `${`The \`accessors\` option has been deprecated. It will have no effect in runes mode`}\nhttps://svelte.dev/e/${'options_deprecated_accessors'}`);
 }
 
 /**
  * The `immutable` option has been deprecated. It will have no effect in runes mode
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function options_deprecated_immutable(node) {
-	w(node, 'options_deprecated_immutable', `The \`immutable\` option has been deprecated. It will have no effect in runes mode\nhttps://svelte.dev/e/options_deprecated_immutable`);
+export function options_deprecated_immutable(node, values) {
+	w(node, 'options_deprecated_immutable', `${`The \`immutable\` option has been deprecated. It will have no effect in runes mode`}\nhttps://svelte.dev/e/${'options_deprecated_immutable'}`);
 }
 
 /**
  * The `customElement` option is used when generating a custom element. Did you forget the `customElement: true` compile option?
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function options_missing_custom_element(node) {
-	w(node, 'options_missing_custom_element', `The \`customElement\` option is used when generating a custom element. Did you forget the \`customElement: true\` compile option?\nhttps://svelte.dev/e/options_missing_custom_element`);
+export function options_missing_custom_element(node, values) {
+	w(node, 'options_missing_custom_element', `${`The \`customElement\` option is used when generating a custom element. Did you forget the \`customElement: true\` compile option?`}\nhttps://svelte.dev/e/${'options_missing_custom_element'}`);
 }
 
 /**
  * The `enableSourcemap` option has been removed. Source maps are always generated now, and tooling can choose to ignore them
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function options_removed_enable_sourcemap(node) {
-	w(node, 'options_removed_enable_sourcemap', `The \`enableSourcemap\` option has been removed. Source maps are always generated now, and tooling can choose to ignore them\nhttps://svelte.dev/e/options_removed_enable_sourcemap`);
+export function options_removed_enable_sourcemap(node, values) {
+	w(node, 'options_removed_enable_sourcemap', `${`The \`enableSourcemap\` option has been removed. Source maps are always generated now, and tooling can choose to ignore them`}\nhttps://svelte.dev/e/${'options_removed_enable_sourcemap'}`);
 }
 
 /**
  * The `hydratable` option has been removed. Svelte components are always hydratable now
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function options_removed_hydratable(node) {
-	w(node, 'options_removed_hydratable', `The \`hydratable\` option has been removed. Svelte components are always hydratable now\nhttps://svelte.dev/e/options_removed_hydratable`);
+export function options_removed_hydratable(node, values) {
+	w(node, 'options_removed_hydratable', `${`The \`hydratable\` option has been removed. Svelte components are always hydratable now`}\nhttps://svelte.dev/e/${'options_removed_hydratable'}`);
 }
 
 /**
  * The `loopGuardTimeout` option has been removed
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function options_removed_loop_guard_timeout(node) {
-	w(node, 'options_removed_loop_guard_timeout', `The \`loopGuardTimeout\` option has been removed\nhttps://svelte.dev/e/options_removed_loop_guard_timeout`);
+export function options_removed_loop_guard_timeout(node, values) {
+	w(node, 'options_removed_loop_guard_timeout', `${`The \`loopGuardTimeout\` option has been removed`}\nhttps://svelte.dev/e/${'options_removed_loop_guard_timeout'}`);
 }
 
 /**
  * `generate: "dom"` and `generate: "ssr"` options have been renamed to "client" and "server" respectively
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function options_renamed_ssr_dom(node) {
-	w(node, 'options_renamed_ssr_dom', `\`generate: "dom"\` and \`generate: "ssr"\` options have been renamed to "client" and "server" respectively\nhttps://svelte.dev/e/options_renamed_ssr_dom`);
+export function options_renamed_ssr_dom(node, values) {
+	w(node, 'options_renamed_ssr_dom', `${`\`generate: "dom"\` and \`generate: "ssr"\` options have been renamed to "client" and "server" respectively`}\nhttps://svelte.dev/e/${'options_renamed_ssr_dom'}`);
 }
 
 /**
  * Using a rest element or a non-destructured declaration with `$props()` means that Svelte can't infer what properties to expose when creating a custom element. Consider destructuring all the props or explicitly specifying the `customElement.props` option.
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function custom_element_props_identifier(node) {
-	w(node, 'custom_element_props_identifier', `Using a rest element or a non-destructured declaration with \`$props()\` means that Svelte can't infer what properties to expose when creating a custom element. Consider destructuring all the props or explicitly specifying the \`customElement.props\` option.\nhttps://svelte.dev/e/custom_element_props_identifier`);
+export function custom_element_props_identifier(node, values) {
+	w(node, 'custom_element_props_identifier', `${`Using a rest element or a non-destructured declaration with \`$props()\` means that Svelte can't infer what properties to expose when creating a custom element. Consider destructuring all the props or explicitly specifying the \`customElement.props\` option.`}\nhttps://svelte.dev/e/${'custom_element_props_identifier'}`);
 }
 
 /**
  * Component has unused export property '%name%'. If it is for external reference only, please consider using `export const %name%`
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function export_let_unused(node, name) {
-	w(node, 'export_let_unused', `Component has unused export property '${name}'. If it is for external reference only, please consider using \`export const ${name}\`\nhttps://svelte.dev/e/export_let_unused`);
+export function export_let_unused(node, values) {
+	w(node, 'export_let_unused', `${`Component has unused export property '${values.name}'. If it is for external reference only, please consider using \`export const ${values.name}\``}\nhttps://svelte.dev/e/${'export_let_unused'}`);
 }
 
 /**
  * Svelte 5 components are no longer classes. Instantiate them using `mount` or `hydrate` (imported from 'svelte') instead.
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function legacy_component_creation(node) {
-	w(node, 'legacy_component_creation', `Svelte 5 components are no longer classes. Instantiate them using \`mount\` or \`hydrate\` (imported from 'svelte') instead.\nhttps://svelte.dev/e/legacy_component_creation`);
+export function legacy_component_creation(node, values) {
+	w(node, 'legacy_component_creation', `${`Svelte 5 components are no longer classes. Instantiate them using \`mount\` or \`hydrate\` (imported from 'svelte') instead.`}\nhttps://svelte.dev/e/${'legacy_component_creation'}`);
 }
 
 /**
  * `%name%` is updated, but is not declared with `$state(...)`. Changing its value will not correctly trigger updates
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function non_reactive_update(node, name) {
-	w(node, 'non_reactive_update', `\`${name}\` is updated, but is not declared with \`$state(...)\`. Changing its value will not correctly trigger updates\nhttps://svelte.dev/e/non_reactive_update`);
+export function non_reactive_update(node, values) {
+	w(node, 'non_reactive_update', `${`\`${values.name}\` is updated, but is not declared with \`$state(...)\`. Changing its value will not correctly trigger updates`}\nhttps://svelte.dev/e/${'non_reactive_update'}`);
 }
 
 /**
  * Avoid 'new class' — instead, declare the class at the top level scope
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function perf_avoid_inline_class(node) {
-	w(node, 'perf_avoid_inline_class', `Avoid 'new class' — instead, declare the class at the top level scope\nhttps://svelte.dev/e/perf_avoid_inline_class`);
+export function perf_avoid_inline_class(node, values) {
+	w(node, 'perf_avoid_inline_class', `${`Avoid 'new class' — instead, declare the class at the top level scope`}\nhttps://svelte.dev/e/${'perf_avoid_inline_class'}`);
 }
 
 /**
  * Avoid declaring classes below the top level scope
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function perf_avoid_nested_class(node) {
-	w(node, 'perf_avoid_nested_class', `Avoid declaring classes below the top level scope\nhttps://svelte.dev/e/perf_avoid_nested_class`);
+export function perf_avoid_nested_class(node, values) {
+	w(node, 'perf_avoid_nested_class', `${`Avoid declaring classes below the top level scope`}\nhttps://svelte.dev/e/${'perf_avoid_nested_class'}`);
 }
 
 /**
  * Reactive declarations only exist at the top level of the instance script
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function reactive_declaration_invalid_placement(node) {
-	w(node, 'reactive_declaration_invalid_placement', `Reactive declarations only exist at the top level of the instance script\nhttps://svelte.dev/e/reactive_declaration_invalid_placement`);
+export function reactive_declaration_invalid_placement(node, values) {
+	w(node, 'reactive_declaration_invalid_placement', `${`Reactive declarations only exist at the top level of the instance script`}\nhttps://svelte.dev/e/${'reactive_declaration_invalid_placement'}`);
 }
 
 /**
  * Reassignments of module-level declarations will not cause reactive statements to update
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function reactive_declaration_module_script_dependency(node) {
-	w(node, 'reactive_declaration_module_script_dependency', `Reassignments of module-level declarations will not cause reactive statements to update\nhttps://svelte.dev/e/reactive_declaration_module_script_dependency`);
+export function reactive_declaration_module_script_dependency(node, values) {
+	w(node, 'reactive_declaration_module_script_dependency', `${`Reassignments of module-level declarations will not cause reactive statements to update`}\nhttps://svelte.dev/e/${'reactive_declaration_module_script_dependency'}`);
 }
 
 /**
  * This reference only captures the initial value of `%name%`. Did you mean to reference it inside a %type% instead?
  * @param {null | NodeLike} node
- * @param {string} name
- * @param {string} type
+ * @param {{ "name": string, "type": string }} values
  */
-export function state_referenced_locally(node, name, type) {
-	w(node, 'state_referenced_locally', `This reference only captures the initial value of \`${name}\`. Did you mean to reference it inside a ${type} instead?\nhttps://svelte.dev/e/state_referenced_locally`);
+export function state_referenced_locally(node, values) {
+	w(node, 'state_referenced_locally', `${`This reference only captures the initial value of \`${values.name}\`. Did you mean to reference it inside a ${values.type} instead?`}\nhttps://svelte.dev/e/${'state_referenced_locally'}`);
 }
 
 /**
  * It looks like you're using the `$%name%` rune, but there is a local binding called `%name%`. Referencing a local variable with a `$` prefix will create a store subscription. Please rename `%name%` to avoid the ambiguity
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function store_rune_conflict(node, name) {
-	w(node, 'store_rune_conflict', `It looks like you're using the \`$${name}\` rune, but there is a local binding called \`${name}\`. Referencing a local variable with a \`$\` prefix will create a store subscription. Please rename \`${name}\` to avoid the ambiguity\nhttps://svelte.dev/e/store_rune_conflict`);
+export function store_rune_conflict(node, values) {
+	w(node, 'store_rune_conflict', `${`It looks like you're using the \`$${values.name}\` rune, but there is a local binding called \`${values.name}\`. Referencing a local variable with a \`$\` prefix will create a store subscription. Please rename \`${values.name}\` to avoid the ambiguity`}\nhttps://svelte.dev/e/${'store_rune_conflict'}`);
 }
 
 /**
  * Unused CSS selector "%name%"
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function css_unused_selector(node, name) {
-	w(node, 'css_unused_selector', `Unused CSS selector "${name}"\nhttps://svelte.dev/e/css_unused_selector`);
+export function css_unused_selector(node, values) {
+	w(node, 'css_unused_selector', `${`Unused CSS selector "${values.name}"`}\nhttps://svelte.dev/e/${'css_unused_selector'}`);
 }
 
 /**
  * The "is" attribute is not supported cross-browser and should be avoided
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function attribute_avoid_is(node) {
-	w(node, 'attribute_avoid_is', `The "is" attribute is not supported cross-browser and should be avoided\nhttps://svelte.dev/e/attribute_avoid_is`);
+export function attribute_avoid_is(node, values) {
+	w(node, 'attribute_avoid_is', `${`The "is" attribute is not supported cross-browser and should be avoided`}\nhttps://svelte.dev/e/${'attribute_avoid_is'}`);
 }
 
 /**
  * You are referencing `globalThis.%name%`. Did you forget to declare a variable with that name?
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function attribute_global_event_reference(node, name) {
-	w(node, 'attribute_global_event_reference', `You are referencing \`globalThis.${name}\`. Did you forget to declare a variable with that name?\nhttps://svelte.dev/e/attribute_global_event_reference`);
+export function attribute_global_event_reference(node, values) {
+	w(node, 'attribute_global_event_reference', `${`You are referencing \`globalThis.${values.name}\`. Did you forget to declare a variable with that name?`}\nhttps://svelte.dev/e/${'attribute_global_event_reference'}`);
 }
 
 /**
  * Attributes should not contain ':' characters to prevent ambiguity with Svelte directives
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function attribute_illegal_colon(node) {
-	w(node, 'attribute_illegal_colon', `Attributes should not contain ':' characters to prevent ambiguity with Svelte directives\nhttps://svelte.dev/e/attribute_illegal_colon`);
+export function attribute_illegal_colon(node, values) {
+	w(node, 'attribute_illegal_colon', `${`Attributes should not contain ':' characters to prevent ambiguity with Svelte directives`}\nhttps://svelte.dev/e/${'attribute_illegal_colon'}`);
 }
 
 /**
  * '%wrong%' is not a valid HTML attribute. Did you mean '%right%'?
  * @param {null | NodeLike} node
- * @param {string} wrong
- * @param {string} right
+ * @param {{ "wrong": string, "right": string }} values
  */
-export function attribute_invalid_property_name(node, wrong, right) {
-	w(node, 'attribute_invalid_property_name', `'${wrong}' is not a valid HTML attribute. Did you mean '${right}'?\nhttps://svelte.dev/e/attribute_invalid_property_name`);
+export function attribute_invalid_property_name(node, values) {
+	w(node, 'attribute_invalid_property_name', `${`'${values.wrong}' is not a valid HTML attribute. Did you mean '${values.right}'?`}\nhttps://svelte.dev/e/${'attribute_invalid_property_name'}`);
 }
 
 /**
  * Quoted attributes on components and custom elements will be stringified in a future version of Svelte. If this isn't what you want, remove the quotes
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function attribute_quoted(node) {
-	w(node, 'attribute_quoted', `Quoted attributes on components and custom elements will be stringified in a future version of Svelte. If this isn't what you want, remove the quotes\nhttps://svelte.dev/e/attribute_quoted`);
+export function attribute_quoted(node, values) {
+	w(node, 'attribute_quoted', `${`Quoted attributes on components and custom elements will be stringified in a future version of Svelte. If this isn't what you want, remove the quotes`}\nhttps://svelte.dev/e/${'attribute_quoted'}`);
 }
 
 /**
  * The rest operator (...) will create a new object and binding '%name%' with the original object will not work
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function bind_invalid_each_rest(node, name) {
-	w(node, 'bind_invalid_each_rest', `The rest operator (...) will create a new object and binding '${name}' with the original object will not work\nhttps://svelte.dev/e/bind_invalid_each_rest`);
+export function bind_invalid_each_rest(node, values) {
+	w(node, 'bind_invalid_each_rest', `${`The rest operator (...) will create a new object and binding '${values.name}' with the original object will not work`}\nhttps://svelte.dev/e/${'bind_invalid_each_rest'}`);
 }
 
 /**
  * Empty block
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function block_empty(node) {
-	w(node, 'block_empty', `Empty block\nhttps://svelte.dev/e/block_empty`);
+export function block_empty(node, values) {
+	w(node, 'block_empty', `${`Empty block`}\nhttps://svelte.dev/e/${'block_empty'}`);
 }
 
 /**
  * `<%name%>` will be treated as an HTML element unless it begins with a capital letter
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function component_name_lowercase(node, name) {
-	w(node, 'component_name_lowercase', `\`<${name}>\` will be treated as an HTML element unless it begins with a capital letter\nhttps://svelte.dev/e/component_name_lowercase`);
+export function component_name_lowercase(node, values) {
+	w(node, 'component_name_lowercase', `${`\`<${values.name}>\` will be treated as an HTML element unless it begins with a capital letter`}\nhttps://svelte.dev/e/${'component_name_lowercase'}`);
 }
 
 /**
  * This element is implicitly closed by the following `%tag%`, which can cause an unexpected DOM structure. Add an explicit `%closing%` to avoid surprises.
  * @param {null | NodeLike} node
- * @param {string} tag
- * @param {string} closing
+ * @param {{ "tag": string, "closing": string }} values
  */
-export function element_implicitly_closed(node, tag, closing) {
-	w(node, 'element_implicitly_closed', `This element is implicitly closed by the following \`${tag}\`, which can cause an unexpected DOM structure. Add an explicit \`${closing}\` to avoid surprises.\nhttps://svelte.dev/e/element_implicitly_closed`);
+export function element_implicitly_closed(node, values) {
+	w(node, 'element_implicitly_closed', `${`This element is implicitly closed by the following \`${values.tag}\`, which can cause an unexpected DOM structure. Add an explicit \`${values.closing}\` to avoid surprises.`}\nhttps://svelte.dev/e/${'element_implicitly_closed'}`);
 }
 
 /**
  * Self-closing HTML tags for non-void elements are ambiguous — use `<%name% ...></%name%>` rather than `<%name% ... />`
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function element_invalid_self_closing_tag(node, name) {
-	w(node, 'element_invalid_self_closing_tag', `Self-closing HTML tags for non-void elements are ambiguous — use \`<${name} ...></${name}>\` rather than \`<${name} ... />\`\nhttps://svelte.dev/e/element_invalid_self_closing_tag`);
+export function element_invalid_self_closing_tag(node, values) {
+	w(node, 'element_invalid_self_closing_tag', `${`Self-closing HTML tags for non-void elements are ambiguous — use \`<${values.name} ...></${values.name}>\` rather than \`<${values.name} ... />\``}\nhttps://svelte.dev/e/${'element_invalid_self_closing_tag'}`);
 }
 
 /**
  * Using `on:%name%` to listen to the %name% event is deprecated. Use the event attribute `on%name%` instead
  * @param {null | NodeLike} node
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function event_directive_deprecated(node, name) {
-	w(node, 'event_directive_deprecated', `Using \`on:${name}\` to listen to the ${name} event is deprecated. Use the event attribute \`on${name}\` instead\nhttps://svelte.dev/e/event_directive_deprecated`);
+export function event_directive_deprecated(node, values) {
+	w(node, 'event_directive_deprecated', `${`Using \`on:${values.name}\` to listen to the ${values.name} event is deprecated. Use the event attribute \`on${values.name}\` instead`}\nhttps://svelte.dev/e/${'event_directive_deprecated'}`);
 }
 
 /**
  * %message%. When rendering this component on the server, the resulting HTML will be modified by the browser (by moving, removing, or inserting elements), likely resulting in a `hydration_mismatch` warning
  * @param {null | NodeLike} node
- * @param {string} message
+ * @param {{ "message": string }} values
  */
-export function node_invalid_placement_ssr(node, message) {
-	w(node, 'node_invalid_placement_ssr', `${message}. When rendering this component on the server, the resulting HTML will be modified by the browser (by moving, removing, or inserting elements), likely resulting in a \`hydration_mismatch\` warning\nhttps://svelte.dev/e/node_invalid_placement_ssr`);
+export function node_invalid_placement_ssr(node, values) {
+	w(node, 'node_invalid_placement_ssr', `${`${values.message}. When rendering this component on the server, the resulting HTML will be modified by the browser (by moving, removing, or inserting elements), likely resulting in a \`hydration_mismatch\` warning`}\nhttps://svelte.dev/e/${'node_invalid_placement_ssr'}`);
 }
 
 /**
  * `context="module"` is deprecated, use the `module` attribute instead
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function script_context_deprecated(node) {
-	w(node, 'script_context_deprecated', `\`context="module"\` is deprecated, use the \`module\` attribute instead\nhttps://svelte.dev/e/script_context_deprecated`);
+export function script_context_deprecated(node, values) {
+	w(node, 'script_context_deprecated', `${`\`context="module"\` is deprecated, use the \`module\` attribute instead`}\nhttps://svelte.dev/e/${'script_context_deprecated'}`);
 }
 
 /**
  * Unrecognised attribute — should be one of `generics`, `lang` or `module`. If this exists for a preprocessor, ensure that the preprocessor removes it
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function script_unknown_attribute(node) {
-	w(node, 'script_unknown_attribute', `Unrecognised attribute — should be one of \`generics\`, \`lang\` or \`module\`. If this exists for a preprocessor, ensure that the preprocessor removes it\nhttps://svelte.dev/e/script_unknown_attribute`);
+export function script_unknown_attribute(node, values) {
+	w(node, 'script_unknown_attribute', `${`Unrecognised attribute — should be one of \`generics\`, \`lang\` or \`module\`. If this exists for a preprocessor, ensure that the preprocessor removes it`}\nhttps://svelte.dev/e/${'script_unknown_attribute'}`);
 }
 
 /**
  * Using `<slot>` to render parent content is deprecated. Use `{@render ...}` tags instead
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function slot_element_deprecated(node) {
-	w(node, 'slot_element_deprecated', `Using \`<slot>\` to render parent content is deprecated. Use \`{@render ...}\` tags instead\nhttps://svelte.dev/e/slot_element_deprecated`);
+export function slot_element_deprecated(node, values) {
+	w(node, 'slot_element_deprecated', `${`Using \`<slot>\` to render parent content is deprecated. Use \`{@render ...}\` tags instead`}\nhttps://svelte.dev/e/${'slot_element_deprecated'}`);
 }
 
 /**
  * `<svelte:component>` is deprecated in runes mode — components are dynamic by default
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function svelte_component_deprecated(node) {
-	w(node, 'svelte_component_deprecated', `\`<svelte:component>\` is deprecated in runes mode — components are dynamic by default\nhttps://svelte.dev/e/svelte_component_deprecated`);
+export function svelte_component_deprecated(node, values) {
+	w(node, 'svelte_component_deprecated', `${`\`<svelte:component>\` is deprecated in runes mode — components are dynamic by default`}\nhttps://svelte.dev/e/${'svelte_component_deprecated'}`);
 }
 
 /**
  * `this` should be an `{expression}`. Using a string attribute value will cause an error in future versions of Svelte
  * @param {null | NodeLike} node
+ * @param {void} values
  */
-export function svelte_element_invalid_this(node) {
-	w(node, 'svelte_element_invalid_this', `\`this\` should be an \`{expression}\`. Using a string attribute value will cause an error in future versions of Svelte\nhttps://svelte.dev/e/svelte_element_invalid_this`);
+export function svelte_element_invalid_this(node, values) {
+	w(node, 'svelte_element_invalid_this', `${`\`this\` should be an \`{expression}\`. Using a string attribute value will cause an error in future versions of Svelte`}\nhttps://svelte.dev/e/${'svelte_element_invalid_this'}`);
 }
 
 /**
  * `<svelte:self>` is deprecated — use self-imports (e.g. `import %name% from './%basename%'`) instead
  * @param {null | NodeLike} node
- * @param {string} name
- * @param {string} basename
+ * @param {{ "name": string, "basename": string }} values
  */
-export function svelte_self_deprecated(node, name, basename) {
-	w(node, 'svelte_self_deprecated', `\`<svelte:self>\` is deprecated — use self-imports (e.g. \`import ${name} from './${basename}'\`) instead\nhttps://svelte.dev/e/svelte_self_deprecated`);
-}
\ No newline at end of file
+export function svelte_self_deprecated(node, values) {
+	w(node, 'svelte_self_deprecated', `${`\`<svelte:self>\` is deprecated — use self-imports (e.g. \`import ${values.name} from './${values.basename}'\`) instead`}\nhttps://svelte.dev/e/${'svelte_self_deprecated'}`);
+}
diff --git a/packages/svelte/src/index-client.js b/packages/svelte/src/index-client.js
index 0eb1b80315..de55247066 100644
--- a/packages/svelte/src/index-client.js
+++ b/packages/svelte/src/index-client.js
@@ -26,7 +26,7 @@ if (DEV) {
 						return value;
 					}
 
-					e.rune_outside_svelte(rune);
+					e.rune_outside_svelte({ rune });
 				},
 				set: (v) => {
 					value = v;
@@ -90,7 +90,7 @@ export function getAbortSignal() {
  */
 export function onMount(fn) {
 	if (component_context === null) {
-		e.lifecycle_outside_component('onMount');
+		e.lifecycle_outside_component({ name: 'onMount' });
 	}
 
 	if (legacy_mode_flag && component_context.l !== null) {
@@ -114,7 +114,7 @@ export function onMount(fn) {
  */
 export function onDestroy(fn) {
 	if (component_context === null) {
-		e.lifecycle_outside_component('onDestroy');
+		e.lifecycle_outside_component({ name: 'onDestroy' });
 	}
 
 	onMount(() => () => untrack(fn));
@@ -157,7 +157,7 @@ function create_custom_event(type, detail, { bubbles = false, cancelable = false
 export function createEventDispatcher() {
 	const active_component_context = component_context;
 	if (active_component_context === null) {
-		e.lifecycle_outside_component('createEventDispatcher');
+		e.lifecycle_outside_component({ name: 'createEventDispatcher' });
 	}
 
 	/**
@@ -199,11 +199,11 @@ export function createEventDispatcher() {
  */
 export function beforeUpdate(fn) {
 	if (component_context === null) {
-		e.lifecycle_outside_component('beforeUpdate');
+		e.lifecycle_outside_component({ name: 'beforeUpdate' });
 	}
 
 	if (component_context.l === null) {
-		e.lifecycle_legacy_only('beforeUpdate');
+		e.lifecycle_legacy_only({ name: 'beforeUpdate' });
 	}
 
 	init_update_callbacks(component_context).b.push(fn);
@@ -222,11 +222,11 @@ export function beforeUpdate(fn) {
  */
 export function afterUpdate(fn) {
 	if (component_context === null) {
-		e.lifecycle_outside_component('afterUpdate');
+		e.lifecycle_outside_component({ name: 'afterUpdate' });
 	}
 
 	if (component_context.l === null) {
-		e.lifecycle_legacy_only('afterUpdate');
+		e.lifecycle_legacy_only({ name: 'afterUpdate' });
 	}
 
 	init_update_callbacks(component_context).a.push(fn);
diff --git a/packages/svelte/src/index-server.js b/packages/svelte/src/index-server.js
index 9fb810fd9e..bb77161600 100644
--- a/packages/svelte/src/index-server.js
+++ b/packages/svelte/src/index-server.js
@@ -22,19 +22,19 @@ export function createEventDispatcher() {
 }
 
 export function mount() {
-	e.lifecycle_function_unavailable('mount');
+	e.lifecycle_function_unavailable({ name: 'mount' });
 }
 
 export function hydrate() {
-	e.lifecycle_function_unavailable('hydrate');
+	e.lifecycle_function_unavailable({ name: 'hydrate' });
 }
 
 export function unmount() {
-	e.lifecycle_function_unavailable('unmount');
+	e.lifecycle_function_unavailable({ name: 'unmount' });
 }
 
 export function fork() {
-	e.lifecycle_function_unavailable('fork');
+	e.lifecycle_function_unavailable({ name: 'fork' });
 }
 
 export async function tick() {}
diff --git a/packages/svelte/src/internal/client/dev/assign.js b/packages/svelte/src/internal/client/dev/assign.js
index e328543b32..b00fd73533 100644
--- a/packages/svelte/src/internal/client/dev/assign.js
+++ b/packages/svelte/src/internal/client/dev/assign.js
@@ -12,7 +12,10 @@ import * as w from '../warnings.js';
  */
 function compare(a, b, property, location) {
 	if (a !== b && typeof b === 'object' && STATE_SYMBOL in b) {
-		w.assignment_value_stale(property, /** @type {string} */ (sanitize_location(location)));
+		w.assignment_value_stale({
+			property,
+			location: /** @type {string} */ (sanitize_location(location))
+		});
 	}
 
 	return a;
diff --git a/packages/svelte/src/internal/client/dev/console-log.js b/packages/svelte/src/internal/client/dev/console-log.js
index 38860eb767..d10d8f35b4 100644
--- a/packages/svelte/src/internal/client/dev/console-log.js
+++ b/packages/svelte/src/internal/client/dev/console-log.js
@@ -23,7 +23,7 @@ export function log_if_contains_state(method, ...objects) {
 			}
 
 			if (has_state) {
-				w.console_log_state(method);
+				w.console_log_state({ method });
 
 				// eslint-disable-next-line no-console
 				console.log('%c[snapshot]', 'color: grey', ...transformed);
diff --git a/packages/svelte/src/internal/client/dev/equality.js b/packages/svelte/src/internal/client/dev/equality.js
index bbc28dc638..2ab4ed2235 100644
--- a/packages/svelte/src/internal/client/dev/equality.js
+++ b/packages/svelte/src/internal/client/dev/equality.js
@@ -19,7 +19,7 @@ export function init_array_prototype_warnings() {
 		if (index === -1) {
 			for (let i = from_index ?? 0; i < this.length; i += 1) {
 				if (get_proxied_value(this[i]) === item) {
-					w.state_proxy_equality_mismatch('array.indexOf(...)');
+					w.state_proxy_equality_mismatch({ operator: 'array.indexOf(...)' });
 					break;
 				}
 			}
@@ -36,7 +36,7 @@ export function init_array_prototype_warnings() {
 		if (index === -1) {
 			for (let i = 0; i <= (from_index ?? this.length - 1); i += 1) {
 				if (get_proxied_value(this[i]) === item) {
-					w.state_proxy_equality_mismatch('array.lastIndexOf(...)');
+					w.state_proxy_equality_mismatch({ operator: 'array.lastIndexOf(...)' });
 					break;
 				}
 			}
@@ -51,7 +51,7 @@ export function init_array_prototype_warnings() {
 		if (!has) {
 			for (let i = 0; i < this.length; i += 1) {
 				if (get_proxied_value(this[i]) === item) {
-					w.state_proxy_equality_mismatch('array.includes(...)');
+					w.state_proxy_equality_mismatch({ operator: 'array.includes(...)' });
 					break;
 				}
 			}
@@ -79,7 +79,7 @@ export function strict_equals(a, b, equal = true) {
 	// which could be disallowed for example in a secure context
 	try {
 		if ((a === b) !== (get_proxied_value(a) === get_proxied_value(b))) {
-			w.state_proxy_equality_mismatch(equal ? '===' : '!==');
+			w.state_proxy_equality_mismatch({ operator: equal ? '===' : '!==' });
 		}
 	} catch {}
 
@@ -94,7 +94,7 @@ export function strict_equals(a, b, equal = true) {
  */
 export function equals(a, b, equal = true) {
 	if ((a == b) !== (get_proxied_value(a) == get_proxied_value(b))) {
-		w.state_proxy_equality_mismatch(equal ? '==' : '!=');
+		w.state_proxy_equality_mismatch({ operator: equal ? '==' : '!=' });
 	}
 
 	return (a == b) === equal;
diff --git a/packages/svelte/src/internal/client/dev/legacy.js b/packages/svelte/src/internal/client/dev/legacy.js
index 02428dc824..7983394ef1 100644
--- a/packages/svelte/src/internal/client/dev/legacy.js
+++ b/packages/svelte/src/internal/client/dev/legacy.js
@@ -5,7 +5,10 @@ import { FILENAME } from '../../../constants.js';
 /** @param {Function & { [FILENAME]: string }} target */
 export function check_target(target) {
 	if (target) {
-		e.component_api_invalid_new(target[FILENAME] ?? 'a component', target.name);
+		e.component_api_invalid_new({
+			component: target[FILENAME] ?? 'a component',
+			name: target.name
+		});
 	}
 }
 
@@ -14,7 +17,7 @@ export function legacy_api() {
 
 	/** @param {string} method */
 	function error(method) {
-		e.component_api_changed(method, component[FILENAME]);
+		e.component_api_changed({ method, component: component[FILENAME] });
 	}
 
 	return {
diff --git a/packages/svelte/src/internal/client/dev/ownership.js b/packages/svelte/src/internal/client/dev/ownership.js
index 19d2cdb343..4c4be5fe35 100644
--- a/packages/svelte/src/internal/client/dev/ownership.js
+++ b/packages/svelte/src/internal/client/dev/ownership.js
@@ -43,7 +43,7 @@ export function create_ownership_validator(props) {
 
 			const location = sanitize_location(`${component[FILENAME]}:${line}:${column}`);
 
-			w.ownership_invalid_mutation(name, location, prop, parent[FILENAME]);
+			w.ownership_invalid_mutation({ name, location, prop, parent: parent[FILENAME] });
 
 			return result;
 		},
@@ -54,12 +54,12 @@ export function create_ownership_validator(props) {
 		 */
 		binding: (key, child_component, value) => {
 			if (!is_bound_or_unset(props, key) && parent && value()?.[STATE_SYMBOL]) {
-				w.ownership_invalid_binding(
-					component[FILENAME],
-					key,
-					child_component[FILENAME],
-					parent[FILENAME]
-				);
+				w.ownership_invalid_binding({
+					parent: component[FILENAME],
+					prop: key,
+					child: child_component[FILENAME],
+					owner: parent[FILENAME]
+				});
 			}
 		}
 	};
diff --git a/packages/svelte/src/internal/client/dom/blocks/each.js b/packages/svelte/src/internal/client/dom/blocks/each.js
index 9a2504f887..216a8b208d 100644
--- a/packages/svelte/src/internal/client/dom/blocks/each.js
+++ b/packages/svelte/src/internal/client/dom/blocks/each.js
@@ -307,7 +307,7 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 				// Check that the key function is idempotent (returns the same value when called twice)
 				var key_again = get_key(value, index);
 				if (key !== key_again) {
-					e.each_key_volatile(String(index), String(key), String(key_again));
+					e.each_key_volatile({ index: String(index), a: String(key), b: String(key_again) });
 				}
 			}
 
@@ -357,7 +357,7 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 				validate_each_keys(array, get_key);
 			} else {
 				// in prod, the additional information isn't printed, so don't bother computing it
-				e.each_key_duplicate('', '', '');
+				e.each_key_duplicate({ a: '', b: '', value: '' });
 			}
 		}
 
@@ -768,7 +768,7 @@ function validate_each_keys(array, key_fn) {
 			let k = String(key);
 			if (k.startsWith('[object ')) k = null;
 
-			e.each_key_duplicate(a, b, k);
+			e.each_key_duplicate(k === null ? { a, b } : { a, b, value: k });
 		}
 
 		keys.set(key, i);
diff --git a/packages/svelte/src/internal/client/dom/blocks/html.js b/packages/svelte/src/internal/client/dom/blocks/html.js
index ffe947eb16..c48c974097 100644
--- a/packages/svelte/src/internal/client/dom/blocks/html.js
+++ b/packages/svelte/src/internal/client/dom/blocks/html.js
@@ -36,7 +36,8 @@ function check_hash(element, server_hash, value) {
 		location = `in ${dev_current_component_function[FILENAME]}`;
 	}
 
-	w.hydration_html_changed(sanitize_location(location));
+	const sanitized = sanitize_location(location);
+	w.hydration_html_changed(sanitized === undefined ? undefined : { location: sanitized });
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/dom/elements/attributes.js b/packages/svelte/src/internal/client/dom/elements/attributes.js
index 0fe1b8b2d3..697fafe8e8 100644
--- a/packages/svelte/src/internal/client/dom/elements/attributes.js
+++ b/packages/svelte/src/internal/client/dom/elements/attributes.js
@@ -630,11 +630,11 @@ function check_src_in_dev_hydration(element, attribute, value) {
 	if (attribute === 'srcset' && srcset_url_equal(element, value)) return;
 	if (src_url_equal(element.getAttribute(attribute) ?? '', value)) return;
 
-	w.hydration_attribute_changed(
+	w.hydration_attribute_changed({
 		attribute,
-		element.outerHTML.replace(element.innerHTML, element.innerHTML && '...'),
-		String(value)
-	);
+		html: element.outerHTML.replace(element.innerHTML, element.innerHTML && '...'),
+		value: String(value)
+	});
 }
 
 /**
diff --git a/packages/svelte/src/internal/client/dom/elements/events.js b/packages/svelte/src/internal/client/dom/elements/events.js
index 0ed2ffc085..029a005469 100644
--- a/packages/svelte/src/internal/client/dom/elements/events.js
+++ b/packages/svelte/src/internal/client/dom/elements/events.js
@@ -363,7 +363,7 @@ export function apply(
 		const description = `\`${event_name}\` handler${location}`;
 		const suggestion = remove_parens ? 'remove the trailing `()`' : 'add a leading `() =>`';
 
-		w.event_handler_invalid(description, suggestion);
+		w.event_handler_invalid({ handler: description, suggestion });
 
 		if (error) {
 			throw error;
diff --git a/packages/svelte/src/internal/client/errors.js b/packages/svelte/src/internal/client/errors.js
index 175bb2e528..bc586833d1 100644
--- a/packages/svelte/src/internal/client/errors.js
+++ b/packages/svelte/src/internal/client/errors.js
@@ -2,493 +2,439 @@
 
 import { DEV } from 'esm-env';
 
-export *  from '../shared/errors.js';
+export * from '../shared/errors.js';
 
 /**
  * Cannot create a `$derived(...)` with an `await` expression outside of an effect tree
+ * @param {void} values
  * @returns {never}
  */
-export function async_derived_orphan() {
+export function async_derived_orphan(values) {
 	if (DEV) {
-		const error = new Error(`async_derived_orphan\nCannot create a \`$derived(...)\` with an \`await\` expression outside of an effect tree\nhttps://svelte.dev/e/async_derived_orphan`);
-
+		const error = new Error(`${'async_derived_orphan'}\n${`Cannot create a \`$derived(...)\` with an \`await\` expression outside of an effect tree`}\nhttps://svelte.dev/e/${'async_derived_orphan'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/async_derived_orphan`);
+		throw new Error(`https://svelte.dev/e/${'async_derived_orphan'}`);
 	}
 }
 
 /**
  * Using `bind:value` together with a checkbox input is not allowed. Use `bind:checked` instead
+ * @param {void} values
  * @returns {never}
  */
-export function bind_invalid_checkbox_value() {
+export function bind_invalid_checkbox_value(values) {
 	if (DEV) {
-		const error = new Error(`bind_invalid_checkbox_value\nUsing \`bind:value\` together with a checkbox input is not allowed. Use \`bind:checked\` instead\nhttps://svelte.dev/e/bind_invalid_checkbox_value`);
-
+		const error = new Error(`${'bind_invalid_checkbox_value'}\n${`Using \`bind:value\` together with a checkbox input is not allowed. Use \`bind:checked\` instead`}\nhttps://svelte.dev/e/${'bind_invalid_checkbox_value'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/bind_invalid_checkbox_value`);
+		throw new Error(`https://svelte.dev/e/${'bind_invalid_checkbox_value'}`);
 	}
 }
 
 /**
  * Component %component% has an export named `%key%` that a consumer component is trying to access using `bind:%key%`, which is disallowed. Instead, use `bind:this` (e.g. `<%name% bind:this={component} />`) and then access the property on the bound component instance (e.g. `component.%key%`)
- * @param {string} component
- * @param {string} key
- * @param {string} name
+ * @param {{ "component": string, "key": string, "name": string }} values
  * @returns {never}
  */
-export function bind_invalid_export(component, key, name) {
+export function bind_invalid_export(values) {
 	if (DEV) {
-		const error = new Error(`bind_invalid_export\nComponent ${component} has an export named \`${key}\` that a consumer component is trying to access using \`bind:${key}\`, which is disallowed. Instead, use \`bind:this\` (e.g. \`<${name} bind:this={component} />\`) and then access the property on the bound component instance (e.g. \`component.${key}\`)\nhttps://svelte.dev/e/bind_invalid_export`);
-
+		const error = new Error(`${'bind_invalid_export'}\n${`Component ${values.component} has an export named \`${values.key}\` that a consumer component is trying to access using \`bind:${values.key}\`, which is disallowed. Instead, use \`bind:this\` (e.g. \`<${values.name} bind:this={component} />\`) and then access the property on the bound component instance (e.g. \`component.${values.key}\`)`}\nhttps://svelte.dev/e/${'bind_invalid_export'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/bind_invalid_export`);
+		throw new Error(`https://svelte.dev/e/${'bind_invalid_export'}`);
 	}
 }
 
 /**
  * A component is attempting to bind to a non-bindable property `%key%` belonging to %component% (i.e. `<%name% bind:%key%={...}>`). To mark a property as bindable: `let { %key% = $bindable() } = $props()`
- * @param {string} key
- * @param {string} component
- * @param {string} name
+ * @param {{ "key": string, "component": string, "name": string }} values
  * @returns {never}
  */
-export function bind_not_bindable(key, component, name) {
+export function bind_not_bindable(values) {
 	if (DEV) {
-		const error = new Error(`bind_not_bindable\nA component is attempting to bind to a non-bindable property \`${key}\` belonging to ${component} (i.e. \`<${name} bind:${key}={...}>\`). To mark a property as bindable: \`let { ${key} = $bindable() } = $props()\`\nhttps://svelte.dev/e/bind_not_bindable`);
-
+		const error = new Error(`${'bind_not_bindable'}\n${`A component is attempting to bind to a non-bindable property \`${values.key}\` belonging to ${values.component} (i.e. \`<${values.name} bind:${values.key}={...}>\`). To mark a property as bindable: \`let { ${values.key} = $bindable() } = $props()\``}\nhttps://svelte.dev/e/${'bind_not_bindable'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/bind_not_bindable`);
+		throw new Error(`https://svelte.dev/e/${'bind_not_bindable'}`);
 	}
 }
 
 /**
  * Calling `%method%` on a component instance (of %component%) is no longer valid in Svelte 5
- * @param {string} method
- * @param {string} component
+ * @param {{ "method": string, "component": string }} values
  * @returns {never}
  */
-export function component_api_changed(method, component) {
+export function component_api_changed(values) {
 	if (DEV) {
-		const error = new Error(`component_api_changed\nCalling \`${method}\` on a component instance (of ${component}) is no longer valid in Svelte 5\nhttps://svelte.dev/e/component_api_changed`);
-
+		const error = new Error(`${'component_api_changed'}\n${`Calling \`${values.method}\` on a component instance (of ${values.component}) is no longer valid in Svelte 5`}\nhttps://svelte.dev/e/${'component_api_changed'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/component_api_changed`);
+		throw new Error(`https://svelte.dev/e/${'component_api_changed'}`);
 	}
 }
 
 /**
  * Attempted to instantiate %component% with `new %name%`, which is no longer valid in Svelte 5. If this component is not under your control, set the `compatibility.componentApi` compiler option to `4` to keep it working.
- * @param {string} component
- * @param {string} name
+ * @param {{ "component": string, "name": string }} values
  * @returns {never}
  */
-export function component_api_invalid_new(component, name) {
+export function component_api_invalid_new(values) {
 	if (DEV) {
-		const error = new Error(`component_api_invalid_new\nAttempted to instantiate ${component} with \`new ${name}\`, which is no longer valid in Svelte 5. If this component is not under your control, set the \`compatibility.componentApi\` compiler option to \`4\` to keep it working.\nhttps://svelte.dev/e/component_api_invalid_new`);
-
+		const error = new Error(`${'component_api_invalid_new'}\n${`Attempted to instantiate ${values.component} with \`new ${values.name}\`, which is no longer valid in Svelte 5. If this component is not under your control, set the \`compatibility.componentApi\` compiler option to \`4\` to keep it working.`}\nhttps://svelte.dev/e/${'component_api_invalid_new'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/component_api_invalid_new`);
+		throw new Error(`https://svelte.dev/e/${'component_api_invalid_new'}`);
 	}
 }
 
 /**
  * A derived value cannot reference itself recursively
+ * @param {void} values
  * @returns {never}
  */
-export function derived_references_self() {
+export function derived_references_self(values) {
 	if (DEV) {
-		const error = new Error(`derived_references_self\nA derived value cannot reference itself recursively\nhttps://svelte.dev/e/derived_references_self`);
-
+		const error = new Error(`${'derived_references_self'}\n${`A derived value cannot reference itself recursively`}\nhttps://svelte.dev/e/${'derived_references_self'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/derived_references_self`);
+		throw new Error(`https://svelte.dev/e/${'derived_references_self'}`);
 	}
 }
 
 /**
- * Keyed each block has duplicate key `%value%` at indexes %a% and %b%
- * @param {string} a
- * @param {string} b
- * @param {string | undefined | null} [value]
+ * Keyed each block has duplicate key at indexes %a% and %b%
+ * @param {{ "a": string, "b": string } | { "value": string, "a": string, "b": string }} values
  * @returns {never}
  */
-export function each_key_duplicate(a, b, value) {
+export function each_key_duplicate(values) {
 	if (DEV) {
-		const error = new Error(`each_key_duplicate\n${value
-			? `Keyed each block has duplicate key \`${value}\` at indexes ${a} and ${b}`
-			: `Keyed each block has duplicate key at indexes ${a} and ${b}`}\nhttps://svelte.dev/e/each_key_duplicate`);
-
+		const error = new Error(`${'each_key_duplicate'}\n${(values?.b !== undefined ? `Keyed each block has duplicate key \`${values.value}\` at indexes ${values.a} and ${values.b}` : `Keyed each block has duplicate key at indexes ${values.a} and ${values.b}`)}\nhttps://svelte.dev/e/${'each_key_duplicate'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/each_key_duplicate`);
+		throw new Error(`https://svelte.dev/e/${'each_key_duplicate'}`);
 	}
 }
 
 /**
  * Keyed each block has key that is not idempotent — the key for item at index %index% was `%a%` but is now `%b%`. Keys must be the same each time for a given item
- * @param {string} index
- * @param {string} a
- * @param {string} b
+ * @param {{ "index": string, "a": string, "b": string }} values
  * @returns {never}
  */
-export function each_key_volatile(index, a, b) {
+export function each_key_volatile(values) {
 	if (DEV) {
-		const error = new Error(`each_key_volatile\nKeyed each block has key that is not idempotent — the key for item at index ${index} was \`${a}\` but is now \`${b}\`. Keys must be the same each time for a given item\nhttps://svelte.dev/e/each_key_volatile`);
-
+		const error = new Error(`${'each_key_volatile'}\n${`Keyed each block has key that is not idempotent — the key for item at index ${values.index} was \`${values.a}\` but is now \`${values.b}\`. Keys must be the same each time for a given item`}\nhttps://svelte.dev/e/${'each_key_volatile'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/each_key_volatile`);
+		throw new Error(`https://svelte.dev/e/${'each_key_volatile'}`);
 	}
 }
 
 /**
  * `%rune%` cannot be used inside an effect cleanup function
- * @param {string} rune
+ * @param {{ "rune": string }} values
  * @returns {never}
  */
-export function effect_in_teardown(rune) {
+export function effect_in_teardown(values) {
 	if (DEV) {
-		const error = new Error(`effect_in_teardown\n\`${rune}\` cannot be used inside an effect cleanup function\nhttps://svelte.dev/e/effect_in_teardown`);
-
+		const error = new Error(`${'effect_in_teardown'}\n${`\`${values.rune}\` cannot be used inside an effect cleanup function`}\nhttps://svelte.dev/e/${'effect_in_teardown'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/effect_in_teardown`);
+		throw new Error(`https://svelte.dev/e/${'effect_in_teardown'}`);
 	}
 }
 
 /**
  * Effect cannot be created inside a `$derived` value that was not itself created inside an effect
+ * @param {void} values
  * @returns {never}
  */
-export function effect_in_unowned_derived() {
+export function effect_in_unowned_derived(values) {
 	if (DEV) {
-		const error = new Error(`effect_in_unowned_derived\nEffect cannot be created inside a \`$derived\` value that was not itself created inside an effect\nhttps://svelte.dev/e/effect_in_unowned_derived`);
-
+		const error = new Error(`${'effect_in_unowned_derived'}\n${`Effect cannot be created inside a \`$derived\` value that was not itself created inside an effect`}\nhttps://svelte.dev/e/${'effect_in_unowned_derived'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/effect_in_unowned_derived`);
+		throw new Error(`https://svelte.dev/e/${'effect_in_unowned_derived'}`);
 	}
 }
 
 /**
  * `%rune%` can only be used inside an effect (e.g. during component initialisation)
- * @param {string} rune
+ * @param {{ "rune": string }} values
  * @returns {never}
  */
-export function effect_orphan(rune) {
+export function effect_orphan(values) {
 	if (DEV) {
-		const error = new Error(`effect_orphan\n\`${rune}\` can only be used inside an effect (e.g. during component initialisation)\nhttps://svelte.dev/e/effect_orphan`);
-
+		const error = new Error(`${'effect_orphan'}\n${`\`${values.rune}\` can only be used inside an effect (e.g. during component initialisation)`}\nhttps://svelte.dev/e/${'effect_orphan'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/effect_orphan`);
+		throw new Error(`https://svelte.dev/e/${'effect_orphan'}`);
 	}
 }
 
 /**
  * `$effect.pending()` can only be called inside an effect or derived
+ * @param {void} values
  * @returns {never}
  */
-export function effect_pending_outside_reaction() {
+export function effect_pending_outside_reaction(values) {
 	if (DEV) {
-		const error = new Error(`effect_pending_outside_reaction\n\`$effect.pending()\` can only be called inside an effect or derived\nhttps://svelte.dev/e/effect_pending_outside_reaction`);
-
+		const error = new Error(`${'effect_pending_outside_reaction'}\n${`\`$effect.pending()\` can only be called inside an effect or derived`}\nhttps://svelte.dev/e/${'effect_pending_outside_reaction'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/effect_pending_outside_reaction`);
+		throw new Error(`https://svelte.dev/e/${'effect_pending_outside_reaction'}`);
 	}
 }
 
 /**
  * Maximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state
+ * @param {void} values
  * @returns {never}
  */
-export function effect_update_depth_exceeded() {
+export function effect_update_depth_exceeded(values) {
 	if (DEV) {
-		const error = new Error(`effect_update_depth_exceeded\nMaximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state\nhttps://svelte.dev/e/effect_update_depth_exceeded`);
-
+		const error = new Error(`${'effect_update_depth_exceeded'}\n${`Maximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state`}\nhttps://svelte.dev/e/${'effect_update_depth_exceeded'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
+		throw new Error(`https://svelte.dev/e/${'effect_update_depth_exceeded'}`);
 	}
 }
 
 /**
  * Cannot use `flushSync` inside an effect
+ * @param {void} values
  * @returns {never}
  */
-export function flush_sync_in_effect() {
+export function flush_sync_in_effect(values) {
 	if (DEV) {
-		const error = new Error(`flush_sync_in_effect\nCannot use \`flushSync\` inside an effect\nhttps://svelte.dev/e/flush_sync_in_effect`);
-
+		const error = new Error(`${'flush_sync_in_effect'}\n${`Cannot use \`flushSync\` inside an effect`}\nhttps://svelte.dev/e/${'flush_sync_in_effect'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/flush_sync_in_effect`);
+		throw new Error(`https://svelte.dev/e/${'flush_sync_in_effect'}`);
 	}
 }
 
 /**
  * Cannot commit a fork that was already discarded
+ * @param {void} values
  * @returns {never}
  */
-export function fork_discarded() {
+export function fork_discarded(values) {
 	if (DEV) {
-		const error = new Error(`fork_discarded\nCannot commit a fork that was already discarded\nhttps://svelte.dev/e/fork_discarded`);
-
+		const error = new Error(`${'fork_discarded'}\n${`Cannot commit a fork that was already discarded`}\nhttps://svelte.dev/e/${'fork_discarded'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/fork_discarded`);
+		throw new Error(`https://svelte.dev/e/${'fork_discarded'}`);
 	}
 }
 
 /**
  * Cannot create a fork inside an effect or when state changes are pending
+ * @param {void} values
  * @returns {never}
  */
-export function fork_timing() {
+export function fork_timing(values) {
 	if (DEV) {
-		const error = new Error(`fork_timing\nCannot create a fork inside an effect or when state changes are pending\nhttps://svelte.dev/e/fork_timing`);
-
+		const error = new Error(`${'fork_timing'}\n${`Cannot create a fork inside an effect or when state changes are pending`}\nhttps://svelte.dev/e/${'fork_timing'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/fork_timing`);
+		throw new Error(`https://svelte.dev/e/${'fork_timing'}`);
 	}
 }
 
 /**
  * `getAbortSignal()` can only be called inside an effect or derived
+ * @param {void} values
  * @returns {never}
  */
-export function get_abort_signal_outside_reaction() {
+export function get_abort_signal_outside_reaction(values) {
 	if (DEV) {
-		const error = new Error(`get_abort_signal_outside_reaction\n\`getAbortSignal()\` can only be called inside an effect or derived\nhttps://svelte.dev/e/get_abort_signal_outside_reaction`);
-
+		const error = new Error(`${'get_abort_signal_outside_reaction'}\n${`\`getAbortSignal()\` can only be called inside an effect or derived`}\nhttps://svelte.dev/e/${'get_abort_signal_outside_reaction'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/get_abort_signal_outside_reaction`);
+		throw new Error(`https://svelte.dev/e/${'get_abort_signal_outside_reaction'}`);
 	}
 }
 
 /**
  * Expected to find a hydratable with key `%key%` during hydration, but did not.
- * @param {string} key
+ * @param {{ "key": string }} values
  * @returns {never}
  */
-export function hydratable_missing_but_required(key) {
+export function hydratable_missing_but_required(values) {
 	if (DEV) {
-		const error = new Error(`hydratable_missing_but_required\nExpected to find a hydratable with key \`${key}\` during hydration, but did not.\nhttps://svelte.dev/e/hydratable_missing_but_required`);
-
+		const error = new Error(`${'hydratable_missing_but_required'}\n${`Expected to find a hydratable with key \`${values.key}\` during hydration, but did not.`}\nhttps://svelte.dev/e/${'hydratable_missing_but_required'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/hydratable_missing_but_required`);
+		throw new Error(`https://svelte.dev/e/${'hydratable_missing_but_required'}`);
 	}
 }
 
 /**
  * Failed to hydrate the application
+ * @param {void} values
  * @returns {never}
  */
-export function hydration_failed() {
+export function hydration_failed(values) {
 	if (DEV) {
-		const error = new Error(`hydration_failed\nFailed to hydrate the application\nhttps://svelte.dev/e/hydration_failed`);
-
+		const error = new Error(`${'hydration_failed'}\n${`Failed to hydrate the application`}\nhttps://svelte.dev/e/${'hydration_failed'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/hydration_failed`);
+		throw new Error(`https://svelte.dev/e/${'hydration_failed'}`);
 	}
 }
 
 /**
  * Could not `{@render}` snippet due to the expression being `null` or `undefined`. Consider using optional chaining `{@render snippet?.()}`
+ * @param {void} values
  * @returns {never}
  */
-export function invalid_snippet() {
+export function invalid_snippet(values) {
 	if (DEV) {
-		const error = new Error(`invalid_snippet\nCould not \`{@render}\` snippet due to the expression being \`null\` or \`undefined\`. Consider using optional chaining \`{@render snippet?.()}\`\nhttps://svelte.dev/e/invalid_snippet`);
-
+		const error = new Error(`${'invalid_snippet'}\n${`Could not \`{@render}\` snippet due to the expression being \`null\` or \`undefined\`. Consider using optional chaining \`{@render snippet?.()}\``}\nhttps://svelte.dev/e/${'invalid_snippet'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/invalid_snippet`);
+		throw new Error(`https://svelte.dev/e/${'invalid_snippet'}`);
 	}
 }
 
 /**
  * `%name%(...)` cannot be used in runes mode
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function lifecycle_legacy_only(name) {
+export function lifecycle_legacy_only(values) {
 	if (DEV) {
-		const error = new Error(`lifecycle_legacy_only\n\`${name}(...)\` cannot be used in runes mode\nhttps://svelte.dev/e/lifecycle_legacy_only`);
-
+		const error = new Error(`${'lifecycle_legacy_only'}\n${`\`${values.name}(...)\` cannot be used in runes mode`}\nhttps://svelte.dev/e/${'lifecycle_legacy_only'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/lifecycle_legacy_only`);
+		throw new Error(`https://svelte.dev/e/${'lifecycle_legacy_only'}`);
 	}
 }
 
 /**
  * Cannot do `bind:%key%={undefined}` when `%key%` has a fallback value
- * @param {string} key
+ * @param {{ "key": string }} values
  * @returns {never}
  */
-export function props_invalid_value(key) {
+export function props_invalid_value(values) {
 	if (DEV) {
-		const error = new Error(`props_invalid_value\nCannot do \`bind:${key}={undefined}\` when \`${key}\` has a fallback value\nhttps://svelte.dev/e/props_invalid_value`);
-
+		const error = new Error(`${'props_invalid_value'}\n${`Cannot do \`bind:${values.key}={undefined}\` when \`${values.key}\` has a fallback value`}\nhttps://svelte.dev/e/${'props_invalid_value'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/props_invalid_value`);
+		throw new Error(`https://svelte.dev/e/${'props_invalid_value'}`);
 	}
 }
 
 /**
  * Rest element properties of `$props()` such as `%property%` are readonly
- * @param {string} property
+ * @param {{ "property": string }} values
  * @returns {never}
  */
-export function props_rest_readonly(property) {
+export function props_rest_readonly(values) {
 	if (DEV) {
-		const error = new Error(`props_rest_readonly\nRest element properties of \`$props()\` such as \`${property}\` are readonly\nhttps://svelte.dev/e/props_rest_readonly`);
-
+		const error = new Error(`${'props_rest_readonly'}\n${`Rest element properties of \`$props()\` such as \`${values.property}\` are readonly`}\nhttps://svelte.dev/e/${'props_rest_readonly'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/props_rest_readonly`);
+		throw new Error(`https://svelte.dev/e/${'props_rest_readonly'}`);
 	}
 }
 
 /**
  * The `%rune%` rune is only available inside `.svelte` and `.svelte.js/ts` files
- * @param {string} rune
+ * @param {{ "rune": string }} values
  * @returns {never}
  */
-export function rune_outside_svelte(rune) {
+export function rune_outside_svelte(values) {
 	if (DEV) {
-		const error = new Error(`rune_outside_svelte\nThe \`${rune}\` rune is only available inside \`.svelte\` and \`.svelte.js/ts\` files\nhttps://svelte.dev/e/rune_outside_svelte`);
-
+		const error = new Error(`${'rune_outside_svelte'}\n${`The \`${values.rune}\` rune is only available inside \`.svelte\` and \`.svelte.js/ts\` files`}\nhttps://svelte.dev/e/${'rune_outside_svelte'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/rune_outside_svelte`);
+		throw new Error(`https://svelte.dev/e/${'rune_outside_svelte'}`);
 	}
 }
 
 /**
  * Property descriptors defined on `$state` objects must contain `value` and always be `enumerable`, `configurable` and `writable`.
+ * @param {void} values
  * @returns {never}
  */
-export function state_descriptors_fixed() {
+export function state_descriptors_fixed(values) {
 	if (DEV) {
-		const error = new Error(`state_descriptors_fixed\nProperty descriptors defined on \`$state\` objects must contain \`value\` and always be \`enumerable\`, \`configurable\` and \`writable\`.\nhttps://svelte.dev/e/state_descriptors_fixed`);
-
+		const error = new Error(`${'state_descriptors_fixed'}\n${`Property descriptors defined on \`$state\` objects must contain \`value\` and always be \`enumerable\`, \`configurable\` and \`writable\`.`}\nhttps://svelte.dev/e/${'state_descriptors_fixed'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
+		throw new Error(`https://svelte.dev/e/${'state_descriptors_fixed'}`);
 	}
 }
 
 /**
  * Cannot set prototype of `$state` object
+ * @param {void} values
  * @returns {never}
  */
-export function state_prototype_fixed() {
+export function state_prototype_fixed(values) {
 	if (DEV) {
-		const error = new Error(`state_prototype_fixed\nCannot set prototype of \`$state\` object\nhttps://svelte.dev/e/state_prototype_fixed`);
-
+		const error = new Error(`${'state_prototype_fixed'}\n${`Cannot set prototype of \`$state\` object`}\nhttps://svelte.dev/e/${'state_prototype_fixed'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
+		throw new Error(`https://svelte.dev/e/${'state_prototype_fixed'}`);
 	}
 }
 
 /**
  * Updating state inside `$derived(...)`, `$inspect(...)` or a template expression is forbidden. If the value should not be reactive, declare it without `$state`
+ * @param {void} values
  * @returns {never}
  */
-export function state_unsafe_mutation() {
+export function state_unsafe_mutation(values) {
 	if (DEV) {
-		const error = new Error(`state_unsafe_mutation\nUpdating state inside \`$derived(...)\`, \`$inspect(...)\` or a template expression is forbidden. If the value should not be reactive, declare it without \`$state\`\nhttps://svelte.dev/e/state_unsafe_mutation`);
-
+		const error = new Error(`${'state_unsafe_mutation'}\n${`Updating state inside \`$derived(...)\`, \`$inspect(...)\` or a template expression is forbidden. If the value should not be reactive, declare it without \`$state\``}\nhttps://svelte.dev/e/${'state_unsafe_mutation'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
+		throw new Error(`https://svelte.dev/e/${'state_unsafe_mutation'}`);
 	}
 }
 
 /**
  * A `<svelte:boundary>` `reset` function cannot be called while an error is still being handled
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_boundary_reset_onerror() {
+export function svelte_boundary_reset_onerror(values) {
 	if (DEV) {
-		const error = new Error(`svelte_boundary_reset_onerror\nA \`<svelte:boundary>\` \`reset\` function cannot be called while an error is still being handled\nhttps://svelte.dev/e/svelte_boundary_reset_onerror`);
-
+		const error = new Error(`${'svelte_boundary_reset_onerror'}\n${`A \`<svelte:boundary>\` \`reset\` function cannot be called while an error is still being handled`}\nhttps://svelte.dev/e/${'svelte_boundary_reset_onerror'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/svelte_boundary_reset_onerror`);
+		throw new Error(`https://svelte.dev/e/${'svelte_boundary_reset_onerror'}`);
 	}
-}
\ No newline at end of file
+}
diff --git a/packages/svelte/src/internal/client/hydratable.js b/packages/svelte/src/internal/client/hydratable.js
index 601b860a48..738fbdf285 100644
--- a/packages/svelte/src/internal/client/hydratable.js
+++ b/packages/svelte/src/internal/client/hydratable.js
@@ -12,7 +12,7 @@ import { DEV } from 'esm-env';
  */
 export function hydratable(key, fn) {
 	if (!async_mode_flag) {
-		e.experimental_async_required('hydratable');
+		e.experimental_async_required({ name: 'hydratable' });
 	}
 
 	if (hydrating) {
@@ -23,9 +23,9 @@ export function hydratable(key, fn) {
 		}
 
 		if (DEV) {
-			e.hydratable_missing_but_required(key);
+			e.hydratable_missing_but_required({ key });
 		} else {
-			w.hydratable_missing_but_expected(key);
+			w.hydratable_missing_but_expected({ key });
 		}
 	}
 
diff --git a/packages/svelte/src/internal/client/reactivity/batch.js b/packages/svelte/src/internal/client/reactivity/batch.js
index 8251f79298..3abce5c286 100644
--- a/packages/svelte/src/internal/client/reactivity/batch.js
+++ b/packages/svelte/src/internal/client/reactivity/batch.js
@@ -1375,7 +1375,7 @@ function reset_all(effect) {
  */
 export function fork(fn) {
 	if (!async_mode_flag) {
-		e.experimental_async_required('fork');
+		e.experimental_async_required({ name: 'fork' });
 	}
 
 	if (current_batch !== null) {
diff --git a/packages/svelte/src/internal/client/reactivity/deriveds.js b/packages/svelte/src/internal/client/reactivity/deriveds.js
index 6b48bc8a23..45d5675292 100644
--- a/packages/svelte/src/internal/client/reactivity/deriveds.js
+++ b/packages/svelte/src/internal/client/reactivity/deriveds.js
@@ -236,7 +236,10 @@ export function async_derived(fn, label, location) {
 
 					setTimeout(() => {
 						if (recent_async_deriveds.has(signal) && (effect.f & DESTROYED) === 0) {
-							w.await_waterfall(/** @type {string} */ (signal.label), location);
+							w.await_waterfall({
+								name: /** @type {string} */ (signal.label),
+								location
+							});
 							recent_async_deriveds.delete(signal);
 						}
 					});
diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js
index e69a639a94..96f809a9e2 100644
--- a/packages/svelte/src/internal/client/reactivity/effects.js
+++ b/packages/svelte/src/internal/client/reactivity/effects.js
@@ -54,14 +54,14 @@ import { set_signal_status } from './status.js';
 export function validate_effect(rune) {
 	if (active_effect === null) {
 		if (active_reaction === null) {
-			e.effect_orphan(rune);
+			e.effect_orphan({ rune });
 		}
 
 		e.effect_in_unowned_derived();
 	}
 
 	if (is_destroying_effect) {
-		e.effect_in_teardown(rune);
+		e.effect_in_teardown({ rune });
 	}
 }
 
diff --git a/packages/svelte/src/internal/client/reactivity/props.js b/packages/svelte/src/internal/client/reactivity/props.js
index 274d780b1e..f9e499bbd0 100644
--- a/packages/svelte/src/internal/client/reactivity/props.js
+++ b/packages/svelte/src/internal/client/reactivity/props.js
@@ -59,7 +59,7 @@ const rest_props_handler = {
 	set(target, key) {
 		if (DEV) {
 			// TODO should this happen in prod too?
-			e.props_rest_readonly(`${target.name}.${String(key)}`);
+			e.props_rest_readonly({ property: `${target.name}.${String(key)}` });
 		}
 
 		return false;
@@ -326,7 +326,7 @@ export function prop(props, key, flags, fallback) {
 		initial_value = get_fallback();
 
 		if (setter) {
-			if (runes) e.props_invalid_value(key);
+			if (runes) e.props_invalid_value({ key });
 			setter(initial_value);
 		}
 	}
diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js
index a881403f58..e99b74b1ad 100644
--- a/packages/svelte/src/internal/client/runtime.js
+++ b/packages/svelte/src/internal/client/runtime.js
@@ -618,7 +618,7 @@ export function get(signal) {
 		) {
 			reactivity_loss_tracker.warned = true;
 
-			w.await_reactivity_loss(/** @type {string} */ (signal.label));
+			w.await_reactivity_loss({ name: /** @type {string} */ (signal.label) });
 
 			var trace = get_error('traced at');
 			// eslint-disable-next-line no-console
diff --git a/packages/svelte/src/internal/client/validate.js b/packages/svelte/src/internal/client/validate.js
index a169225f1e..eec2918423 100644
--- a/packages/svelte/src/internal/client/validate.js
+++ b/packages/svelte/src/internal/client/validate.js
@@ -45,7 +45,7 @@ export function validate_binding(binding, blockers, get_object, get_property, li
 
 			if (effect.deps === null) {
 				var location = `${filename}:${line}:${column}`;
-				w.binding_property_non_reactive(binding, location);
+				w.binding_property_non_reactive({ binding, location });
 
 				warned = true;
 			}
diff --git a/packages/svelte/src/internal/client/warnings.js b/packages/svelte/src/internal/client/warnings.js
index ced1a8b2c3..81ea2913fd 100644
--- a/packages/svelte/src/internal/client/warnings.js
+++ b/packages/svelte/src/internal/client/warnings.js
@@ -7,265 +7,320 @@ var normal = 'font-weight: normal';
 
 /**
  * Assignment to `%property%` property (%location%) will evaluate to the right-hand side, not the value of `%property%` following the assignment. This may result in unexpected behaviour.
- * @param {string} property
- * @param {string} location
+ * @param {{ "property": string, "location": string }} values
  */
-export function assignment_value_stale(property, location) {
+export function assignment_value_stale(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] assignment_value_stale\n%cAssignment to \`${property}\` property (${location}) will evaluate to the right-hand side, not the value of \`${property}\` following the assignment. This may result in unexpected behaviour.\nhttps://svelte.dev/e/assignment_value_stale`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'assignment_value_stale'}\n%c${`Assignment to \`${values.property}\` property (${values.location}) will evaluate to the right-hand side, not the value of \`${values.property}\` following the assignment. This may result in unexpected behaviour.`}\nhttps://svelte.dev/e/${'assignment_value_stale'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/assignment_value_stale`);
+		console.warn(`https://svelte.dev/e/${'assignment_value_stale'}`);
 	}
 }
 
 /**
  * Detected reactivity loss when reading `%name%`. This happens when state is read in an async function after an earlier `await`
- * @param {string} name
+ * @param {{ "name": string }} values
  */
-export function await_reactivity_loss(name) {
+export function await_reactivity_loss(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] await_reactivity_loss\n%cDetected reactivity loss when reading \`${name}\`. This happens when state is read in an async function after an earlier \`await\`\nhttps://svelte.dev/e/await_reactivity_loss`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'await_reactivity_loss'}\n%c${`Detected reactivity loss when reading \`${values.name}\`. This happens when state is read in an async function after an earlier \`await\``}\nhttps://svelte.dev/e/${'await_reactivity_loss'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/await_reactivity_loss`);
+		console.warn(`https://svelte.dev/e/${'await_reactivity_loss'}`);
 	}
 }
 
 /**
  * An async derived, `%name%` (%location%) was not read immediately after it resolved. This often indicates an unnecessary waterfall, which can slow down your app
- * @param {string} name
- * @param {string} location
+ * @param {{ "name": string, "location": string }} values
  */
-export function await_waterfall(name, location) {
+export function await_waterfall(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] await_waterfall\n%cAn async derived, \`${name}\` (${location}) was not read immediately after it resolved. This often indicates an unnecessary waterfall, which can slow down your app\nhttps://svelte.dev/e/await_waterfall`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'await_waterfall'}\n%c${`An async derived, \`${values.name}\` (${values.location}) was not read immediately after it resolved. This often indicates an unnecessary waterfall, which can slow down your app`}\nhttps://svelte.dev/e/${'await_waterfall'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/await_waterfall`);
+		console.warn(`https://svelte.dev/e/${'await_waterfall'}`);
 	}
 }
 
 /**
- * `%binding%` (%location%) is binding to a non-reactive property
- * @param {string} binding
- * @param {string | undefined | null} [location]
+ * `%binding%` is binding to a non-reactive property
+ * @param {{ "binding": string } | { "binding": string, "location": string }} values
  */
-export function binding_property_non_reactive(binding, location) {
+export function binding_property_non_reactive(values) {
 	if (DEV) {
 		console.warn(
-			`%c[svelte] binding_property_non_reactive\n%c${location
-				? `\`${binding}\` (${location}) is binding to a non-reactive property`
-				: `\`${binding}\` is binding to a non-reactive property`}\nhttps://svelte.dev/e/binding_property_non_reactive`,
+			`%c[svelte] ${'binding_property_non_reactive'}\n%c${(values?.location !== undefined ? `\`${values.binding}\` (${values.location}) is binding to a non-reactive property` : `\`${values.binding}\` is binding to a non-reactive property`)}\nhttps://svelte.dev/e/${'binding_property_non_reactive'}`,
 			bold,
 			normal
 		);
 	} else {
-		console.warn(`https://svelte.dev/e/binding_property_non_reactive`);
+		console.warn(`https://svelte.dev/e/${'binding_property_non_reactive'}`);
 	}
 }
 
 /**
  * Your `console.%method%` contained `$state` proxies. Consider using `$inspect(...)` or `$state.snapshot(...)` instead
- * @param {string} method
+ * @param {{ "method": string }} values
  */
-export function console_log_state(method) {
+export function console_log_state(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] console_log_state\n%cYour \`console.${method}\` contained \`$state\` proxies. Consider using \`$inspect(...)\` or \`$state.snapshot(...)\` instead\nhttps://svelte.dev/e/console_log_state`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'console_log_state'}\n%c${`Your \`console.${values.method}\` contained \`$state\` proxies. Consider using \`$inspect(...)\` or \`$state.snapshot(...)\` instead`}\nhttps://svelte.dev/e/${'console_log_state'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/console_log_state`);
+		console.warn(`https://svelte.dev/e/${'console_log_state'}`);
 	}
 }
 
 /**
  * Reading a derived belonging to a now-destroyed effect may result in stale values
+ * @param {void} values
  */
-export function derived_inert() {
+export function derived_inert(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] derived_inert\n%cReading a derived belonging to a now-destroyed effect may result in stale values\nhttps://svelte.dev/e/derived_inert`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'derived_inert'}\n%c${`Reading a derived belonging to a now-destroyed effect may result in stale values`}\nhttps://svelte.dev/e/${'derived_inert'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/derived_inert`);
+		console.warn(`https://svelte.dev/e/${'derived_inert'}`);
 	}
 }
 
 /**
  * %handler% should be a function. Did you mean to %suggestion%?
- * @param {string} handler
- * @param {string} suggestion
+ * @param {{ "handler": string, "suggestion": string }} values
  */
-export function event_handler_invalid(handler, suggestion) {
+export function event_handler_invalid(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] event_handler_invalid\n%c${handler} should be a function. Did you mean to ${suggestion}?\nhttps://svelte.dev/e/event_handler_invalid`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'event_handler_invalid'}\n%c${`${values.handler} should be a function. Did you mean to ${values.suggestion}?`}\nhttps://svelte.dev/e/${'event_handler_invalid'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/event_handler_invalid`);
+		console.warn(`https://svelte.dev/e/${'event_handler_invalid'}`);
 	}
 }
 
 /**
  * Expected to find a hydratable with key `%key%` during hydration, but did not.
- * @param {string} key
+ * @param {{ "key": string }} values
  */
-export function hydratable_missing_but_expected(key) {
+export function hydratable_missing_but_expected(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] hydratable_missing_but_expected\n%cExpected to find a hydratable with key \`${key}\` during hydration, but did not.\nhttps://svelte.dev/e/hydratable_missing_but_expected`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'hydratable_missing_but_expected'}\n%c${`Expected to find a hydratable with key \`${values.key}\` during hydration, but did not.`}\nhttps://svelte.dev/e/${'hydratable_missing_but_expected'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/hydratable_missing_but_expected`);
+		console.warn(`https://svelte.dev/e/${'hydratable_missing_but_expected'}`);
 	}
 }
 
 /**
  * The `%attribute%` attribute on `%html%` changed its value between server and client renders. The client value, `%value%`, will be ignored in favour of the server value
- * @param {string} attribute
- * @param {string} html
- * @param {string} value
+ * @param {{ "attribute": string, "html": string, "value": string }} values
  */
-export function hydration_attribute_changed(attribute, html, value) {
+export function hydration_attribute_changed(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] hydration_attribute_changed\n%cThe \`${attribute}\` attribute on \`${html}\` changed its value between server and client renders. The client value, \`${value}\`, will be ignored in favour of the server value\nhttps://svelte.dev/e/hydration_attribute_changed`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'hydration_attribute_changed'}\n%c${`The \`${values.attribute}\` attribute on \`${values.html}\` changed its value between server and client renders. The client value, \`${values.value}\`, will be ignored in favour of the server value`}\nhttps://svelte.dev/e/${'hydration_attribute_changed'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/hydration_attribute_changed`);
+		console.warn(`https://svelte.dev/e/${'hydration_attribute_changed'}`);
 	}
 }
 
 /**
- * The value of an `{@html ...}` block %location% changed between server and client renders. The client value will be ignored in favour of the server value
- * @param {string | undefined | null} [location]
+ * The value of an `{@html ...}` block changed between server and client renders. The client value will be ignored in favour of the server value
+ * @param {void | { "location": string }} values
  */
-export function hydration_html_changed(location) {
+export function hydration_html_changed(values) {
 	if (DEV) {
 		console.warn(
-			`%c[svelte] hydration_html_changed\n%c${location
-				? `The value of an \`{@html ...}\` block ${location} changed between server and client renders. The client value will be ignored in favour of the server value`
-				: 'The value of an `{@html ...}` block changed between server and client renders. The client value will be ignored in favour of the server value'}\nhttps://svelte.dev/e/hydration_html_changed`,
+			`%c[svelte] ${'hydration_html_changed'}\n%c${(values?.location !== undefined ? `The value of an \`{@html ...}\` block ${values.location} changed between server and client renders. The client value will be ignored in favour of the server value` : `The value of an \`{@html ...}\` block changed between server and client renders. The client value will be ignored in favour of the server value`)}\nhttps://svelte.dev/e/${'hydration_html_changed'}`,
 			bold,
 			normal
 		);
 	} else {
-		console.warn(`https://svelte.dev/e/hydration_html_changed`);
+		console.warn(`https://svelte.dev/e/${'hydration_html_changed'}`);
 	}
 }
 
 /**
- * Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near %location%
- * @param {string | undefined | null} [location]
+ * Hydration failed because the initial UI does not match what was rendered on the server
+ * @param {void | { "location": string }} values
  */
-export function hydration_mismatch(location) {
+export function hydration_mismatch(values) {
 	if (DEV) {
 		console.warn(
-			`%c[svelte] hydration_mismatch\n%c${location
-				? `Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near ${location}`
-				: 'Hydration failed because the initial UI does not match what was rendered on the server'}\nhttps://svelte.dev/e/hydration_mismatch`,
+			`%c[svelte] ${'hydration_mismatch'}\n%c${(values?.location !== undefined ? `Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near ${values.location}` : `Hydration failed because the initial UI does not match what was rendered on the server`)}\nhttps://svelte.dev/e/${'hydration_mismatch'}`,
 			bold,
 			normal
 		);
 	} else {
-		console.warn(`https://svelte.dev/e/hydration_mismatch`);
+		console.warn(`https://svelte.dev/e/${'hydration_mismatch'}`);
 	}
 }
 
 /**
  * The `render` function passed to `createRawSnippet` should return HTML for a single element
+ * @param {void} values
  */
-export function invalid_raw_snippet_render() {
+export function invalid_raw_snippet_render(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] invalid_raw_snippet_render\n%cThe \`render\` function passed to \`createRawSnippet\` should return HTML for a single element\nhttps://svelte.dev/e/invalid_raw_snippet_render`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'invalid_raw_snippet_render'}\n%c${`The \`render\` function passed to \`createRawSnippet\` should return HTML for a single element`}\nhttps://svelte.dev/e/${'invalid_raw_snippet_render'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/invalid_raw_snippet_render`);
+		console.warn(`https://svelte.dev/e/${'invalid_raw_snippet_render'}`);
 	}
 }
 
 /**
  * Detected a migrated `$:` reactive block in `%filename%` that both accesses and updates the same reactive value. This may cause recursive updates when converted to an `$effect`.
- * @param {string} filename
+ * @param {{ "filename": string }} values
  */
-export function legacy_recursive_reactive_block(filename) {
+export function legacy_recursive_reactive_block(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] legacy_recursive_reactive_block\n%cDetected a migrated \`$:\` reactive block in \`${filename}\` that both accesses and updates the same reactive value. This may cause recursive updates when converted to an \`$effect\`.\nhttps://svelte.dev/e/legacy_recursive_reactive_block`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'legacy_recursive_reactive_block'}\n%c${`Detected a migrated \`$:\` reactive block in \`${values.filename}\` that both accesses and updates the same reactive value. This may cause recursive updates when converted to an \`$effect\`.`}\nhttps://svelte.dev/e/${'legacy_recursive_reactive_block'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/legacy_recursive_reactive_block`);
+		console.warn(`https://svelte.dev/e/${'legacy_recursive_reactive_block'}`);
 	}
 }
 
 /**
  * Tried to unmount a component that was not mounted
+ * @param {void} values
  */
-export function lifecycle_double_unmount() {
+export function lifecycle_double_unmount(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] lifecycle_double_unmount\n%cTried to unmount a component that was not mounted\nhttps://svelte.dev/e/lifecycle_double_unmount`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'lifecycle_double_unmount'}\n%c${`Tried to unmount a component that was not mounted`}\nhttps://svelte.dev/e/${'lifecycle_double_unmount'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/lifecycle_double_unmount`);
+		console.warn(`https://svelte.dev/e/${'lifecycle_double_unmount'}`);
 	}
 }
 
 /**
  * %parent% passed property `%prop%` to %child% with `bind:`, but its parent component %owner% did not declare `%prop%` as a binding. Consider creating a binding between %owner% and %parent% (e.g. `bind:%prop%={...}` instead of `%prop%={...}`)
- * @param {string} parent
- * @param {string} prop
- * @param {string} child
- * @param {string} owner
+ * @param {{ "parent": string, "prop": string, "child": string, "owner": string }} values
  */
-export function ownership_invalid_binding(parent, prop, child, owner) {
+export function ownership_invalid_binding(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] ownership_invalid_binding\n%c${parent} passed property \`${prop}\` to ${child} with \`bind:\`, but its parent component ${owner} did not declare \`${prop}\` as a binding. Consider creating a binding between ${owner} and ${parent} (e.g. \`bind:${prop}={...}\` instead of \`${prop}={...}\`)\nhttps://svelte.dev/e/ownership_invalid_binding`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'ownership_invalid_binding'}\n%c${`${values.parent} passed property \`${values.prop}\` to ${values.child} with \`bind:\`, but its parent component ${values.owner} did not declare \`${values.prop}\` as a binding. Consider creating a binding between ${values.owner} and ${values.parent} (e.g. \`bind:${values.prop}={...}\` instead of \`${values.prop}={...}\`)`}\nhttps://svelte.dev/e/${'ownership_invalid_binding'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/ownership_invalid_binding`);
+		console.warn(`https://svelte.dev/e/${'ownership_invalid_binding'}`);
 	}
 }
 
 /**
  * Mutating unbound props (`%name%`, at %location%) is strongly discouraged. Consider using `bind:%prop%={...}` in %parent% (or using a callback) instead
- * @param {string} name
- * @param {string} location
- * @param {string} prop
- * @param {string} parent
+ * @param {{ "name": string, "location": string, "prop": string, "parent": string }} values
  */
-export function ownership_invalid_mutation(name, location, prop, parent) {
+export function ownership_invalid_mutation(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] ownership_invalid_mutation\n%cMutating unbound props (\`${name}\`, at ${location}) is strongly discouraged. Consider using \`bind:${prop}={...}\` in ${parent} (or using a callback) instead\nhttps://svelte.dev/e/ownership_invalid_mutation`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'ownership_invalid_mutation'}\n%c${`Mutating unbound props (\`${values.name}\`, at ${values.location}) is strongly discouraged. Consider using \`bind:${values.prop}={...}\` in ${values.parent} (or using a callback) instead`}\nhttps://svelte.dev/e/${'ownership_invalid_mutation'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/ownership_invalid_mutation`);
+		console.warn(`https://svelte.dev/e/${'ownership_invalid_mutation'}`);
 	}
 }
 
 /**
  * The `value` property of a `<select multiple>` element should be an array, but it received a non-array value. The selection will be kept as is.
+ * @param {void} values
  */
-export function select_multiple_invalid_value() {
+export function select_multiple_invalid_value(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] select_multiple_invalid_value\n%cThe \`value\` property of a \`<select multiple>\` element should be an array, but it received a non-array value. The selection will be kept as is.\nhttps://svelte.dev/e/select_multiple_invalid_value`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'select_multiple_invalid_value'}\n%c${`The \`value\` property of a \`<select multiple>\` element should be an array, but it received a non-array value. The selection will be kept as is.`}\nhttps://svelte.dev/e/${'select_multiple_invalid_value'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/select_multiple_invalid_value`);
+		console.warn(`https://svelte.dev/e/${'select_multiple_invalid_value'}`);
 	}
 }
 
 /**
  * Reactive `$state(...)` proxies and the values they proxy have different identities. Because of this, comparisons with `%operator%` will produce unexpected results
- * @param {string} operator
+ * @param {{ "operator": string }} values
  */
-export function state_proxy_equality_mismatch(operator) {
+export function state_proxy_equality_mismatch(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] state_proxy_equality_mismatch\n%cReactive \`$state(...)\` proxies and the values they proxy have different identities. Because of this, comparisons with \`${operator}\` will produce unexpected results\nhttps://svelte.dev/e/state_proxy_equality_mismatch`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'state_proxy_equality_mismatch'}\n%c${`Reactive \`$state(...)\` proxies and the values they proxy have different identities. Because of this, comparisons with \`${values.operator}\` will produce unexpected results`}\nhttps://svelte.dev/e/${'state_proxy_equality_mismatch'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/state_proxy_equality_mismatch`);
+		console.warn(`https://svelte.dev/e/${'state_proxy_equality_mismatch'}`);
 	}
 }
 
 /**
  * A `<svelte:boundary>` `reset` function only resets the boundary the first time it is called
+ * @param {void} values
  */
-export function svelte_boundary_reset_noop() {
+export function svelte_boundary_reset_noop(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] svelte_boundary_reset_noop\n%cA \`<svelte:boundary>\` \`reset\` function only resets the boundary the first time it is called\nhttps://svelte.dev/e/svelte_boundary_reset_noop`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'svelte_boundary_reset_noop'}\n%c${`A \`<svelte:boundary>\` \`reset\` function only resets the boundary the first time it is called`}\nhttps://svelte.dev/e/${'svelte_boundary_reset_noop'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
+		console.warn(`https://svelte.dev/e/${'svelte_boundary_reset_noop'}`);
 	}
 }
 
 /**
  * The `slide` transition does not work correctly for elements with `display: %value%`
- * @param {string} value
+ * @param {{ "value": string }} values
  */
-export function transition_slide_display(value) {
+export function transition_slide_display(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] transition_slide_display\n%cThe \`slide\` transition does not work correctly for elements with \`display: ${value}\`\nhttps://svelte.dev/e/transition_slide_display`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'transition_slide_display'}\n%c${`The \`slide\` transition does not work correctly for elements with \`display: ${values.value}\``}\nhttps://svelte.dev/e/${'transition_slide_display'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/transition_slide_display`);
+		console.warn(`https://svelte.dev/e/${'transition_slide_display'}`);
 	}
-}
\ No newline at end of file
+}
diff --git a/packages/svelte/src/internal/server/errors.js b/packages/svelte/src/internal/server/errors.js
index 079bec3c91..da656caa9b 100644
--- a/packages/svelte/src/internal/server/errors.js
+++ b/packages/svelte/src/internal/server/errors.js
@@ -1,143 +1,127 @@
 /* This file is generated by scripts/process-messages/index.js. Do not edit! */
 
-export *  from '../shared/errors.js';
+export * from '../shared/errors.js';
 
 /**
  * The node API `AsyncLocalStorage` is not available, but is required to use async server rendering.
+ * @param {void} values
  * @returns {never}
  */
-export function async_local_storage_unavailable() {
-	const error = new Error(`async_local_storage_unavailable\nThe node API \`AsyncLocalStorage\` is not available, but is required to use async server rendering.\nhttps://svelte.dev/e/async_local_storage_unavailable`);
-
+export function async_local_storage_unavailable(values) {
+	const error = new Error(`${'async_local_storage_unavailable'}\n${`The node API \`AsyncLocalStorage\` is not available, but is required to use async server rendering.`}\nhttps://svelte.dev/e/${'async_local_storage_unavailable'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * Encountered asynchronous work while rendering synchronously.
+ * @param {void} values
  * @returns {never}
  */
-export function await_invalid() {
-	const error = new Error(`await_invalid\nEncountered asynchronous work while rendering synchronously.\nhttps://svelte.dev/e/await_invalid`);
-
+export function await_invalid(values) {
+	const error = new Error(`${'await_invalid'}\n${`Encountered asynchronous work while rendering synchronously.`}\nhttps://svelte.dev/e/${'await_invalid'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * `<svelte:element this="%tag%">` is not a valid element name — the element will not be rendered
- * @param {string} tag
+ * @param {{ "tag": string }} values
  * @returns {never}
  */
-export function dynamic_element_invalid_tag(tag) {
-	const error = new Error(`dynamic_element_invalid_tag\n\`<svelte:element this="${tag}">\` is not a valid element name — the element will not be rendered\nhttps://svelte.dev/e/dynamic_element_invalid_tag`);
-
+export function dynamic_element_invalid_tag(values) {
+	const error = new Error(`${'dynamic_element_invalid_tag'}\n${`\`<svelte:element this="${values.tag}">\` is not a valid element name — the element will not be rendered`}\nhttps://svelte.dev/e/${'dynamic_element_invalid_tag'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * The `html` property of server render results has been deprecated. Use `body` instead.
+ * @param {void} values
  * @returns {never}
  */
-export function html_deprecated() {
-	const error = new Error(`html_deprecated\nThe \`html\` property of server render results has been deprecated. Use \`body\` instead.\nhttps://svelte.dev/e/html_deprecated`);
-
+export function html_deprecated(values) {
+	const error = new Error(`${'html_deprecated'}\n${`The \`html\` property of server render results has been deprecated. Use \`body\` instead.`}\nhttps://svelte.dev/e/${'html_deprecated'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * Attempted to set `hydratable` with key `%key%` twice with different values.
- * 
- * %stack%
- * @param {string} key
- * @param {string} stack
+
+%stack%
+ * @param {{ "key": string, "stack": string }} values
  * @returns {never}
  */
-export function hydratable_clobbering(key, stack) {
-	const error = new Error(`hydratable_clobbering\nAttempted to set \`hydratable\` with key \`${key}\` twice with different values.
-
-${stack}\nhttps://svelte.dev/e/hydratable_clobbering`);
+export function hydratable_clobbering(values) {
+	const error = new Error(`${'hydratable_clobbering'}\n${`Attempted to set \`hydratable\` with key \`${values.key}\` twice with different values.
 
+${values.stack}`}\nhttps://svelte.dev/e/${'hydratable_clobbering'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * Failed to serialize `hydratable` data for key `%key%`.
- * 
- * `hydratable` can serialize anything [`uneval` from `devalue`](https://npmjs.com/package/uneval) can, plus Promises.
- * 
- * Cause:
- * %stack%
- * @param {string} key
- * @param {string} stack
+
+`hydratable` can serialize anything [`uneval` from `devalue`](https://npmjs.com/package/uneval) can, plus Promises.
+
+Cause:
+%stack%
+ * @param {{ "key": string, "stack": string }} values
  * @returns {never}
  */
-export function hydratable_serialization_failed(key, stack) {
-	const error = new Error(`hydratable_serialization_failed\nFailed to serialize \`hydratable\` data for key \`${key}\`.
+export function hydratable_serialization_failed(values) {
+	const error = new Error(`${'hydratable_serialization_failed'}\n${`Failed to serialize \`hydratable\` data for key \`${values.key}\`.
 
 \`hydratable\` can serialize anything [\`uneval\` from \`devalue\`](https://npmjs.com/package/uneval) can, plus Promises.
 
 Cause:
-${stack}\nhttps://svelte.dev/e/hydratable_serialization_failed`);
-
+${values.stack}`}\nhttps://svelte.dev/e/${'hydratable_serialization_failed'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * `csp.nonce` was set while `csp.hash` was `true`. These options cannot be used simultaneously.
+ * @param {void} values
  * @returns {never}
  */
-export function invalid_csp() {
-	const error = new Error(`invalid_csp\n\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.\nhttps://svelte.dev/e/invalid_csp`);
-
+export function invalid_csp(values) {
+	const error = new Error(`${'invalid_csp'}\n${`\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.`}\nhttps://svelte.dev/e/${'invalid_csp'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * The `idPrefix` option cannot include `--`.
+ * @param {void} values
  * @returns {never}
  */
-export function invalid_id_prefix() {
-	const error = new Error(`invalid_id_prefix\nThe \`idPrefix\` option cannot include \`--\`.\nhttps://svelte.dev/e/invalid_id_prefix`);
-
+export function invalid_id_prefix(values) {
+	const error = new Error(`${'invalid_id_prefix'}\n${`The \`idPrefix\` option cannot include \`--\`.`}\nhttps://svelte.dev/e/${'invalid_id_prefix'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * `%name%(...)` is not available on the server
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function lifecycle_function_unavailable(name) {
-	const error = new Error(`lifecycle_function_unavailable\n\`${name}(...)\` is not available on the server\nhttps://svelte.dev/e/lifecycle_function_unavailable`);
-
+export function lifecycle_function_unavailable(values) {
+	const error = new Error(`${'lifecycle_function_unavailable'}\n${`\`${values.name}(...)\` is not available on the server`}\nhttps://svelte.dev/e/${'lifecycle_function_unavailable'}`);
 	error.name = 'Svelte error';
-
 	throw error;
 }
 
 /**
  * Could not resolve `render` context.
+ * @param {void} values
  * @returns {never}
  */
-export function server_context_required() {
-	const error = new Error(`server_context_required\nCould not resolve \`render\` context.\nhttps://svelte.dev/e/server_context_required`);
-
+export function server_context_required(values) {
+	const error = new Error(`${'server_context_required'}\n${`Could not resolve \`render\` context.`}\nhttps://svelte.dev/e/${'server_context_required'}`);
 	error.name = 'Svelte error';
-
 	throw error;
-}
\ No newline at end of file
+}
diff --git a/packages/svelte/src/internal/server/hydratable.js b/packages/svelte/src/internal/server/hydratable.js
index be75288604..4770a0bc71 100644
--- a/packages/svelte/src/internal/server/hydratable.js
+++ b/packages/svelte/src/internal/server/hydratable.js
@@ -14,7 +14,7 @@ import { get_user_code_location } from './dev.js';
  */
 export function hydratable(key, fn) {
 	if (!async_mode_flag) {
-		e.experimental_async_required('hydratable');
+		e.experimental_async_required({ name: 'hydratable' });
 	}
 
 	const { hydratable } = get_render_context();
@@ -73,10 +73,10 @@ function encode(key, value, unresolved) {
 					);
 				})
 				.catch((devalue_error) =>
-					e.hydratable_serialization_failed(
+					e.hydratable_serialization_failed({
 						key,
-						serialization_stack(entry.stack, devalue_error?.stack)
-					)
+						stack: serialization_stack(entry.stack, devalue_error?.stack)
+					})
 				);
 
 			unresolved?.set(p, key);
@@ -127,7 +127,7 @@ async function compare(key, a, b) {
 				? `Occurred at:\n${a_stack}`
 				: `First occurrence at:\n${a_stack}\n\nSecond occurrence at:\n${b_stack}`;
 
-		e.hydratable_clobbering(key, stack);
+		e.hydratable_clobbering({ key, stack });
 	}
 }
 
diff --git a/packages/svelte/src/internal/server/index.js b/packages/svelte/src/internal/server/index.js
index 20bef78306..38b972db5d 100644
--- a/packages/svelte/src/internal/server/index.js
+++ b/packages/svelte/src/internal/server/index.js
@@ -42,7 +42,7 @@ export function element(renderer, tag, attributes_fn = noop, children_fn = noop)
 
 	if (tag) {
 		if (!REGEX_VALID_TAG_NAME.test(tag)) {
-			e.dynamic_element_invalid_tag(tag);
+			e.dynamic_element_invalid_tag({ tag });
 		}
 		renderer.push(`<${tag}`);
 		attributes_fn();
diff --git a/packages/svelte/src/internal/server/renderer.js b/packages/svelte/src/internal/server/renderer.js
index 6b3c1b28dd..76b9bb93a5 100644
--- a/packages/svelte/src/internal/server/renderer.js
+++ b/packages/svelte/src/internal/server/renderer.js
@@ -843,7 +843,10 @@ export class Renderer {
 		for (const [_, key] of ctx.unresolved_promises) {
 			// this is a problem -- it means we've finished the render but we're still waiting on a promise to resolve so we can
 			// serialize it, so we're blocking the response on useless content.
-			w.unresolved_hydratable(key, ctx.lookup.get(key)?.stack ?? '<missing stack trace>');
+			w.unresolved_hydratable({
+				key,
+				stack: ctx.lookup.get(key)?.stack ?? '<missing stack trace>'
+			});
 		}
 
 		for (const comparison of ctx.comparisons) {
diff --git a/packages/svelte/src/internal/server/warnings.js b/packages/svelte/src/internal/server/warnings.js
index fc44a086af..11b04c02a1 100644
--- a/packages/svelte/src/internal/server/warnings.js
+++ b/packages/svelte/src/internal/server/warnings.js
@@ -7,23 +7,22 @@ var normal = 'font-weight: normal';
 
 /**
  * A `hydratable` value with key `%key%` was created, but at least part of it was not used during the render.
- * 
- * The `hydratable` was initialized in:
- * %stack%
- * @param {string} key
- * @param {string} stack
+
+The `hydratable` was initialized in:
+%stack%
+ * @param {{ "key": string, "stack": string }} values
  */
-export function unresolved_hydratable(key, stack) {
+export function unresolved_hydratable(values) {
 	if (DEV) {
 		console.warn(
-			`%c[svelte] unresolved_hydratable\n%cA \`hydratable\` value with key \`${key}\` was created, but at least part of it was not used during the render.
+			`%c[svelte] ${'unresolved_hydratable'}\n%c${`A \`hydratable\` value with key \`${values.key}\` was created, but at least part of it was not used during the render.
 
 The \`hydratable\` was initialized in:
-${stack}\nhttps://svelte.dev/e/unresolved_hydratable`,
+${values.stack}`}\nhttps://svelte.dev/e/${'unresolved_hydratable'}`,
 			bold,
 			normal
 		);
 	} else {
-		console.warn(`https://svelte.dev/e/unresolved_hydratable`);
+		console.warn(`https://svelte.dev/e/${'unresolved_hydratable'}`);
 	}
-}
\ No newline at end of file
+}
diff --git a/packages/svelte/src/internal/shared/clone.js b/packages/svelte/src/internal/shared/clone.js
index ba0c731047..20144dbe5a 100644
--- a/packages/svelte/src/internal/shared/clone.js
+++ b/packages/svelte/src/internal/shared/clone.js
@@ -35,7 +35,7 @@ export function snapshot(value, skip_warning = false, no_tojson = false) {
 			let uncloned = slice.map((path) => `- <value>${path}`).join('\n');
 			if (excess > 0) uncloned += `\n- ...and ${excess} more`;
 
-			w.state_snapshot_uncloneable(uncloned);
+			w.state_snapshot_uncloneable({ properties: uncloned });
 		}
 
 		return copy;
diff --git a/packages/svelte/src/internal/shared/context.js b/packages/svelte/src/internal/shared/context.js
index 005c009101..ed9707c77c 100644
--- a/packages/svelte/src/internal/shared/context.js
+++ b/packages/svelte/src/internal/shared/context.js
@@ -46,7 +46,7 @@ function get_parent_context(context) {
  */
 export function get_or_init_context_map(context, name) {
 	if (context === null) {
-		lifecycle_outside_component(name);
+		lifecycle_outside_component({ name });
 	}
 
 	return (context.c ??= new Map(get_parent_context(context) || undefined));
diff --git a/packages/svelte/src/internal/shared/dev.js b/packages/svelte/src/internal/shared/dev.js
index 9c36664dc4..1bdc68783b 100644
--- a/packages/svelte/src/internal/shared/dev.js
+++ b/packages/svelte/src/internal/shared/dev.js
@@ -75,5 +75,5 @@ export function invariant(condition, message) {
 		throw new Error('invariant(...) was not guarded by if (DEV)');
 	}
 
-	if (!condition) e.invariant_violation(message);
+	if (!condition) e.invariant_violation({ message });
 }
diff --git a/packages/svelte/src/internal/shared/errors.js b/packages/svelte/src/internal/shared/errors.js
index 6cbbe82ca5..98d71b49ec 100644
--- a/packages/svelte/src/internal/shared/errors.js
+++ b/packages/svelte/src/internal/shared/errors.js
@@ -4,164 +4,150 @@ import { DEV } from 'esm-env';
 
 /**
  * Cannot use `%name%(...)` unless the `experimental.async` compiler option is `true`
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function experimental_async_required(name) {
+export function experimental_async_required(values) {
 	if (DEV) {
-		const error = new Error(`experimental_async_required\nCannot use \`${name}(...)\` unless the \`experimental.async\` compiler option is \`true\`\nhttps://svelte.dev/e/experimental_async_required`);
-
+		const error = new Error(`${'experimental_async_required'}\n${`Cannot use \`${values.name}(...)\` unless the \`experimental.async\` compiler option is \`true\``}\nhttps://svelte.dev/e/${'experimental_async_required'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/experimental_async_required`);
+		throw new Error(`https://svelte.dev/e/${'experimental_async_required'}`);
 	}
 }
 
 /**
  * Cannot use `{@render children(...)}` if the parent component uses `let:` directives. Consider using a named snippet instead
+ * @param {void} values
  * @returns {never}
  */
-export function invalid_default_snippet() {
+export function invalid_default_snippet(values) {
 	if (DEV) {
-		const error = new Error(`invalid_default_snippet\nCannot use \`{@render children(...)}\` if the parent component uses \`let:\` directives. Consider using a named snippet instead\nhttps://svelte.dev/e/invalid_default_snippet`);
-
+		const error = new Error(`${'invalid_default_snippet'}\n${`Cannot use \`{@render children(...)}\` if the parent component uses \`let:\` directives. Consider using a named snippet instead`}\nhttps://svelte.dev/e/${'invalid_default_snippet'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/invalid_default_snippet`);
+		throw new Error(`https://svelte.dev/e/${'invalid_default_snippet'}`);
 	}
 }
 
 /**
  * A snippet function was passed invalid arguments. Snippets should only be instantiated via `{@render ...}`
+ * @param {void} values
  * @returns {never}
  */
-export function invalid_snippet_arguments() {
+export function invalid_snippet_arguments(values) {
 	if (DEV) {
-		const error = new Error(`invalid_snippet_arguments\nA snippet function was passed invalid arguments. Snippets should only be instantiated via \`{@render ...}\`\nhttps://svelte.dev/e/invalid_snippet_arguments`);
-
+		const error = new Error(`${'invalid_snippet_arguments'}\n${`A snippet function was passed invalid arguments. Snippets should only be instantiated via \`{@render ...}\``}\nhttps://svelte.dev/e/${'invalid_snippet_arguments'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/invalid_snippet_arguments`);
+		throw new Error(`https://svelte.dev/e/${'invalid_snippet_arguments'}`);
 	}
 }
 
 /**
  * An invariant violation occurred, meaning Svelte's internal assumptions were flawed. This is a bug in Svelte, not your app — please open an issue at https://github.com/sveltejs/svelte, citing the following message: "%message%"
- * @param {string} message
+ * @param {{ "message": string }} values
  * @returns {never}
  */
-export function invariant_violation(message) {
+export function invariant_violation(values) {
 	if (DEV) {
-		const error = new Error(`invariant_violation\nAn invariant violation occurred, meaning Svelte's internal assumptions were flawed. This is a bug in Svelte, not your app — please open an issue at https://github.com/sveltejs/svelte, citing the following message: "${message}"\nhttps://svelte.dev/e/invariant_violation`);
-
+		const error = new Error(`${'invariant_violation'}\n${`An invariant violation occurred, meaning Svelte's internal assumptions were flawed. This is a bug in Svelte, not your app — please open an issue at https://github.com/sveltejs/svelte, citing the following message: "${values.message}"`}\nhttps://svelte.dev/e/${'invariant_violation'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/invariant_violation`);
+		throw new Error(`https://svelte.dev/e/${'invariant_violation'}`);
 	}
 }
 
 /**
  * `%name%(...)` can only be used during component initialisation
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function lifecycle_outside_component(name) {
+export function lifecycle_outside_component(values) {
 	if (DEV) {
-		const error = new Error(`lifecycle_outside_component\n\`${name}(...)\` can only be used during component initialisation\nhttps://svelte.dev/e/lifecycle_outside_component`);
-
+		const error = new Error(`${'lifecycle_outside_component'}\n${`\`${values.name}(...)\` can only be used during component initialisation`}\nhttps://svelte.dev/e/${'lifecycle_outside_component'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
+		throw new Error(`https://svelte.dev/e/${'lifecycle_outside_component'}`);
 	}
 }
 
 /**
  * Context was not set in the current component or any of its ancestors
+ * @param {void} values
  * @returns {never}
  */
-export function missing_context() {
+export function missing_context(values) {
 	if (DEV) {
-		const error = new Error(`missing_context\nContext was not set in the current component or any of its ancestors\nhttps://svelte.dev/e/missing_context`);
-
+		const error = new Error(`${'missing_context'}\n${`Context was not set in the current component or any of its ancestors`}\nhttps://svelte.dev/e/${'missing_context'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/missing_context`);
+		throw new Error(`https://svelte.dev/e/${'missing_context'}`);
 	}
 }
 
 /**
  * `setContext` must be called when a component first initializes, not in a subsequent effect or after an `await` expression
+ * @param {void} values
  * @returns {never}
  */
-export function set_context_after_init() {
+export function set_context_after_init(values) {
 	if (DEV) {
-		const error = new Error(`set_context_after_init\n\`setContext\` must be called when a component first initializes, not in a subsequent effect or after an \`await\` expression\nhttps://svelte.dev/e/set_context_after_init`);
-
+		const error = new Error(`${'set_context_after_init'}\n${`\`setContext\` must be called when a component first initializes, not in a subsequent effect or after an \`await\` expression`}\nhttps://svelte.dev/e/${'set_context_after_init'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/set_context_after_init`);
+		throw new Error(`https://svelte.dev/e/${'set_context_after_init'}`);
 	}
 }
 
 /**
  * Attempted to render a snippet without a `{@render}` block. This would cause the snippet code to be stringified instead of its content being rendered to the DOM. To fix this, change `{snippet}` to `{@render snippet()}`.
+ * @param {void} values
  * @returns {never}
  */
-export function snippet_without_render_tag() {
+export function snippet_without_render_tag(values) {
 	if (DEV) {
-		const error = new Error(`snippet_without_render_tag\nAttempted to render a snippet without a \`{@render}\` block. This would cause the snippet code to be stringified instead of its content being rendered to the DOM. To fix this, change \`{snippet}\` to \`{@render snippet()}\`.\nhttps://svelte.dev/e/snippet_without_render_tag`);
-
+		const error = new Error(`${'snippet_without_render_tag'}\n${`Attempted to render a snippet without a \`{@render}\` block. This would cause the snippet code to be stringified instead of its content being rendered to the DOM. To fix this, change \`{snippet}\` to \`{@render snippet()}\`.`}\nhttps://svelte.dev/e/${'snippet_without_render_tag'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/snippet_without_render_tag`);
+		throw new Error(`https://svelte.dev/e/${'snippet_without_render_tag'}`);
 	}
 }
 
 /**
  * `%name%` is not a store with a `subscribe` method
- * @param {string} name
+ * @param {{ "name": string }} values
  * @returns {never}
  */
-export function store_invalid_shape(name) {
+export function store_invalid_shape(values) {
 	if (DEV) {
-		const error = new Error(`store_invalid_shape\n\`${name}\` is not a store with a \`subscribe\` method\nhttps://svelte.dev/e/store_invalid_shape`);
-
+		const error = new Error(`${'store_invalid_shape'}\n${`\`${values.name}\` is not a store with a \`subscribe\` method`}\nhttps://svelte.dev/e/${'store_invalid_shape'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/store_invalid_shape`);
+		throw new Error(`https://svelte.dev/e/${'store_invalid_shape'}`);
 	}
 }
 
 /**
  * The `this` prop on `<svelte:element>` must be a string, if defined
+ * @param {void} values
  * @returns {never}
  */
-export function svelte_element_invalid_this_value() {
+export function svelte_element_invalid_this_value(values) {
 	if (DEV) {
-		const error = new Error(`svelte_element_invalid_this_value\nThe \`this\` prop on \`<svelte:element>\` must be a string, if defined\nhttps://svelte.dev/e/svelte_element_invalid_this_value`);
-
+		const error = new Error(`${'svelte_element_invalid_this_value'}\n${`The \`this\` prop on \`<svelte:element>\` must be a string, if defined`}\nhttps://svelte.dev/e/${'svelte_element_invalid_this_value'}`);
 		error.name = 'Svelte error';
-
 		throw error;
 	} else {
-		throw new Error(`https://svelte.dev/e/svelte_element_invalid_this_value`);
+		throw new Error(`https://svelte.dev/e/${'svelte_element_invalid_this_value'}`);
 	}
-}
\ No newline at end of file
+}
diff --git a/packages/svelte/src/internal/shared/validate.js b/packages/svelte/src/internal/shared/validate.js
index 48e76f0958..9f520642d8 100644
--- a/packages/svelte/src/internal/shared/validate.js
+++ b/packages/svelte/src/internal/shared/validate.js
@@ -11,7 +11,7 @@ export { invalid_default_snippet } from './errors.js';
 export function validate_void_dynamic_element(tag_fn) {
 	const tag = tag_fn();
 	if (tag && is_void(tag)) {
-		w.dynamic_void_element_content(tag);
+		w.dynamic_void_element_content({ tag });
 	}
 }
 
@@ -30,7 +30,7 @@ export function validate_dynamic_element_tag(tag_fn) {
  */
 export function validate_store(store, name) {
 	if (store != null && typeof store.subscribe !== 'function') {
-		e.store_invalid_shape(name);
+		e.store_invalid_shape({ name });
 	}
 }
 
diff --git a/packages/svelte/src/internal/shared/warnings.js b/packages/svelte/src/internal/shared/warnings.js
index 0acca44184..f05a7945f4 100644
--- a/packages/svelte/src/internal/shared/warnings.js
+++ b/packages/svelte/src/internal/shared/warnings.js
@@ -7,34 +7,34 @@ var normal = 'font-weight: normal';
 
 /**
  * `<svelte:element this="%tag%">` is a void element — it cannot have content
- * @param {string} tag
+ * @param {{ "tag": string }} values
  */
-export function dynamic_void_element_content(tag) {
+export function dynamic_void_element_content(values) {
 	if (DEV) {
-		console.warn(`%c[svelte] dynamic_void_element_content\n%c\`<svelte:element this="${tag}">\` is a void element — it cannot have content\nhttps://svelte.dev/e/dynamic_void_element_content`, bold, normal);
+		console.warn(
+			`%c[svelte] ${'dynamic_void_element_content'}\n%c${`\`<svelte:element this="${values.tag}">\` is a void element — it cannot have content`}\nhttps://svelte.dev/e/${'dynamic_void_element_content'}`,
+			bold,
+			normal
+		);
 	} else {
-		console.warn(`https://svelte.dev/e/dynamic_void_element_content`);
+		console.warn(`https://svelte.dev/e/${'dynamic_void_element_content'}`);
 	}
 }
 
 /**
- * The following properties cannot be cloned with `$state.snapshot` — the return value contains the originals:
- * 
- * %properties%
- * @param {string | undefined | null} [properties]
+ * Value cannot be cloned with `$state.snapshot` — the original value was returned
+ * @param {void | { "properties": string }} values
  */
-export function state_snapshot_uncloneable(properties) {
+export function state_snapshot_uncloneable(values) {
 	if (DEV) {
 		console.warn(
-			`%c[svelte] state_snapshot_uncloneable\n%c${properties
-				? `The following properties cannot be cloned with \`$state.snapshot\` — the return value contains the originals:
+			`%c[svelte] ${'state_snapshot_uncloneable'}\n%c${(values?.properties !== undefined ? `The following properties cannot be cloned with \`$state.snapshot\` — the return value contains the originals:
 
-${properties}`
-				: 'Value cannot be cloned with `$state.snapshot` — the original value was returned'}\nhttps://svelte.dev/e/state_snapshot_uncloneable`,
+${values.properties}` : `Value cannot be cloned with \`$state.snapshot\` — the original value was returned`)}\nhttps://svelte.dev/e/${'state_snapshot_uncloneable'}`,
 			bold,
 			normal
 		);
 	} else {
-		console.warn(`https://svelte.dev/e/state_snapshot_uncloneable`);
+		console.warn(`https://svelte.dev/e/${'state_snapshot_uncloneable'}`);
 	}
-}
\ No newline at end of file
+}
diff --git a/packages/svelte/src/legacy/legacy-client.js b/packages/svelte/src/legacy/legacy-client.js
index 801c126b2c..4b33d4e1c8 100644
--- a/packages/svelte/src/legacy/legacy-client.js
+++ b/packages/svelte/src/legacy/legacy-client.js
@@ -198,7 +198,7 @@ export function run(fn) {
 				// @ts-ignore
 				filename = dev_current_component_function?.[FILENAME] ?? filename;
 			}
-			w.legacy_recursive_reactive_block(filename);
+			w.legacy_recursive_reactive_block({ filename });
 			set_signal_status(effect, MAYBE_DIRTY);
 		}
 	});
@@ -250,7 +250,7 @@ export function handlers(...handlers) {
 export function createBubbler() {
 	const active_component_context = component_context;
 	if (active_component_context === null) {
-		e.lifecycle_outside_component('createBubbler');
+		e.lifecycle_outside_component({ name: 'createBubbler' });
 	}
 
 	return (/**@type {string}*/ type) => (/**@type {Event}*/ event) => {
diff --git a/packages/svelte/src/transition/index.js b/packages/svelte/src/transition/index.js
index 31e8fbde2b..520747d3b9 100644
--- a/packages/svelte/src/transition/index.js
+++ b/packages/svelte/src/transition/index.js
@@ -122,7 +122,7 @@ export function slide(node, { delay = 0, duration = 400, easing = cubic_out, axi
 	if (DEV && !slide_warning && /(contents|inline|table)/.test(style.display)) {
 		slide_warning = true;
 		Promise.resolve().then(() => (slide_warning = false));
-		w.transition_slide_display(style.display);
+		w.transition_slide_display({ value: style.display });
 	}
 
 	const opacity = +style.opacity;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e7fee7b592..3532acb133 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -132,6 +132,9 @@ importers:
       '@rollup/plugin-virtual':
         specifier: ^3.0.2
         version: 3.0.2(rollup@4.62.2)
+      '@sveltejs/message-box':
+        specifier: ^1.1.0
+        version: 1.1.0
       '@types/aria-query':
         specifier: ^5.0.4
         version: 5.0.4
@@ -937,6 +940,9 @@ packages:
       typescript: '>= 5'
       typescript-eslint: '>= 8'
 
+  '@sveltejs/message-box@1.1.0':
+    resolution: {integrity: sha512-zJ9WUolgv6W4IpAHBSu4da5Uha4Je4ZGrKjVyIY4jWSqkJNbofoCgZxRoLuKExcyXODphzommhsHH/42zxd6zg==}
+
   '@sveltejs/vite-plugin-svelte-inspector@5.0.1':
     resolution: {integrity: sha512-ubWshlMk4bc8mkwWbg6vNvCeT7lGQojE3ijDh3QTR6Zr/R+GXxsGbyH4PExEPpiFmqPhYiVSVmHBjUcVc1JIrA==}
     engines: {node: ^20.19 || ^22.12 || >=24}
@@ -3072,6 +3078,8 @@ snapshots:
       typescript: 5.5.4
       typescript-eslint: 8.56.0(eslint@10.0.0)(typescript@5.5.4)
 
+  '@sveltejs/message-box@1.1.0': {}
+
   '@sveltejs/vite-plugin-svelte-inspector@5.0.1(@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)))(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
     dependencies:
       '@sveltejs/vite-plugin-svelte': 6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))

From 4d5fa48995a14c9ada1c2b932e3cf36dc7f4c8ea Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 1 Sep 2026 12:18:20 +0100
Subject: [PATCH 2/5] simplify

---
 packages/svelte/scripts/process-messages/index.js | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/packages/svelte/scripts/process-messages/index.js b/packages/svelte/scripts/process-messages/index.js
index ef817b8f7d..97e1868f1a 100644
--- a/packages/svelte/scripts/process-messages/index.js
+++ b/packages/svelte/scripts/process-messages/index.js
@@ -40,16 +40,11 @@ function run() {
 
 			const sorted = Array.from(
 				markdown.matchAll(/## ([\w]+)\n\n([^]+?)(?=$|\n\n## )/g),
-				([_, code]) => ({
-					code,
-					_
-				})
-			);
-			sorted.sort((a, b) => (a.code < b.code ? -1 : 1));
+			).map((m) => m[0]).sort();
 
 			fs.writeFileSync(
 				`messages/${category}/${file}`,
-				sorted.map((x) => x._.trim()).join('\n\n') + '\n'
+				sorted.map((x) => x.trim()).join('\n\n') + '\n'
 			);
 		}
 

From 03d3896aa09f33ce3e7bac79d097e68d6d03fdc4 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 1 Sep 2026 16:36:30 +0100
Subject: [PATCH 3/5] bump

---
 packages/svelte/package.json                  |  2 +-
 packages/svelte/src/internal/client/errors.js |  4 ++--
 pnpm-lock.yaml                                | 10 +++++-----
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/packages/svelte/package.json b/packages/svelte/package.json
index 3596345da6..491d7045d7 100644
--- a/packages/svelte/package.json
+++ b/packages/svelte/package.json
@@ -157,7 +157,7 @@
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-virtual": "^3.0.2",
-    "@sveltejs/message-box": "^1.1.0",
+    "@sveltejs/message-box": "^1.1.1",
     "@types/aria-query": "^5.0.4",
     "@types/node": "^20.11.5",
     "@types/trusted-types": "^2.0.7",
diff --git a/packages/svelte/src/internal/client/errors.js b/packages/svelte/src/internal/client/errors.js
index bc586833d1..334f4aa0be 100644
--- a/packages/svelte/src/internal/client/errors.js
+++ b/packages/svelte/src/internal/client/errors.js
@@ -111,12 +111,12 @@ export function derived_references_self(values) {
 
 /**
  * Keyed each block has duplicate key at indexes %a% and %b%
- * @param {{ "a": string, "b": string } | { "value": string, "a": string, "b": string }} values
+ * @param {{ "a": string, "b": string } | { "a": string, "b": string, "value": string }} values
  * @returns {never}
  */
 export function each_key_duplicate(values) {
 	if (DEV) {
-		const error = new Error(`${'each_key_duplicate'}\n${(values?.b !== undefined ? `Keyed each block has duplicate key \`${values.value}\` at indexes ${values.a} and ${values.b}` : `Keyed each block has duplicate key at indexes ${values.a} and ${values.b}`)}\nhttps://svelte.dev/e/${'each_key_duplicate'}`);
+		const error = new Error(`${'each_key_duplicate'}\n${(values?.value !== undefined ? `Keyed each block has duplicate key \`${values.value}\` at indexes ${values.a} and ${values.b}` : `Keyed each block has duplicate key at indexes ${values.a} and ${values.b}`)}\nhttps://svelte.dev/e/${'each_key_duplicate'}`);
 		error.name = 'Svelte error';
 		throw error;
 	} else {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3532acb133..e5a866e7fa 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -133,8 +133,8 @@ importers:
         specifier: ^3.0.2
         version: 3.0.2(rollup@4.62.2)
       '@sveltejs/message-box':
-        specifier: ^1.1.0
-        version: 1.1.0
+        specifier: ^1.1.1
+        version: 1.1.1
       '@types/aria-query':
         specifier: ^5.0.4
         version: 5.0.4
@@ -940,8 +940,8 @@ packages:
       typescript: '>= 5'
       typescript-eslint: '>= 8'
 
-  '@sveltejs/message-box@1.1.0':
-    resolution: {integrity: sha512-zJ9WUolgv6W4IpAHBSu4da5Uha4Je4ZGrKjVyIY4jWSqkJNbofoCgZxRoLuKExcyXODphzommhsHH/42zxd6zg==}
+  '@sveltejs/message-box@1.1.1':
+    resolution: {integrity: sha512-4Qab06sApD/yZXCZb3we9qYh2ZNslSlAlqc+LCkkPBloNqwFiBTg/lf4/XloXY4T0xKODUyFK7lhNYafNWeIHw==}
 
   '@sveltejs/vite-plugin-svelte-inspector@5.0.1':
     resolution: {integrity: sha512-ubWshlMk4bc8mkwWbg6vNvCeT7lGQojE3ijDh3QTR6Zr/R+GXxsGbyH4PExEPpiFmqPhYiVSVmHBjUcVc1JIrA==}
@@ -3078,7 +3078,7 @@ snapshots:
       typescript: 5.5.4
       typescript-eslint: 8.56.0(eslint@10.0.0)(typescript@5.5.4)
 
-  '@sveltejs/message-box@1.1.0': {}
+  '@sveltejs/message-box@1.1.1': {}
 
   '@sveltejs/vite-plugin-svelte-inspector@5.0.1(@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)))(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
     dependencies:

From b3a00ec91685fbb2757eaf821daeabcaeadd9d9e Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 1 Sep 2026 17:02:13 +0100
Subject: [PATCH 4/5] fix

---
 packages/svelte/package.json                  |  2 +-
 packages/svelte/src/compiler/errors.js        | 20 ++++-----
 packages/svelte/src/compiler/warnings.js      | 42 +++++++++----------
 packages/svelte/src/internal/client/errors.js | 12 +++---
 .../svelte/src/internal/client/warnings.js    | 14 +++----
 packages/svelte/src/internal/server/errors.js |  4 +-
 .../svelte/src/internal/server/warnings.js    |  2 +-
 pnpm-lock.yaml                                | 10 ++---
 8 files changed, 53 insertions(+), 53 deletions(-)

diff --git a/packages/svelte/package.json b/packages/svelte/package.json
index 491d7045d7..2aaff04482 100644
--- a/packages/svelte/package.json
+++ b/packages/svelte/package.json
@@ -157,7 +157,7 @@
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-virtual": "^3.0.2",
-    "@sveltejs/message-box": "^1.1.1",
+    "@sveltejs/message-box": "^1.1.2",
     "@types/aria-query": "^5.0.4",
     "@types/node": "^20.11.5",
     "@types/trusted-types": "^2.0.7",
diff --git a/packages/svelte/src/compiler/errors.js b/packages/svelte/src/compiler/errors.js
index c96d214b56..e809607f09 100644
--- a/packages/svelte/src/compiler/errors.js
+++ b/packages/svelte/src/compiler/errors.js
@@ -414,7 +414,7 @@ export function rune_invalid_arguments(node, values) {
 /**
  * `%rune%` must be called with %args%
  * @param {null | number | NodeLike} node
- * @param {{ "rune": string, "args": string }} values
+ * @param {{ "rune": string; "args": string }} values
  * @returns {never}
  */
 export function rune_invalid_arguments_length(node, values) {
@@ -484,7 +484,7 @@ export function rune_removed(node, values) {
 /**
  * `%name%` is now `%replacement%`
  * @param {null | number | NodeLike} node
- * @param {{ "name": string, "replacement": string }} values
+ * @param {{ "name": string; "replacement": string }} values
  * @returns {never}
  */
 export function rune_renamed(node, values) {
@@ -904,7 +904,7 @@ export function bind_invalid_expression(node, values) {
 /**
  * `bind:%name%` is not a valid binding
  * @param {null | number | NodeLike} node
- * @param {{ "name": string } | { "name": string, "explanation": string }} values
+ * @param {{ "name": string; "explanation"?: string }} values
  * @returns {never}
  */
 export function bind_invalid_name(node, values) {
@@ -924,7 +924,7 @@ export function bind_invalid_parens(node, values) {
 /**
  * `bind:%name%` can only be used with %elements%
  * @param {null | number | NodeLike} node
- * @param {{ "name": string, "elements": string }} values
+ * @param {{ "name": string; "elements": string }} values
  * @returns {never}
  */
 export function bind_invalid_target(node, values) {
@@ -974,7 +974,7 @@ export function block_invalid_elseif(node, values) {
 /**
  * {#%name% ...} block cannot be %location%
  * @param {null | number | NodeLike} node
- * @param {{ "name": string, "location": string }} values
+ * @param {{ "name": string; "location": string }} values
  * @returns {never}
  */
 export function block_invalid_placement(node, values) {
@@ -1134,7 +1134,7 @@ export function element_invalid_closing_tag(node, values) {
 /**
  * `</%name%>` attempted to close element that was already automatically closed by `<%reason%>` (cannot nest `<%reason%>` inside `<%name%>`)
  * @param {null | number | NodeLike} node
- * @param {{ "name": string, "reason": string }} values
+ * @param {{ "name": string; "reason": string }} values
  * @returns {never}
  */
 export function element_invalid_closing_tag_autoclosed(node, values) {
@@ -1174,7 +1174,7 @@ export function event_handler_invalid_modifier(node, values) {
 /**
  * The '%modifier1%' and '%modifier2%' modifiers cannot be used together
  * @param {null | number | NodeLike} node
- * @param {{ "modifier1": string, "modifier2": string }} values
+ * @param {{ "modifier1": string; "modifier2": string }} values
  * @returns {never}
  */
 export function event_handler_invalid_modifier_combination(node, values) {
@@ -1384,7 +1384,7 @@ export function script_reserved_attribute(node, values) {
 /**
  * Duplicate slot name '%name%' in <%component%>
  * @param {null | number | NodeLike} node
- * @param {{ "name": string, "component": string }} values
+ * @param {{ "name": string; "component": string }} values
  * @returns {never}
  */
 export function slot_attribute_duplicate(node, values) {
@@ -1754,7 +1754,7 @@ export function tag_invalid_name(node, values) {
 /**
  * {@%name% ...} tag cannot be %location%
  * @param {null | number | NodeLike} node
- * @param {{ "name": string, "location": string }} values
+ * @param {{ "name": string; "location": string }} values
  * @returns {never}
  */
 export function tag_invalid_placement(node, values) {
@@ -1794,7 +1794,7 @@ export function title_invalid_content(node, values) {
 /**
  * Cannot use `%type%:` alongside existing `%existing%:` directive
  * @param {null | number | NodeLike} node
- * @param {{ "type": string, "existing": string }} values
+ * @param {{ "type": string; "existing": string }} values
  * @returns {never}
  */
 export function transition_conflict(node, values) {
diff --git a/packages/svelte/src/compiler/warnings.js b/packages/svelte/src/compiler/warnings.js
index 8e3af7d959..7fffa5e70f 100644
--- a/packages/svelte/src/compiler/warnings.js
+++ b/packages/svelte/src/compiler/warnings.js
@@ -155,7 +155,7 @@ export function a11y_aria_attributes(node, values) {
 /**
  * '%value%' is an invalid value for 'autocomplete' on `<input type="%type%">`
  * @param {null | NodeLike} node
- * @param {{ "value": string, "type": string }} values
+ * @param {{ "value": string; "type": string }} values
  */
 export function a11y_autocomplete_valid(node, values) {
 	w(node, 'a11y_autocomplete_valid', `${`'${values.value}' is an invalid value for 'autocomplete' on \`<input type="${values.type}">\``}\nhttps://svelte.dev/e/${'a11y_autocomplete_valid'}`);
@@ -236,7 +236,7 @@ export function a11y_img_redundant_alt(node, values) {
 /**
  * The value of '%attribute%' must be a %type%
  * @param {null | NodeLike} node
- * @param {{ "attribute": string, "type": string }} values
+ * @param {{ "attribute": string; "type": string }} values
  */
 export function a11y_incorrect_aria_attribute_type(node, values) {
 	w(node, 'a11y_incorrect_aria_attribute_type', `${`The value of '${values.attribute}' must be a ${values.type}`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type'}`);
@@ -281,7 +281,7 @@ export function a11y_incorrect_aria_attribute_type_integer(node, values) {
 /**
  * The value of '%attribute%' must be exactly one of %values%
  * @param {null | NodeLike} node
- * @param {{ "attribute": string, "values": string }} values
+ * @param {{ "attribute": string; "values": string }} values
  */
 export function a11y_incorrect_aria_attribute_type_token(node, values) {
 	w(node, 'a11y_incorrect_aria_attribute_type_token', `${`The value of '${values.attribute}' must be exactly one of ${values.values}`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_token'}`);
@@ -290,7 +290,7 @@ export function a11y_incorrect_aria_attribute_type_token(node, values) {
 /**
  * The value of '%attribute%' must be a space-separated list of one or more of %values%
  * @param {null | NodeLike} node
- * @param {{ "attribute": string, "values": string }} values
+ * @param {{ "attribute": string; "values": string }} values
  */
 export function a11y_incorrect_aria_attribute_type_tokenlist(node, values) {
 	w(node, 'a11y_incorrect_aria_attribute_type_tokenlist', `${`The value of '${values.attribute}' must be a space-separated list of one or more of ${values.values}`}\nhttps://svelte.dev/e/${'a11y_incorrect_aria_attribute_type_tokenlist'}`);
@@ -317,7 +317,7 @@ export function a11y_interactive_supports_focus(node, values) {
 /**
  * '%href_value%' is not a valid %href_attribute% attribute
  * @param {null | NodeLike} node
- * @param {{ "href_value": string, "href_attribute": string }} values
+ * @param {{ "href_value": string; "href_attribute": string }} values
  */
 export function a11y_invalid_attribute(node, values) {
 	w(node, 'a11y_invalid_attribute', `${`'${values.href_value}' is not a valid ${values.href_attribute} attribute`}\nhttps://svelte.dev/e/${'a11y_invalid_attribute'}`);
@@ -362,7 +362,7 @@ export function a11y_misplaced_scope(node, values) {
 /**
  * `<%name%>` element should have %article% %sequence% attribute
  * @param {null | NodeLike} node
- * @param {{ "name": string, "article": string, "sequence": string }} values
+ * @param {{ "name": string; "article": string; "sequence": string }} values
  */
 export function a11y_missing_attribute(node, values) {
 	w(node, 'a11y_missing_attribute', `${`\`<${values.name}>\` element should have ${values.article} ${values.sequence} attribute`}\nhttps://svelte.dev/e/${'a11y_missing_attribute'}`);
@@ -380,7 +380,7 @@ export function a11y_missing_content(node, values) {
 /**
  * '%event%' event must be accompanied by '%accompanied_by%' event
  * @param {null | NodeLike} node
- * @param {{ "event": string, "accompanied_by": string }} values
+ * @param {{ "event": string; "accompanied_by": string }} values
  */
 export function a11y_mouse_events_have_key_events(node, values) {
 	w(node, 'a11y_mouse_events_have_key_events', `${`'${values.event}' event must be accompanied by '${values.accompanied_by}' event`}\nhttps://svelte.dev/e/${'a11y_mouse_events_have_key_events'}`);
@@ -398,7 +398,7 @@ export function a11y_no_abstract_role(node, values) {
 /**
  * `<%element%>` cannot have role '%role%'
  * @param {null | NodeLike} node
- * @param {{ "element": string, "role": string }} values
+ * @param {{ "element": string; "role": string }} values
  */
 export function a11y_no_interactive_element_to_noninteractive_role(node, values) {
 	w(node, 'a11y_no_interactive_element_to_noninteractive_role', `${`\`<${values.element}>\` cannot have role '${values.role}'`}\nhttps://svelte.dev/e/${'a11y_no_interactive_element_to_noninteractive_role'}`);
@@ -416,7 +416,7 @@ export function a11y_no_noninteractive_element_interactions(node, values) {
 /**
  * Non-interactive element `<%element%>` cannot have interactive role '%role%'
  * @param {null | NodeLike} node
- * @param {{ "element": string, "role": string }} values
+ * @param {{ "element": string; "role": string }} values
  */
 export function a11y_no_noninteractive_element_to_interactive_role(node, values) {
 	w(node, 'a11y_no_noninteractive_element_to_interactive_role', `${`Non-interactive element \`<${values.element}>\` cannot have interactive role '${values.role}'`}\nhttps://svelte.dev/e/${'a11y_no_noninteractive_element_to_interactive_role'}`);
@@ -443,7 +443,7 @@ export function a11y_no_redundant_roles(node, values) {
 /**
  * `<%element%>` with a %handler% handler must have an ARIA role
  * @param {null | NodeLike} node
- * @param {{ "element": string, "handler": string }} values
+ * @param {{ "element": string; "handler": string }} values
  */
 export function a11y_no_static_element_interactions(node, values) {
 	w(node, 'a11y_no_static_element_interactions', `${`\`<${values.element}>\` with a ${values.handler} handler must have an ARIA role`}\nhttps://svelte.dev/e/${'a11y_no_static_element_interactions'}`);
@@ -461,7 +461,7 @@ export function a11y_positive_tabindex(node, values) {
 /**
  * Elements with the ARIA role "%role%" must have the following attributes defined: %props%
  * @param {null | NodeLike} node
- * @param {{ "role": string, "props": string }} values
+ * @param {{ "role": string; "props": string }} values
  */
 export function a11y_role_has_required_aria_props(node, values) {
 	w(node, 'a11y_role_has_required_aria_props', `${`Elements with the ARIA role "${values.role}" must have the following attributes defined: ${values.props}`}\nhttps://svelte.dev/e/${'a11y_role_has_required_aria_props'}`);
@@ -470,7 +470,7 @@ export function a11y_role_has_required_aria_props(node, values) {
 /**
  * The attribute '%attribute%' is not supported by the role '%role%'
  * @param {null | NodeLike} node
- * @param {{ "attribute": string, "role": string }} values
+ * @param {{ "attribute": string; "role": string }} values
  */
 export function a11y_role_supports_aria_props(node, values) {
 	w(node, 'a11y_role_supports_aria_props', `${`The attribute '${values.attribute}' is not supported by the role '${values.role}'`}\nhttps://svelte.dev/e/${'a11y_role_supports_aria_props'}`);
@@ -479,7 +479,7 @@ export function a11y_role_supports_aria_props(node, values) {
 /**
  * The attribute '%attribute%' is not supported by the role '%role%'. This role is implicit on the element `<%name%>`
  * @param {null | NodeLike} node
- * @param {{ "attribute": string, "role": string, "name": string }} values
+ * @param {{ "attribute": string; "role": string; "name": string }} values
  */
 export function a11y_role_supports_aria_props_implicit(node, values) {
 	w(node, 'a11y_role_supports_aria_props_implicit', `${`The attribute '${values.attribute}' is not supported by the role '${values.role}'. This role is implicit on the element \`<${values.name}>\``}\nhttps://svelte.dev/e/${'a11y_role_supports_aria_props_implicit'}`);
@@ -488,7 +488,7 @@ export function a11y_role_supports_aria_props_implicit(node, values) {
 /**
  * Unknown aria attribute 'aria-%attribute%'
  * @param {null | NodeLike} node
- * @param {{ "attribute": string } | { "attribute": string, "suggestion": string }} values
+ * @param {{ "attribute": string; "suggestion"?: string }} values
  */
 export function a11y_unknown_aria_attribute(node, values) {
 	w(node, 'a11y_unknown_aria_attribute', `${(values?.suggestion !== undefined ? `Unknown aria attribute 'aria-${values.attribute}'. Did you mean '${values.suggestion}'?` : `Unknown aria attribute 'aria-${values.attribute}'`)}\nhttps://svelte.dev/e/${'a11y_unknown_aria_attribute'}`);
@@ -497,7 +497,7 @@ export function a11y_unknown_aria_attribute(node, values) {
 /**
  * Unknown role '%role%'
  * @param {null | NodeLike} node
- * @param {{ "role": string } | { "role": string, "suggestion": string }} values
+ * @param {{ "role": string; "suggestion"?: string }} values
  */
 export function a11y_unknown_role(node, values) {
 	w(node, 'a11y_unknown_role', `${(values?.suggestion !== undefined ? `Unknown role '${values.role}'. Did you mean '${values.suggestion}'?` : `Unknown role '${values.role}'`)}\nhttps://svelte.dev/e/${'a11y_unknown_role'}`);
@@ -515,7 +515,7 @@ export function bidirectional_control_characters(node, values) {
 /**
  * `%code%` is no longer valid — please use `%suggestion%` instead
  * @param {null | NodeLike} node
- * @param {{ "code": string, "suggestion": string }} values
+ * @param {{ "code": string; "suggestion": string }} values
  */
 export function legacy_code(node, values) {
 	w(node, 'legacy_code', `${`\`${values.code}\` is no longer valid — please use \`${values.suggestion}\` instead`}\nhttps://svelte.dev/e/${'legacy_code'}`);
@@ -524,7 +524,7 @@ export function legacy_code(node, values) {
 /**
  * `%code%` is not a recognised code
  * @param {null | NodeLike} node
- * @param {{ "code": string } | { "code": string, "suggestion": string }} values
+ * @param {{ "code": string; "suggestion"?: string }} values
  */
 export function unknown_code(node, values) {
 	w(node, 'unknown_code', `${(values?.suggestion !== undefined ? `\`${values.code}\` is not a recognised code (did you mean \`${values.suggestion}\`?)` : `\`${values.code}\` is not a recognised code`)}\nhttps://svelte.dev/e/${'unknown_code'}`);
@@ -668,7 +668,7 @@ export function reactive_declaration_module_script_dependency(node, values) {
 /**
  * This reference only captures the initial value of `%name%`. Did you mean to reference it inside a %type% instead?
  * @param {null | NodeLike} node
- * @param {{ "name": string, "type": string }} values
+ * @param {{ "name": string; "type": string }} values
  */
 export function state_referenced_locally(node, values) {
 	w(node, 'state_referenced_locally', `${`This reference only captures the initial value of \`${values.name}\`. Did you mean to reference it inside a ${values.type} instead?`}\nhttps://svelte.dev/e/${'state_referenced_locally'}`);
@@ -722,7 +722,7 @@ export function attribute_illegal_colon(node, values) {
 /**
  * '%wrong%' is not a valid HTML attribute. Did you mean '%right%'?
  * @param {null | NodeLike} node
- * @param {{ "wrong": string, "right": string }} values
+ * @param {{ "wrong": string; "right": string }} values
  */
 export function attribute_invalid_property_name(node, values) {
 	w(node, 'attribute_invalid_property_name', `${`'${values.wrong}' is not a valid HTML attribute. Did you mean '${values.right}'?`}\nhttps://svelte.dev/e/${'attribute_invalid_property_name'}`);
@@ -767,7 +767,7 @@ export function component_name_lowercase(node, values) {
 /**
  * This element is implicitly closed by the following `%tag%`, which can cause an unexpected DOM structure. Add an explicit `%closing%` to avoid surprises.
  * @param {null | NodeLike} node
- * @param {{ "tag": string, "closing": string }} values
+ * @param {{ "tag": string; "closing": string }} values
  */
 export function element_implicitly_closed(node, values) {
 	w(node, 'element_implicitly_closed', `${`This element is implicitly closed by the following \`${values.tag}\`, which can cause an unexpected DOM structure. Add an explicit \`${values.closing}\` to avoid surprises.`}\nhttps://svelte.dev/e/${'element_implicitly_closed'}`);
@@ -848,7 +848,7 @@ export function svelte_element_invalid_this(node, values) {
 /**
  * `<svelte:self>` is deprecated — use self-imports (e.g. `import %name% from './%basename%'`) instead
  * @param {null | NodeLike} node
- * @param {{ "name": string, "basename": string }} values
+ * @param {{ "name": string; "basename": string }} values
  */
 export function svelte_self_deprecated(node, values) {
 	w(node, 'svelte_self_deprecated', `${`\`<svelte:self>\` is deprecated — use self-imports (e.g. \`import ${values.name} from './${values.basename}'\`) instead`}\nhttps://svelte.dev/e/${'svelte_self_deprecated'}`);
diff --git a/packages/svelte/src/internal/client/errors.js b/packages/svelte/src/internal/client/errors.js
index 334f4aa0be..94acd4ba9c 100644
--- a/packages/svelte/src/internal/client/errors.js
+++ b/packages/svelte/src/internal/client/errors.js
@@ -36,7 +36,7 @@ export function bind_invalid_checkbox_value(values) {
 
 /**
  * Component %component% has an export named `%key%` that a consumer component is trying to access using `bind:%key%`, which is disallowed. Instead, use `bind:this` (e.g. `<%name% bind:this={component} />`) and then access the property on the bound component instance (e.g. `component.%key%`)
- * @param {{ "component": string, "key": string, "name": string }} values
+ * @param {{ "component": string; "key": string; "name": string }} values
  * @returns {never}
  */
 export function bind_invalid_export(values) {
@@ -51,7 +51,7 @@ export function bind_invalid_export(values) {
 
 /**
  * A component is attempting to bind to a non-bindable property `%key%` belonging to %component% (i.e. `<%name% bind:%key%={...}>`). To mark a property as bindable: `let { %key% = $bindable() } = $props()`
- * @param {{ "key": string, "component": string, "name": string }} values
+ * @param {{ "key": string; "component": string; "name": string }} values
  * @returns {never}
  */
 export function bind_not_bindable(values) {
@@ -66,7 +66,7 @@ export function bind_not_bindable(values) {
 
 /**
  * Calling `%method%` on a component instance (of %component%) is no longer valid in Svelte 5
- * @param {{ "method": string, "component": string }} values
+ * @param {{ "method": string; "component": string }} values
  * @returns {never}
  */
 export function component_api_changed(values) {
@@ -81,7 +81,7 @@ export function component_api_changed(values) {
 
 /**
  * Attempted to instantiate %component% with `new %name%`, which is no longer valid in Svelte 5. If this component is not under your control, set the `compatibility.componentApi` compiler option to `4` to keep it working.
- * @param {{ "component": string, "name": string }} values
+ * @param {{ "component": string; "name": string }} values
  * @returns {never}
  */
 export function component_api_invalid_new(values) {
@@ -111,7 +111,7 @@ export function derived_references_self(values) {
 
 /**
  * Keyed each block has duplicate key at indexes %a% and %b%
- * @param {{ "a": string, "b": string } | { "a": string, "b": string, "value": string }} values
+ * @param {{ "a": string; "b": string; "value"?: string }} values
  * @returns {never}
  */
 export function each_key_duplicate(values) {
@@ -126,7 +126,7 @@ export function each_key_duplicate(values) {
 
 /**
  * Keyed each block has key that is not idempotent — the key for item at index %index% was `%a%` but is now `%b%`. Keys must be the same each time for a given item
- * @param {{ "index": string, "a": string, "b": string }} values
+ * @param {{ "index": string; "a": string; "b": string }} values
  * @returns {never}
  */
 export function each_key_volatile(values) {
diff --git a/packages/svelte/src/internal/client/warnings.js b/packages/svelte/src/internal/client/warnings.js
index 81ea2913fd..83d9088b58 100644
--- a/packages/svelte/src/internal/client/warnings.js
+++ b/packages/svelte/src/internal/client/warnings.js
@@ -7,7 +7,7 @@ var normal = 'font-weight: normal';
 
 /**
  * Assignment to `%property%` property (%location%) will evaluate to the right-hand side, not the value of `%property%` following the assignment. This may result in unexpected behaviour.
- * @param {{ "property": string, "location": string }} values
+ * @param {{ "property": string; "location": string }} values
  */
 export function assignment_value_stale(values) {
 	if (DEV) {
@@ -39,7 +39,7 @@ export function await_reactivity_loss(values) {
 
 /**
  * An async derived, `%name%` (%location%) was not read immediately after it resolved. This often indicates an unnecessary waterfall, which can slow down your app
- * @param {{ "name": string, "location": string }} values
+ * @param {{ "name": string; "location": string }} values
  */
 export function await_waterfall(values) {
 	if (DEV) {
@@ -55,7 +55,7 @@ export function await_waterfall(values) {
 
 /**
  * `%binding%` is binding to a non-reactive property
- * @param {{ "binding": string } | { "binding": string, "location": string }} values
+ * @param {{ "binding": string; "location"?: string }} values
  */
 export function binding_property_non_reactive(values) {
 	if (DEV) {
@@ -103,7 +103,7 @@ export function derived_inert(values) {
 
 /**
  * %handler% should be a function. Did you mean to %suggestion%?
- * @param {{ "handler": string, "suggestion": string }} values
+ * @param {{ "handler": string; "suggestion": string }} values
  */
 export function event_handler_invalid(values) {
 	if (DEV) {
@@ -135,7 +135,7 @@ export function hydratable_missing_but_expected(values) {
 
 /**
  * The `%attribute%` attribute on `%html%` changed its value between server and client renders. The client value, `%value%`, will be ignored in favour of the server value
- * @param {{ "attribute": string, "html": string, "value": string }} values
+ * @param {{ "attribute": string; "html": string; "value": string }} values
  */
 export function hydration_attribute_changed(values) {
 	if (DEV) {
@@ -231,7 +231,7 @@ export function lifecycle_double_unmount(values) {
 
 /**
  * %parent% passed property `%prop%` to %child% with `bind:`, but its parent component %owner% did not declare `%prop%` as a binding. Consider creating a binding between %owner% and %parent% (e.g. `bind:%prop%={...}` instead of `%prop%={...}`)
- * @param {{ "parent": string, "prop": string, "child": string, "owner": string }} values
+ * @param {{ "parent": string; "prop": string; "child": string; "owner": string }} values
  */
 export function ownership_invalid_binding(values) {
 	if (DEV) {
@@ -247,7 +247,7 @@ export function ownership_invalid_binding(values) {
 
 /**
  * Mutating unbound props (`%name%`, at %location%) is strongly discouraged. Consider using `bind:%prop%={...}` in %parent% (or using a callback) instead
- * @param {{ "name": string, "location": string, "prop": string, "parent": string }} values
+ * @param {{ "name": string; "location": string; "prop": string; "parent": string }} values
  */
 export function ownership_invalid_mutation(values) {
 	if (DEV) {
diff --git a/packages/svelte/src/internal/server/errors.js b/packages/svelte/src/internal/server/errors.js
index da656caa9b..e1bbed5821 100644
--- a/packages/svelte/src/internal/server/errors.js
+++ b/packages/svelte/src/internal/server/errors.js
@@ -50,7 +50,7 @@ export function html_deprecated(values) {
  * Attempted to set `hydratable` with key `%key%` twice with different values.
 
 %stack%
- * @param {{ "key": string, "stack": string }} values
+ * @param {{ "key": string; "stack": string }} values
  * @returns {never}
  */
 export function hydratable_clobbering(values) {
@@ -68,7 +68,7 @@ ${values.stack}`}\nhttps://svelte.dev/e/${'hydratable_clobbering'}`);
 
 Cause:
 %stack%
- * @param {{ "key": string, "stack": string }} values
+ * @param {{ "key": string; "stack": string }} values
  * @returns {never}
  */
 export function hydratable_serialization_failed(values) {
diff --git a/packages/svelte/src/internal/server/warnings.js b/packages/svelte/src/internal/server/warnings.js
index 11b04c02a1..11aa69c546 100644
--- a/packages/svelte/src/internal/server/warnings.js
+++ b/packages/svelte/src/internal/server/warnings.js
@@ -10,7 +10,7 @@ var normal = 'font-weight: normal';
 
 The `hydratable` was initialized in:
 %stack%
- * @param {{ "key": string, "stack": string }} values
+ * @param {{ "key": string; "stack": string }} values
  */
 export function unresolved_hydratable(values) {
 	if (DEV) {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e5a866e7fa..433bc59584 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -133,8 +133,8 @@ importers:
         specifier: ^3.0.2
         version: 3.0.2(rollup@4.62.2)
       '@sveltejs/message-box':
-        specifier: ^1.1.1
-        version: 1.1.1
+        specifier: ^1.1.2
+        version: 1.1.2
       '@types/aria-query':
         specifier: ^5.0.4
         version: 5.0.4
@@ -940,8 +940,8 @@ packages:
       typescript: '>= 5'
       typescript-eslint: '>= 8'
 
-  '@sveltejs/message-box@1.1.1':
-    resolution: {integrity: sha512-4Qab06sApD/yZXCZb3we9qYh2ZNslSlAlqc+LCkkPBloNqwFiBTg/lf4/XloXY4T0xKODUyFK7lhNYafNWeIHw==}
+  '@sveltejs/message-box@1.1.2':
+    resolution: {integrity: sha512-VIr0VaTmMOhGyt1hT9isSuNcaK3qkYVMma/gDeNUH4yGQs1Va4Diw8mPkqi0MygCKE0OqdyrHk1OnxSeOns3Zg==}
 
   '@sveltejs/vite-plugin-svelte-inspector@5.0.1':
     resolution: {integrity: sha512-ubWshlMk4bc8mkwWbg6vNvCeT7lGQojE3ijDh3QTR6Zr/R+GXxsGbyH4PExEPpiFmqPhYiVSVmHBjUcVc1JIrA==}
@@ -3078,7 +3078,7 @@ snapshots:
       typescript: 5.5.4
       typescript-eslint: 8.56.0(eslint@10.0.0)(typescript@5.5.4)
 
-  '@sveltejs/message-box@1.1.1': {}
+  '@sveltejs/message-box@1.1.2': {}
 
   '@sveltejs/vite-plugin-svelte-inspector@5.0.1(@sveltejs/vite-plugin-svelte@6.2.0(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0)))(svelte@packages+svelte)(vite@7.3.5(@types/node@24.5.2)(lightningcss@1.23.0)(sass@1.70.0)(terser@5.27.0))':
     dependencies:

From 48a405cbc3d6510d08553b563396981895ef73a4 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Tue, 1 Sep 2026 17:03:18 +0100
Subject: [PATCH 5/5] prettier

---
 packages/svelte/scripts/process-messages/index.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/svelte/scripts/process-messages/index.js b/packages/svelte/scripts/process-messages/index.js
index 97e1868f1a..037b904952 100644
--- a/packages/svelte/scripts/process-messages/index.js
+++ b/packages/svelte/scripts/process-messages/index.js
@@ -38,9 +38,9 @@ function run() {
 				messages[category][message.code] = message;
 			}
 
-			const sorted = Array.from(
-				markdown.matchAll(/## ([\w]+)\n\n([^]+?)(?=$|\n\n## )/g),
-			).map((m) => m[0]).sort();
+			const sorted = Array.from(markdown.matchAll(/## ([\w]+)\n\n([^]+?)(?=$|\n\n## )/g))
+				.map((m) => m[0])
+				.sort();
 
 			fs.writeFileSync(
 				`messages/${category}/${file}`,